Search

The balanced hypercube B H n plays an essential role in large-scale parallel and distributed computing systems. With the increasing probability of edge faults in large-scale networks and the widespread applications of Hamiltonian paths and cycles, it is especially essential to study the fault tolerance of networks in the presence of Hamiltonian paths and cycles. However, existing researches on edge faults ignore that it is almost impossible for all faulty edges to be concentrated in a certain dimension. Thus, the fault tolerance performance of interconnection networks is severely underestimated. This paper focuses on three measures, t -partition-edge fault-tolerant Hamiltonian, t -partition-edge fault-tolerant Hamiltonian laceable, and t -partition-edge fault-tolerant strongly Hamiltonian laceable, and utilizes these measures to explore the existence of Hamiltonian paths and cycles in balanced hypercubes with exponentially faulty edges. We show that the B H n is 2 n − 1 -partition-edge fault-tolerant Hamiltonian laceable, 2 n − 1 -partition-edge fault-tolerant Hamiltonian, and (2 n − 1 − 1) -partition-edge fault-tolerant strongly Hamiltonian laceable for n ≥ 2. Comparison results show the partitioned fault model can provide the exponential fault tolerance as the value of the dimension n grows. • Based on the partitioned fault model, this paper propose three novel indicators for the balanced hypercubes B H n. • B H n is 2 n − 1 (resp. 2 n − 1 − 1)-partition-edge fault-tolerant (resp. strongly) Hamiltonian laceable. • Comparison results show the partitioned fault model can provide exponential fault tolerance as the dimension n grows. [ABSTRACT FROM AUTHOR]

Classic synchronous consensus algorithms are leaderless in that processes exchange proposals, choose the maximum value and decide when they see the same choice across a couple of rounds. Indulgent consensus algorithms are typically leader-based. Although they tolerate unexpected delays and find practical applications in blockchains running over an open network like the Internet, their performance is highly dependent on the activity of a single participant. This paper asks whether, under eventual synchrony, it is possible to deterministically solve consensus without a leader. The fact that the weakest failure detector to solve consensus is one that also eventually elects a leader seems to indicate that the answer to the question is negative. We prove in this paper that the answer is actually positive. We first give a precise definition of the very notion of a leaderless algorithm. Then we present three indulgent leaderless consensus algorithms, each we believe interesting in its own right: (i) for shared memory, (ii) for message passing with omission failures and (iii) for message passing with Byzantine failures. Finally, we implement a Byzantine fault tolerant (BFT) state machine replication (SMR), that is leaderless. Our empirical results demonstrate that it is faster and more robust than HotStuff, the recent BFT SMR algorithm used in the Facebook Libra blockchain when deployed in a wide area network. • Eventually synchronous consensus algorithms are leader-based. We show that they can be leaderless. • We propose a formal definition of leaderless consensus algorithm. • We propose a didactic construction of a byzantine fault tolerant consensus algorithm. • We prove correctness. [ABSTRACT FROM AUTHOR]

This paper investigates the exploitation of heterogeneous DVFS (dynamic voltage frequency scaling) control for improving the energy efficiency of data-parallel applications on ccNUMA shared-memory systems. We propose to adjust the clock frequency individually for the appropriately selected groups of cores, taking into account the diversified costs of parallel computation. This paper aims to evaluate the proposed approach using two different data-parallel applications: solving the 3D diffusion problem, and MPDATA fluid dynamics application. As a result, we observe the energy-savings gains of up to 20 percentage points over the traditional homogeneous frequency scaling approach on the server with two 18-core Intel Xeon Gold 6240. Additionally, we confirm the effectiveness of our strategy using two 64-core AMD EPYC 7773X. This paper also introduces two pruning algorithms that help select the optimal heterogeneous DVFS setups taking into account the energy or performance profile of studied applications. Finally, the cost and efficiency of developed algorithms are verified and compared experimentally against the brute-force search. • Heterogeneous DVFS method for energy efficiency of regular data-parallel applications. • Individually adjusting clock frequency for cores based on workload distribution. • Pruning algorithms for selecting optimal heterogeneous DVFS setups. [ABSTRACT FROM AUTHOR]

Cloud computing environments are indispensable components of the majority of information technology organizations and users' lives. Despite multiple benefits of cloud computing environments, cloud users (CUs) as well as cloud service providers (CSPs) may experience unpleasant conditions by detrimental results of distributed denial of service (DDoS) attacks such as unavailability of cloud services or lengthy response times of the services. In this paper, we provide a threshold anomaly-based DDoS attack detection method to protect cloud environments against DDoS attack. Our proposed method is introduced to reduce DDoS attack consequences in CSPs. Our suggested method includes three newly defined components: 1. A third party auditor (TPA) which acquires direct interaction with each datacenter of the CSP, 2. A zone delimiter (ZD) which encapsulates the sensitive internal specifications of a CSP from TPA, and 3. A protocol which is defined to coordinate TPA, ZD, and CSPs for DDoS attack detection via TPA. We analyze our proposed method by determining and conducting a simulation strategy for an intrusion detection system in CSPs. Results illustrate that interactive communication between TPA and datacenters of CSPs improves the user experience of CUs in the time of DDoS attacks by reducing excessive attack filtering stages. Moreover, by using an intrusion detection system (IDS), we investigate efficiency of the proposed method to recover CSPs from DDoS attacks. We further indicate the efficiency of our proposed method by providing accuracy and qualitative comparisons with other existing methods. • A cloud auditor detects Denial of Service or Distributed Denial of Service attacks in services of a Cloud Service Provider. • Interactive communication between cloud auditor and datacenters improves the user experience in the time of attacks. • When attacks remain undetected, cloud users will not experience any unusual condition such as long response time. • When attacks remain undetected, hosts will not experience any unusual condition such as overheating the hardware. • This method functions completely independent from any other intrusion detection mechanism or filtration method. [ABSTRACT FROM AUTHOR]

Batched linear solvers, which solve many small related but independent problems, are increasingly important for highly parallel processors such as graphics processing units (GPUs). GPUs need a substantial amount of work to keep them operating efficiently and it is not an option to solve smaller problems one-by-one. Because of the small size of each problem, the task of implementing a parallel partitioning scheme and mapping the problem to hardware is not trivial. In recent history, significant attention has been given to batched dense linear algebra. However, there is also an interest in utilizing sparse iterative solvers in a batched form. An example use case is found in a gyrokinetic Particle-In-Cell (PIC) code used for modeling magnetically confined fusion plasma devices. The collision operator has been identified as a bottleneck, and a proxy app has been created for facilitating optimizations and porting to GPUs. The current collision kernel linear solver does not run on the GPU—a major bottleneck. As these matrices are sparse and well-conditioned, batched iterative sparse solvers are an attractive option. A batched sparse iterative solver capability has recently been developed in the Ginkgo library. In this paper, we describe how Ginkgo 's batched solver technology can integrate into the XGC collision kernel and accelerate the simulation process. Comparisons for the solve times on NVIDIA V100 and A100 GPUs and AMD MI100 GPUs with one dual-socket Intel Xeon Skylake CPU node with 40 cores are presented for matrices from the collision kernel of XGC. Further, the speedups observed for the overall collision kernel are presented in comparison to different modern CPUs on multiple supercomputer systems. The results suggest that Ginkgo 's batched sparse iterative solvers are well suited for efficient utilization of the GPU for this problem, and the performance portability of Ginkgo in conjunction with Kokkos (used within XGC as the heterogeneous programming model) allows seamless execution on exascale-oriented heterogeneous architectures. • Fast batched sparse iterative linear solvers for modern graphics processing units. • Implementation of different batched sparse matrix formats. • Automatic tuning of shared memory utilization on the GPU. • Strategy for integration into the plasma simulation code XGC via Kokkos. • Performance results on various CPUs and V100, A100 and MI100 GPUs. [ABSTRACT FROM AUTHOR]

Water distribution networks (WDNs) are one of the largest infrastructures in society. Various methods for formulation and hydraulic analysis of water distribution networks, including numerical and non-numerical methods, have been previously proposed. Due to the complexity, the nonlinearity of the hydraulic equations of water distribution networks, and the need for multiple executions and uncertainties in parameters, solving the hydraulic model of water distribution networks has high time complexity. In this paper, a parallel computational architecture based on the concept of cellular automata is proposed to accelerate the numerical solution of the steady-state water distribution network model. Taylor series is proposed to solve hydraulic equations. The presented architecture was implemented as a parallel hardware platform on a field-programmable gate array. The performance of the proposed method was compared with EPANET software for networks with different complexities and topologies. The results show that the proposed parallel algorithm can accelerate the hydraulic analysis of regular water distribution networks up to 700 times and 250 times for small and large networks, respectively. • Proposed CA architectures to solve a system of non-linear equations on a fine-grain parallel architecture. • An efficient method to reduce computation time for hydraulic analysis of water networks. • The synthesizable hardware descriptions were generated through design automation. • Accelerate the hydraulic analysis of WDNs up to 700 times compared to EPANET, a well-known hydraulic analysis tool. [ABSTRACT FROM AUTHOR]

In an embedded and resource-constrained environment, Elliptic Curve Cryptography (ECC) has been noted as an efficient and suitable methodology for achieving information security via public-key cryptography. However, the drawback of ECC is its lack of unifiedness in point operation that makes it prone to side-channel attack. Also, ECC does not satisfy the completeness property due to which the addition formula is not defined for all the pairs of input points. Edward curve, with its unified addition law and completeness property, proved to be the answer to aforementioned flaws. High throughput while maintaining low resource is a key issue for elliptic curve cryptography (ECC) hardware implementations in many applications. This paper presents the implementation of a Binary Edward curve Crypto processor over G F (2 233) for FPGA platforms. The architecture is modified to perform scalar multiplication in a parallel manner using two hybrid Karatsuba field multipliers. Field inversion being one of the most tedious operations while reconversion, is also performed in a parallel manner using an efficient Hex Itoh-Tsujii inversion algorithm. The hardware resources are shared for performing point operations and inversion. Exploiting parallelism in point and inversion operations has resulted in reduction of the clock cycles consumed and the resultant architecture is more efficient in terms of throughput over area. The design takes 0.038 ms on Xilinx Virtex-4 and 0.031 ms on Virtex-7 FPGA platforms to perform a 233-bit point multiplication operation. It takes 73.57%, 13.71%, 14.76% and 48.76% more efficient than existing scalar multiplication with BEC. This proposed scalable, side-channel attack resilient design outperforms the existing techniques with respect to throughput over area. • The parallelism in BEC is done with two modular hybrid Karatsuba multiplier. • Inversion in reconversion is done with new Hex-Itoh Tsujii inversion algorithm (HITA). • Point operation and HITA uses the same resources with reduced clock cycles. • This architecture is designed for FPGA platforms yielding high throughput and area-time performance. [ABSTRACT FROM AUTHOR]

The paper aims at mitigating hot-spots during Offline Scheduling in IaaS (Infrastructure-as-a-Service) cloud systems. Unlike previous studies, the research focuses on identifying and resolving hot-spots not at servers, but at server racks. A two-phase algorithm for performing power-aware offline scheduling is proposed. The first phase aims at identifying and mitigating hot-spots at racks, while the second phase performs VM consolidation, i.e. minimization of the number of occupied servers while maintaining a feasible VM mapping and low migration costs. The proposed algorithm takes into account the dynamic nature of VM's resource consumption: it does not only resolve detected hot-spots, but also tries to avoid hot-spots in a reasonable future time period. The algorithm was tested with the data from a real IaaS cloud with different sets of algorithm's parameters. Experimental evaluation showed that the statistical estimates of the future VM's resource consumption provide the most reliable mapping, which is a result of minimization of the number of new hot-spot occurrences. • A server rack is a hot-spot if it exceeds the upper bound of power consumption. • Hot-spot identification, mitigation, and avoidance is crucial for IaaS systems. • An algorithm is proposed for rack hot-spot mitigation and consolidation of VMs. • Considering future CPU utilization values is associated with migrating more memory. • Ignoring future CPU utilization values leads to more new hot-spots happening shortly. [ABSTRACT FROM AUTHOR]

Three-way concept analysis (3WCA) is a framework based on Formal concept analysis and three-way decisions is used in the field of knowledge discovery to solve uncertainties in many domains like machine learning, data mining and software engineering. The 3WCA requires both the formal context and its complement context for generating concepts and constructing the concept lattice. In three-way concept analysis, data are analyzed using two types of concept lattices constructed using classical formal concept analysis (FCA) algorithms: object-induced (OE) concept lattices and attribute-induced (AE) concept lattices. The existing formal concept analysis algorithms focus on the sequential generation of OE and AE concepts rather than finding them in parallel and cannot process large datasets efficiently. The main contribution of this paper is that we propose a novel parallel algorithm for concept generation and construction of the three way concept lattice for knowledge discovery and representation in large datasets. Aiming to construct an efficient algorithm for 3WCA, this paper primarily discusses the existing algorithms for concept generation. Further we develop an efficient algorithm for OE and AE concept generation and lattice construction. Extensive experiments are conducted on various datasets to evaluate the efficiency of the proposed algorithm. Both the experimental and statistical results demonstrate the efficacy of the algorithm on larger datasets. Also the proposed algorithm can significantly decrease the time required for OE/AE concept generation and lattice construction compared to the existing classical FCA algorithms. • This article proposes an efficient distributed algorithm for performing three-way concept analysis (3WCA). • The proposed algorithm distributes the input data across the cluster and performs in-memory computations. • The experimental and statistical validations prove that the proposed algorithm is efficient for 3WCA. [ABSTRACT FROM AUTHOR]

Generally, the computational grid consists of a large number of computing nodes, some of them are idle due to the uneven geographical distribution of computing requirements. This may cause workload unbalancing problems, which affect the performance of large-scale computational grids. In order to balance the computing requirements and computing nodes, we propose a job scheduling algorithm based on the workload prediction of computing nodes. We first analyze the causes of workload imbalance and the feasibility of reallocating computing resources. Secondly, we design an application and workload-aware scheduling algorithm (AWAS) by combining the previously designed workload prediction model. To reduce the complexity of the AWAS algorithm, we propose a parallel job scheduling method based on computing node workload prediction. The experiments show that the AWAS algorithm can balance the workload among different computing nodes on the real-world dataset. In addition, we propose the parallelism of workload prediction model from the perspective of internal structure and data set to make AWAS apply to more computing nodes of the large-scale computing grids. Experimental results show that the combination of the two can achieve satisfactory acceleration efficiency. • In this paper, we propose an application and grid computing nodes workload aware scheduling algorithm (AWAS). • AWAS optimizes grid loads using greedy and heuristic methods. • This paper parallelizes the scheduling process of AWAS to improve its efficiency. • The experiment results show that the AWAS can achieve workload balancing in China National Grid. [ABSTRACT FROM AUTHOR]

• This paper presents a clustered routing algorithm with authentication capability. • This routing method prioritizes data packets based on their type. • This paper suggests a suitable clustering algorithm. • This scheme reduces end to end delay and improves packet delivery rate. • The proposed method compare with three routing methods indicates its superiority. Routing is challenging in vehicular ad hoc networks due to their features, such as high mobility of nodes and unstable wireless communication links. Therefore, it is an interesting issue for researchers. In addition, it is very important to design an authentication mechanism between the source node and the destination node because these networks are exposed to many attacks due to their features mentioned above. In this paper, we present a fuzzy logic-based routing method with authentication capability in vehicular ad hoc networks. The proposed routing method has three phases: clustering phase, routing phase between cluster head nodes, and authentication phase. In the first phase, vehicles are clustered using an efficient scheme. In the proposed method, we define two types of data packets: immediate and ordinary. Various data packets have different route discovery processes that are described in Phase 2. Note that any data packet type is divided into two groups: simple and secure. Simple data packets have no authentication mechanism. On the other hand, secure data packets use an authentication mechanism based on message authentication code (MAC) and symmetric key cryptography. We simulate the proposed method using NS2. Simulation results are compared with three routing protocols including, AODV, R 2 SCDT , and 3VSR. Experiments show that the proposed method outperforms others in terms of end-to-end delay, packet collision, packet delivery rate (PDR), packet loss rate (PLR), and throughput. However, it increases the routing overhead slightly. [ABSTRACT FROM AUTHOR]

The decomposition-based multi-objective evolutionary algorithm first generates a set of weight vectors in advance, and it is very important to select a set of appropriate weight vectors for the decomposition-based algorithm. A variety of weight vector generation methods have been proposed in the existing algorithms, but in most algorithms, a pre-defined weight vector generation method is still used, the pre-defined weight vector is too specialized for the simplex-like front surface, which results in poor performance on the front surface with irregularities. At the same time, most of the existing algorithms have proposed many new adaptive strategies for weight vectors, but if you generate a set of more suitable weight vectors at the beginning, and then use the update strategy, it can make the algorithm achieve a better balance between diversity and convergence. In order to select a suitable weight vector, this paper proposes a multi-stage MOEA to select a suitable weight vector. The algorithm is divided into multiple stages according to the evolution process, first of all, in the early stage of evolution, the reliability of multiple weight vector generation methods was evaluated according to the spearman correlation coefficient in statistics, choose the most suitable weight generation method; Secondly, this method can be applied to the search for high-quality solutions in the middle of evolution; Finally, a weight vector adaptive strategy is adopted in the overall evolution process. In the experiment, the proposed algorithm was analyzed in the benchmark test problem, mechanical bearing and light aircraft gear reducer. The experimental results show the effectiveness of the proposed algorithm. • This paper proposes a multi-stage and multi-objective algorithm. • A method of judging the reliability of the weight vector is proposed. • Proposed a way to find high-quality solutions. • Compare with other 15 algorithms in 47 test questions. • Optimized mechanical bearings and gear reducers. [ABSTRACT FROM AUTHOR]

• The adaptive bulk search is a QUBO solver alternative to quantum annealing. • The cyclic-min algorithm is a SA-like algorithm without random number generation. • The bit permutated cyclic-min algorithm provides near-optimal solutions for QUBO. • Our scalable implementation attains linear improvement of the search rate. A wide range of combinatorial optimization problems can be reduced to the Ising model, and equivalently the quadratic unconstrained binary optimization (QUBO) problem. Thus, in recent years, researchers have proposed to solve QUBO on FPGAs, GPUs, and special-purpose processors. The adaptive bulk search (ABS) is a previously-proposed framework for solving QUBO in parallel on multiple GPUs. In the ABS, a CPU host performs a GA-based global search while GPUs asynchronously perform many local searches in parallel. An original ABS adopts a simple local search algorithm called a cyclic-min algorithm, which does not use pseudo random numbers. However, the lack of randomness may cause a potential drawback of restricted bit-flipping operations in a local search. To avoid this drawback, this paper proposes a cyclic-min algorithm with randomly-generated multiple bit permutations, which enables a more effective local search with random number generation in CPUs (not in GPUs). Furthermore, this paper introduces a scalable implementation of the ABS with MPI and OpenMP. Our experimental results on TSUBAME3.0 show that the solution quality improves and the throughput linearly increases as the number of GPUs increases; with 256 GPUs, it evaluates 20.1 × 10 12 solutions per second. [ABSTRACT FROM AUTHOR]

The number of Vehicle Equipment (VE) connected to the Internet is increasing, and these VEs generate tasks that contain large amounts of data. Processing these tasks requires a lot of computing resources. Therefore, it is a promising issue that offloading compute-intensive tasks from resource-limited vehicles to Vehicular Edge Computing (VEC) servers, which involves big data transmission, processing and computation. In a network, multiple providers provide VEC servers. When a vehicle generates a task, our goal is to make an intelligent decision on whether and when to offload this task to VEC servers to minimize the task completion time and total big data processing time. When each vehicle passes VEC servers, the vehicle can decide to offload its task to the VEC server in the current communication range, or continue to drive until it reaches the next server's communication range. This issue can be considered as an asset selling problem. It is a challenging issue to make a smart decision for the vehicle with a location view because the vehicle is not sure when the next VEC server will be available and how much about the available computing capacity of the next VEC server. Firstly, this paper formulates the problem as a Markov Decision Process (MDP), defines and analyzes the state set, action set, reward model, and state transition probability distribution. Then it uses Asynchronous Advantage Actor-Critic (A3C) algorithm to solve this MDP problem, builds the various elements of the A3C algorithm, uses Actor (the strategy function) to generate two actions of the vehicle: offloading and moving without offloading. Thirdly, it uses Critic (the value function) to evaluate Actor's behavior, and guide Actor's actions in subsequent stages. The Actor starts from the initial state in the state space until it enters the termination state, forming a complete decision-making process. It minimizes the completion time of task offloading through learning thereby reducing the delay of big data processing. Compared to the Immediately Offload (IO) scheme and Expect Offload (EO) scheme, the MIDP scheme proposed in this paper reduces the average task offloading delay to 29.93% and 29.99%, close to the EO scheme in terms of task completion rate and up to 66.6% improvement compared to the IO scheme. • A task offloading approach in Internet of Vehicles (IoV) is proposed. • An MDP-based Intelligent Big Data Processing (MIDP) Scheme is proposed. • Simulations demonstrate the better performances of MIDP scheme. [ABSTRACT FROM AUTHOR]

Data sharing is increasingly popular especially for scientific research and business fields where large volume of datasets need to be used, but it involves data security and privacy concerns. This paper mitigates such concerns by tracking and logging the history of shared data (i.e., provenance records) while preserving data privacy. This is a challenging problem in the data sharing scenario in this paper because the environment is decentralized and internal logs are not accessible publicly due to privacy concerns. We present ProvNet, a decentralized data sharing platform that can detect malicious users and provide secure provenance records using the newly proposed networked blockchain without disclosing raw data contents. Valid sharing records are collected and stored in the blocknet and misbehavior is detected with the stored provenance records according to our accountable protocols. We give a proof-of-concept implementation, and evaluation results show that the overhead is acceptable. • A networked blockchain, blocknet, stores data sharing records bi-directionally. • Using MinHash to check datasets' similarities, thus protect data ownership. • Chameleon Hash is leveraged to add future pointers without changing previous hashes. • A provenance graph built from blocknet, provides users' trackability on shared data. • Prototye performance is acceptable, an indexing system designed for optimization. [ABSTRACT FROM AUTHOR]

In recent decades, the exponential growth of applications has intensified traffic demands, posing challenges in ensuring optimal user experiences within modern networks. Traditional congestion avoidance and control mechanisms embedded in conventional routing struggle to promptly adapt to new-generation networks. Current routing approaches risk-averse outcomes such as (1) scalability constraints, (2) high convergence times, and (3) congestion due to inadequate real-time traffic prioritization. To address these issues, this paper introduces a QoS-Driven Routing Optimization in Software-Defined Networking (SDN) using Deep Reinforcement Learning (DRL) to optimize routing and enhance QoS efficiency. Employing DRL, the proposed DQS optimizes routing decisions by intelligently distributing traffic, guided by a multi-objective function-driven DRL agent that considers both link and queue metrics. Despite the complexity of the network, DQS sustains scalability while significantly reducing convergence times. Through a Docker-based Openflow prototype, results highlight a substantial 20-30% reduction in end-to-end delay compared to baseline methods. • DQS tackles scalability and congestion with a multi-objective loss function, integrating CoS into routing decisions to make informed decisions. • DQS employs a seven-parameter traffic classifier with ML techniques, efficiently categorizing CoS and ensuring mice and elephant traffic. • The paper presents DQS, employing DRL to optimize routing decisions, minimize delay and loss, and maximize bandwidth use across links and queues. • We evaluate DQS with a Docker-based SDN prototype, showing its adaptability, scalability, and responsiveness to traffic changes and QoS demands. • Results show 20-30% delay reduction and 14% processing time improvement over state-of-the-art algorithms, enhancing network performance. [ABSTRACT FROM AUTHOR]

This paper presents implementing and optimizing a high-order unstructured computational fluid dynamics (CFD) solver using five shared-memory programming models: CUDA, OpenACC, OpenMP, Kokkos, and OP2. The study aims to evaluate the performance of these models on different hardware architectures, including NVIDIA GPUs, x86-based Intel/AMD, and Arm-based systems. The goal is to determine whether these models can provide developers with performance-portable solvers running efficiently on various architectures. The paper forms a more holistic view of a high-order solver across multiple platforms by visualizing performance portability (PP) and measuring productivity. It gives guidelines for translating existing codebases and their data structures to these models. • We port and optimize a high-order unstructured CFD application by using five shared-memory programming models. • We evaluate the performance portability of five programming models on diverse hardware. • We analyze the workload from the perspective of code volume and learning cost. [ABSTRACT FROM AUTHOR]

Federated Learning coordinates many mobile devices to train an artificial intelligence model while preserving data privacy collaboratively. Mobile devices are usually equipped with totally different hardware configurations, leading to various training capabilities. At the same time, the distribution of the local training data is highly heterogeneous across different clients. Randomly selecting the clients to participate in the training process results in poor model performance and low system efficiency. In this paper, we propose GraphCS, a graph-based client selection framework for heterogeneity in Federated Learning. GraphCS first measures the distribution coupling across the clients via the model gradients. After that, it divides the clients into different groups according to the diversity of the local datasets. At the same time, it well estimates the runtime training capability of each client by jointly considering the hardware configuration and resource contention caused by the concurrently running apps. With the distribution coupling information and runtime training capability, GraphCS selects the best clients in order to well balance the model accuracy and overall training progress. We evaluate the performance of GraphCS with mobile devices with different hardware configurations on various datasets. The experiment results show that our approach improves model accuracy up to 45.69%. Meanwhile, it reduces communication and computation overhead 87.35% and 89.48% at best, respectively. Furthermore, GraphCS accelerates the overall training process up to 35×. • We observe that the distribution of the training data can be reflected by the gradient of a machine learning model. • We observe that the training capability is jointly affected by the hardware configuration and resource contention. • we design a framework selects the best clients with diverse local datasets and highest runtime training capability. • We prototype GraphCS on a Federated system consisting of mobile devices with heterogeneous hardware configurations. [ABSTRACT FROM AUTHOR]

Sobel is one of the most popular edge detection operators used in image processing. To date, most users utilize the two-directional 3×3 Sobel operator as detectors because of its low computational cost and reasonable performance. Simultaneously, many studies have been conducted on using large multi-directional Sobel operators to satisfy their needs considering the high stability, but at an expense of speed. This paper proposes a fast graphics processing unit (GPU) kernel for the four-directional 5×5 Sobel operator. To improve kernel performance, we implement the kernel based on warp-level primitives, which can significantly reduce the number of memory accesses. In addition, we introduce the prefetching mechanism and operator transformation into the kernel to significantly reduce the computational complexity and data transmission latency. Compared with the OpenCV-GPU library, our kernel shows high performances of 6.7x speedup on a Jetson AGX Xavier GPU and 13x on a GTX 1650Ti GPU. • Implemented an efficient GPU kernel of a four-directional 5x5 Sobel operator. • Implemented GPU kernel based on warp-level primitives. • Hid latency caused by data transmission using the prefetching mechanism. • Accelerated the computation of diagonal directions using a two-step optimization approach. • Achieved an extremely high processing speed, which is almost 13x faster than that of the OpenCV-GPU library. [ABSTRACT FROM AUTHOR]

Offloading tasks from edge devices to the cloud is an important method to enhance the performance of the edge device. With the help of EH (Energy Harvesting) technology, the edge device can use the collected green energy to support its operations. Most offloading scheduling methods use as much green energy as the edge device collected. Unlike prior research, we consider the long-term benefits of energy. In this paper, we forecast the solar energy supply with meteorological methods which are based on the weather forecast data. Then, we use quadratic programming to allocate energy based on the forecast energy to maximize energy efficiency. Finally, we use NSGA (Non-dominated Sorting Genetic Algorithms) to offload tasks in the edge device. Simulations show that our proposed method not only minimizes the execution time and the energy consumption of clouds, but also enhances the QoE of users. • We model the edge system considering the battery and the weather information. • Energy allocation for edge devices based on the weather forecast information. • A offloading task method is proposed based on NGSA III. • Simulations are given with benefit function. • Comparisons are given considering multiple aspects. [ABSTRACT FROM AUTHOR]

Recently, unmanned aerial vehicle (UAV) networks have been widely used in military and civilian scenarios; however, they suffer various attacks. Time-delay attacks maliciously delay the transmission of packets without tampering with the contents or significantly affecting the transmission pattern, making detection difficult. In this paper, a holistic cross-layer time-delay attack detection framework (HOTD) is proposed for UAV networks. A holistic selection of the delay-related features available at all layers is performed, before adopting supervised learning to build a consistency model between these features and the corresponding forwarding delay to calculate the degree of consistency of each node. Finally, the clustering method is used to distinguish malicious from benign nodes according to their degree of consistency. Experimental results show that the performance of HOTD is superior to that of state-of-the-art detection methods, and it achieves a detection accuracy higher than 85% with less than 2.5% additional overhead. • Time-delay attacks are modelled in UAV networks for the first time. • HOTD collects delay-related features at all layers in the UAV network protocol. • The relationship between the features and delay is used to identify malicious nodes. • Simulations show the method achieves over 85% detection accuracy. • HOTD is better than other available methods in detecting time-delay attack nodes. [ABSTRACT FROM AUTHOR]

In situ analysis and visualization have grown increasingly popular for enabling direct access to data from high-performance computing (HPC) simulations. As a simulation progresses and interesting physical phenomena emerge, however, the data produced may become increasingly complex, and users may need to dynamically change the type and scale of in situ analysis tasks being carried out and consequently adapt the amount of resources allocated to such tasks. To date, none of the production in situ analysis frameworks offer such an elasticity feature, and for good reason: the assumption that the number of processes could vary during run time would force developers to rethink software and algorithms at every level of the in situ analysis stack. In this paper we present Colza, a data staging service with elastic in situ visualization capabilities. We demonstrate the use of Colza with the Deep Water Impact and the AMR-Wind simulations, coupling them with the ParaView Catalyst and Ascent in situ libraries, and show that Colza enables dynamic rescaling of these widely-used frameworks with no interruption to the simulation or staging service. We highlight the challenges of enabling such elasticity, which requires overcoming these frameworks' reliance on MPI, using distinct engineering approaches, namely dependency injection and dependency overload. To the best of our knowledge, this work is the first to enable elastic in situ visualization capabilities for HPC applications on top of existing production analysis tools. • We introduce Colza, an elastic service for in situ analysis of HPC applications. • We present two methods of integrating Colza with existing in situ frameworks. • We evaluate Colza on ANL's Theta and NERSC's Cori supercomputers. [ABSTRACT FROM AUTHOR]

Big data processing frameworks such as Spark usually provide a large number of performance-related configuration parameters, how to auto-tune these parameters for a better performance has been a hot issue in academia as well as industry for years. Through delicately tradeoff between exploration and exploitation, Bayesian Optimization (BO) is currently the most appealing algorithm to achieve configuration auto-tuning. However, considering the tuning cost constraint in practice, there are three critical limitations preventing conventional BO-based approaches from being directly applied into auto-tuning cluster-based big data frameworks. In this paper, we propose a cost-efficient configuration auto-tuning approach named TurBO for big data frameworks based on two enhancements of vanilla BO:1) To reduce the essential iteration times, TurBO integrates a well-designed adaptive pseudo point mechanism with BO; 2) To avoid the time-consuming practical evaluation of sub-optimal configurations as possible, TurBO leverages the proposed CASampling method to intelligently tackle with these sub-optimal configurations based on ensemble learning with historical tuning experiences. To evaluate the performance of TurBO, we conducted a series of experiments on a local Spark cluster with 9 different HiBench benchmark applications. Overall, compared with 3 representative BO-based baseline approaches OpenTuner, Bliss and ResTune, TurBO is able to speedup the tuning procedures respectively by 2.24×, 2.29× and 1.97× on average. Besides, TurBO can always achieve a positive cumulative performance gain under the simulated dynamic workload scenario, which means TurBO is indeed appropriate for workload changes of big data applications. • Analyze the limitations of vanilla Bayesian optimization considering tuning cost. • Implement a cost-efficient configuration auto-tuning approach named TurBO. • TurBO reduces iteration times via an adaptive pseudo point mechanism with BO. • TurBO reduces configuration evaluation cost via an ensemble learning-based method. • Experiments on a Spark cluster show the effectiveness and efficiency of TurBO. [ABSTRACT FROM AUTHOR]

Even though it is well known that binary values are common in graph applications (e.g., adjacency matrix), how to leverage the phenomenon for efficiency has not yet been adequately explored. This paper presents a systematic study on how to unlock the potential of the bit-level optimizations of graph computations that involve binary values. It proposes a two-level representation named Bit-Block Compressed Sparse Row (B2SR) and presents a series of optimizations to the graph operations on B2SR by the intrinsics of modern GPUs. It additionally introduces Deep Reinforcement Learning (DRL) as an efficient way to best configure the bit-level optimizations on the fly. The DQN-based adaptive tile size selector with dedicated model training can reach 68% prediction accuracy. Evaluations on the NVIDIA Pascal and Volta GPUs show that the optimizations bring up to 40▪ and 6555▪ for essential GraphBLAS kernels SpMV and SpGEMM, respectively, accelerating GraphBLAS-based BFS by up to 433▪, SSSP, PR, and CC 35▪, and TC 52▪. • The performance of GraphBLAS algorithms can be accelerated with sparse bit storage format and bit manipulation. • Sparse operators such as SpMV and SpGEMM can be accelerated with bit intrinsics on GPU when contains only binary values. • A DRL-based adaptive scheme can be utilized to select the best bit sparse format based on sparse matrix features. [ABSTRACT FROM AUTHOR]

Extreme-scale computing involves hundreds of millions of threads with multi-level parallelism running on large-scale hierarchical and heterogeneous hardware. Some OpenMP multi-threaded applications increasingly suffer from runtime hidden behaviors owning to shared resource contention as well as software- and hardware-related problems. Such hidden behaviors can result in failure and inefficiencies and are among the main challenges in system resiliency. To minimize the impact of hidden behaviors, one must quickly and accurately detect and diagnose the hidden behaviors that cause the failures. However, it is difficult to identify hidden behaviors in the dynamic and noisy data collected by OpenMP multi-threaded monitoring infrastructures. This paper presents an anthropomorphic diagnosis framework for hidden behaviors of OpenMP multi-threaded applications. In the framework, we first design injected heartbeat functions for OpenMP multi-threaded applications. Then, we leverage the heartbeat sequences to extract features of hidden behaviors. Finally, we develop a feature learning-based algorithm using heartbeat analysis, namely HSA, to diagnose hidden behaviors. To evaluate our framework, the NAS Parallel NPB benchmark, EPCC OpenMP micro-benchmark suite, and Jacobi benchmark are used to test the performance of our proposed framework. The experimental results demonstrate that our framework successfully identifies 90.3% of the injected hidden behaviors of OpenMP multi-threaded applications while acquiring low overhead. • The anthropomorphic framework is proposed for diagnosing hidden behaviors. • The framework based on heartbeats supports multi-threaded OpenMP applications. • Small-size samples also demonstrate the high efficiency of this framework. • The framework is lower overhead and is more accurate than the state-of-the-art. • The framework supports extension and specificity in most of our experiments. [ABSTRACT FROM AUTHOR]

Disaggregated architecture brings new opportunities to memory-consuming applications like graph processing. It allows one to outspread memory access pressure from local to far memory, providing an attractive alternative to disk-based processing. Although existing works on general-purpose far memory platforms show great potentials for application expansion, it is unclear how graph processing applications could benefit from disaggregated architecture, and how different optimization methods influence the overall performance. In this paper, we take the first step to analyze the impact of graph processing workload on disaggregated architecture by extending the GridGraph framework on top of the RDMA-based far memory system. We propose Fargraph+, a system with parallel graph data offloading and far memory coordination strategy for enhancing efficiency of graph processing workload on RDMA-based far memory architecture. Specifically, Fargraph+ reduces the overall data movement through a well-crafted, graph-aware data segment offloading mechanism. In addition, we use optimal data segment splitting and asynchronous data buffering to achieve graph iteration-friendly far memory access. We further configure efficient parallelism-oriented control to accelerate performance of multi-threading processing on graph iterations while improving memory efficiency of far memory access by utilizing RDMA queue features. We show that Fargraph+ achieves near-oracle performance for typical in-local-memory graph processing systems. Fargraph+ shows up to 11.2× speedup compared to Fastswap, the state-of-the-art, general-purpose far memory platform. • Graph programs demand large memory capacity and higher performance on disaggregated architecture. • Fargraph+ optimizes the execution to run graph applications on RDMA-based far memory in parallel efficiently. • The smart graph-aware data segment grouping and splitting method achieves better effectiveness by flexible data offloading. • The adaptive far memory interaction improves performance of graph iterations by buffering the transferred data carefully. • Parallelism control of multi-threaded graph iterations and RDMA shared-resource queues optimizes overall memory efficiency. [ABSTRACT FROM AUTHOR]

Resource provisioning plays a pivotal role in determining the right amount of infrastructure resource to run applications and reduce the monetary cost. A significant portion of production clusters is now dedicated to long-running applications (LRAs), which are typically in the form of microservices and executed in the order of hours or even months. It is therefore practically important to plan ahead the placement of LRAs in a shared cluster for the minimized number of compute nodes required by them. Existing works on LRA scheduling are often application-agnostic, without particularly addressing the constraining requirements imposed by LRAs, such as co-location affinity constraints and time-varying resource requirements. In this paper, we present an affinity-aware resource provisioning approach for deploying large-scale LRAs in a shared cluster subject to multiple constraints, with the objective of minimizing the number of compute nodes in use. We investigate a broad range of solution algorithms which fall into three main categories: Application-Centric, Node-Centric, and Multi-Node approaches, and tune them for typical large-scale real-world scenarios. Experimental studies driven by the Alibaba Tianchi dataset show that our algorithms can achieve competitive scheduling effectiveness and running time, as compared with the heuristics used by the latest work including Medea and Lra Sched. Best results are obtained by the Application-Centric algorithms, if the algorithm's running time is of primary concern, and by Multi-Node algorithms, if the solution quality is of primary concern. • Resource provisioning for long-running applications is studied in shared clusters. • Temporal resource requests and application-level affinity are considered. • Application-Centric algorithms win if the running time is of primary concern. • Node-Centric Algorithms offer a trade-off between solution quality and time. [ABSTRACT FROM AUTHOR]

Middleboxes are widely used in modern networks for a variety of network functions in cybersecurity, performance enhancement, and monitoring. Middlebox policy enforcement is however complex and tedious with unreliable manual re-configuration of legacy routers. The existing solution on automated policy enforcement relies on software-defined networking and does not apply to the traditional non-SDN networks, which remain popular today in enterprise deployment and core networks. This paper proposes a new architecture based entirely on software-defined middleboxes (instead of using software-defined switches in the prior art) to enable dependable and automated policy enforcement in non-SDN networks whose routers forward packets based on traditional routing protocols that are not policy-sensitive. We present a hot-potato enforcement strategy, which is then enhanced with two optimizations for load-balanced policy enforcement among software-defined middleboxes. Next, we propose two additional optimizations that minimize total traffic and aggregate end-to-end delays subject to link capacity constraints. Further enhancements are made to relieve middlebox processing overhead, avoid packet fragmentation due to policy enforcement, recover from failures, and mitigate delay for time-sensitive applications. We evaluate the proposed architecture on a real-life campus network topology and two simulated topologies to demonstrate the superior performance of our load-balanced enforcement strategies. [ABSTRACT FROM AUTHOR]

Cloud warehouses have been exploiting multi-tenancy in CPU-FPGA collaborative environments, so clients can share the same infrastructure, achieving scalability and maximizing resource utilization. Therefore, the distribution of tasks across CPU and FPGA must be well-balanced so performance and energy are optimized in a highly variant workload scenario. In this paper, we take a step further and, in contrast to existing approaches, exploit DVFS (Dynamic Voltage and Frequency Scaling) on the CPU, together with an intelligent CPU-FPGA resource provisioning mechanism, to further improve energy. For that, we propose EASER, an end user-transparent framework that employs multiple strategies and dynamically selects the most appropriate one to optimize resource provisioning and DVFS according to the warehouse needs, workload properties, and target architecture. Our synergistic DVFS optimization brings up to 22% additional energy gains over our dynamic provisioning alone. Compared to fixed single strategies with DVFS, EASER brings, on average, 71% of energy gains. • We explore voltage/frequency scaling and provisioning in multi-tenant CPU-FPGA Cloud. • Different strategies are needed depending on the architecture and workload properties. • EASER is end-user transparent and fully-adaptive. • EASER achieves energy improvements without harming makespan. [ABSTRACT FROM AUTHOR]

An elegant strategy for proving impossibility results in distributed computing was introduced in the celebrated FLP consensus impossibility proof. This strategy is local in nature as at each stage, one configuration of a hypothetical protocol for consensus is considered, together with future decisions of possible extensions. This proof strategy has been used in numerous situations related to consensus, leading one to wonder why it has not been used in impossibility results of two other well-known tasks: set agreement and renaming. This paper provides an explanation of why impossibility proofs of these tasks have been of a global nature. It shows that a protocol can always solve such tasks locally, in the following sense. Given a configuration and all its future decisions, if a single successor configuration is selected, then the protocol can reveal all decisions in this branch of executions, satisfying the task specification. This result is shown for both set agreement and renaming, providing evidence that there are no local impossibility proofs for these tasks. • Studies impossibility proofs for sub-consensus tasks in wait-free shared-memory. • Locally-solvable valency tasks capture the FLP strategy for proving impossibility results. • Presents locally-solvable valency tasks for set consensus, weak symmetry breaking and renaming. • This explains why there are no FLP-style proofs for the impossibility of solving these tasks. [ABSTRACT FROM AUTHOR]

In recent years, the increase in the use of services in cloud, fog, edge, and IoT ecosystems has been very notable. On the one hand, environmental sustainability is affected by this type of ecosystem since it can produce a large amount of energy consumption which translates into CO2 emissions into the atmosphere. On the other hand, due to the COVID-19 pandemic, the use of these ecosystems has increased considerably. Thus, it is necessary to apply policies and techniques to maximize sustainability within these ecosystems. Some of these policies and techniques are those based on artificial intelligence. However, the current processing of these policies and techniques can also consume a lot of resources. From this perspective, this article aims to clarify whether the sustainability of cloud/fog/edge/IoT ecosystems is improved by the application of artificial intelligence. To do this, a systematic literature review is developed in this paper. In addition, a set of classifications of the analyzed works is proposed based on the different aspects related to these ecosystems, their sustainability, and the applicability of artificial intelligence to improve them. • The use of cloud, fog, edge, and IoT has increased drastically in the last few years. • It is necessary to apply policies to maximize the sustainability of AI. • This work clarifies whether the sustainability of these environments is improved by AI. • A SLR is performed to achieve this aim. • The application of AI to these environments is a newborn topic. [ABSTRACT FROM AUTHOR]

Many virtual machine (VM) allocation methods have been proposed to reduce the number of physical machines (PMs), improve resource utilization for cloud service providers. If VMs are migrated on the same PM, then there will be substantial resource competition among these VMs, which results in VM performance reduction. Many VM migration (VMM) methods neglect VM performance reduction. Although some performance-aware VM allocation methods were proposed, the performance optimization objective of these methods mainly aimed at guaranteeing service level agreement or reducing VM downtime during migration, and they did not scientifically analyze how the VM performance degrades. Therefore, how to minimize the VM performance reduction for users when migrating VMs remains a major challenge. This paper proposes a VM Performance-Aware VMM method (PAVMM) for both users and cloud service providers. To maximize VM performance for users, it utilizes the VM performance model, which was built in our previous works, to predict the VM performance after migrating VMs. It then establishes an optimization objective of maximizing VM performance for users. Meanwhile, minimizing the number of active PMs and the total migration cost are regarded as additional optimization objectives for cloud service providers. Therefore, we formulate VMM as a multi-objective optimization problem, which tries to maximize VM performance for users and minimize the number of active PMs and the total migration cost for cloud service providers simultaneously. Then an ant colony optimization (ACO)-based algorithm is proposed to solve the NP-hard VMM problem. Lastly, the experiments are conducted to evaluate PAVMM, and the results verify its efficiency. • VM Performance-Aware VMM method of improving users' experience and cloud service providers' benefits. • Optimizations include: maximizing VM performance, and minimizing the number of active PMs and the total migration cost. • An efficient VMM algorithm based on ant colony optimization. • Experimental results using both CloudSim platform and OpenStack-based cloud platform. [ABSTRACT FROM AUTHOR]

The construction of systems supporting spatial data has experienced great enthusiasm in the past, due to the richness of this type of data and their semantics, which can be used in the decision-making process in various fields. Thus, the problem of integrating spatial data into existing databases and information systems has been addressed by creating spatial extensions to relational tables or by creating spatial data warehouses, while arranging data structures and query languages by making them more spatially-aware. With the advent of Big Data, these conventional storage and spatial representation structures are becoming increasingly outdated, and required a new organization of spatial data. Approaches based on distributed storage and data lakes have been proposed, to integrate the complexity of spatial data, with operational and analytical systems which unfortunately quickly showed their limits. Recently the concept of lakehouse was introduced in order to integrate, among other things, the notion of reliability and ACID properties to the volume of data to be managed. This new data architecture is a combination of governed and reliable Data Warehouses and flexible, scalable and cost-effective Data Lakes. In this paper, we present how traditional approaches of spatial data management in the context of spatial big data have quickly shown their limits. We present a literature overview of these approaches, and how they led to the Data LakeHouse. We detail how the Lakehouse paradigm can be used and extended for managing spatial big data, by giving the different components and best practices for building a spatial data LakeHouse architecture optimized for the storage and computing over spatial big data. • Limitations of Data Warehouses and Data Lakes for Spatial Big Data. • Characteristics and Architecture of the Data LakeHouse. • Overview of Three Major Open Source LakeHouse Systems. • Challenges in Using Data LakeHouse for Spatial Big Data. • Optimized Data LakeHouse Architecture for Spatial Big Data. [ABSTRACT FROM AUTHOR]

This paper focuses on energy minimization for the mapping and scheduling of real-time workflows under reliability constraints. Workflow instances are input periodically to the system. Each instance is composed of several tasks and must complete execution before the arrival of the next instance, and with a prescribed reliability threshold. While the shape of the dependence graph is identical for each instance, task execution times are stochastic and vary from one instance to the next. The reliability threshold is met by executing several replicas for each task. The target platform consists of identical processors equipped with Dynamic Voltage and Frequency Scaling (DVFS) capabilities. A different frequency can be assigned to each task replica to save energy, but it may have negative effect on the deadline and reliability target. This difficult tri-criteria mapping and scheduling problem (energy, deadline, reliability) has been studied only recently for workflows with arbitrary dependence constraints. We investigate new mapping and scheduling strategies based upon layers in the task graph. These strategies better balance replicas across processors, thereby decreasing the time overlap between different replicas of a given task, and saving energy. We compare these strategies with two state-of-the-art approaches and a reference baseline on a variety of benchmark workflows. Our best heuristics achieve an average energy gain of 60% over the competitors and of 82% over the baseline. • Tri-criteria mapping and scheduling problem for real-time workflows of arbitrary shape. • First general solution without any limitation on the number of replicas used. • Innovative solution based upon layers of the workflow outperforms competitors. [ABSTRACT FROM AUTHOR]

One of the key objectives in many fields in machine learning is to discover causal relationships among a set of variables from observational data. In linear non-Gaussian acyclic models (LiNGAM), it can be shown that the true underlying causal structure can be identified uniquely from merely observational data. The DirectLiNGAM algorithm is a well-known solution to learn the true causal structure in a high dimensional setting. DirectLiNGAM algorithm executes in a sequence of iterations and it performs a set of comparisons between pairs of variables in each iteration. Unfortunately, the runtime of this algorithm grows significantly as the number of variables increases. In this paper, we propose a parallel algorithm, called ParaLiNGAM, to learn casual structures based on DirectLiNGAM algorithm. We propose a threshold mechanism that can reduce the number of comparisons remarkably compared with the sequential solution. Moreover, in order to further reduce runtime, we employ a messaging mechanism between workers. We also present an implementation of ParaLiNGAM on GPU, considering hardware constraints. Experimental results on synthetic and real data show that our proposed solution outperforms DirectLiNGAM by a factor up to 4788X, and by a median of 2344X. • A scalable algorithm for learning causal structures in linear non-Gaussian models. • Significant speedup by selecting the necessary computations judiciously. • Speedup ratio of up to 4788 on GPUs in real-world and synthetic datasets. [ABSTRACT FROM AUTHOR]

Recently, Federated Learning (FL) has been explored as a new paradigm that preserves both data privacy and end-users knowledge while reducing latency during model training. While often applied between a central server and the edge devices, FL deals with a wide range of end-user applications and devices. Given the Internet of Things (IoT) current popularity, its relevance and its penetration in several new application domains, this work examines the new challenges faced when combining IoT with the classic FL model. The limited resources of IoT edge devices require careful adaptation of the way how FL should be structured in this scenario. In addition, since FL is a distributed paradigm that shares deep learning artifacts through a network, there are also communication issues reminiscent to IoT networks that need special consideration. Thus, it is necessary to optimize the use of both processing and communication resources when considering the use of IoT edge devices as part of a FL. This paper systematically reviews current advances and steps taken towards dealing with resource optimization when using FL as part of IoT scenarios. We examine the published works over the last ten years and discuss the main goals, scenarios, and developed solutions to solve the problems encountered. We also present the main metrics used to quantify the effectiveness and to evaluate the performance of existing IoT based architectures with FL support. • Federated Learning preserves data privacy and end-users knowledge. • Federated Learning deals with a wide range of end-user applications and devices. • Internet of Things application offers a substantial source of data. • Federated Learning is seen as a suitable approach for building smart IoT systems. • Federated Learning and IoT integration present peculiar IoT-scenario challenges. [ABSTRACT FROM AUTHOR]

Network coding (NC), when combined with multipath routing, enables a linear programming (LP) formulation for a multi-source multicast with intra-session network coding (MISNC) problem. However, it is still hard to solve using conventional methods due to the enormous scale of variables or constraints. In this paper, we try to solve this problem in terms of throughput maximization from an algorithmic perspective. We propose a novel formulation based on the extreme flow decomposition technique, which facilitates the design and analysis of approximation and online algorithms. For the offline scenario, we develop a fully polynomial time approximation scheme (FPTAS) which can find a (1 + ω) -approximation solution for any specified ω > 0. For the online scenario, we develop an online primal-dual algorithm which proves O (1) -competitive and violates link capacities by a factor of O (log ⁡ m) , where m is the link number. The proposed algorithms share an elegant primal-dual form and thereby have inherent advantages of simplicity, efficiency, and scalability. To better understand the proposed approach, we devise delicate numerical examples on an extended butterfly network to validate the effects of algorithmic parameters and make an interesting comparison between the offline and online cases. We also perform large-scale simulations on real networks to validate the effectiveness of the proposed FPTAS and online algorithm. • Extreme flow decomposition technique for intra-session network coding. • Offline FPTAS with provable approximation ratio. • Online primal-dual algorithm with provable competitive ratio. • Large-scale experiments using public datasets. [ABSTRACT FROM AUTHOR]

The extensive use of Deep Neural Networks (DNNs) encourages people to design domain-specific hardware called Artificial Intelligence (AI) processors. The novel hardware makes optimizations challenging without a proper performance model that reveals working details and performance implications. This paper presents a performance model, Verrocchio, for Huawei DaVinci AI Core, which predicts the execution time of real-world DaVinci kernels. We propose specially-crafted micro-benchmarks to identify contention source, runtime behaviors, and bandwidth sharing, which significantly determine performance. Since DaVinci Core adopts a binary semaphore mechanism for synchronization, Verrocchio views each instruction as a discrete event and manages its execution time based on the programming logic. For evaluation, Verrocchio achieves average error rates of 2.62% and 2.30% in sample kernels for single-core and double-core execution. We demonstrate an optimizing process of matrix multiplications with Verrocchio, achieving speedups of 1.70× for operators and 1.53× for applications and error rates of 5.06% and 5.25%. • Detailed dissections of Huawei DaVinci AI Core, a novel AI processor. • Benchmarking the DaVinci Core bandwidth contention, the key performance factor. • Performance model for accurate execution time prediction of kernel program. • Demonstration of DaVinci kernel optimization and prediction accuracy evaluation. [ABSTRACT FROM AUTHOR]

Although code generation for Convolution Neural Network (CNN) models has been extensively studied, performing efficient data slicing and parallelization for highly-constrained Multicore Neural Processor Units (NPUs) is still a challenging problem. Given the size of convolutions' input/output tensors and the small footprint of NPU on-chip memories, minimizing memory transactions while maximizing parallelism and MAC utilization are central to any effective solution. This paper proposes a TensorFlow XLA/LLVM compiler optimization pass for Multicore NPUs, called Tensor Slicing Optimization (TSO), which: (a) maximizes convolution parallelism and memory usage across NPU cores; and (b) reduces data transfers between host and NPU on-chip memories by using DRAM memory burst time estimates to guide tensor slicing. To evaluate the proposed approach, a set of experiments was performed using the NeuroMorphic Processor (NMP), a multicore NPU containing 32 RISC-V cores extended with novel CNN instructions. Experimental results show that TSO is capable of identifying the best tensor slicing that minimizes execution time for a set of CNN models. Speed-ups of up to 21.7% result when comparing the TSO burst-based technique to a no-burst data slicing approach. To validate the generality of the TSO approach, the algorithm was also ported to the Glow Machine Learning framework. The performance of the models were measured on both Glow and TensorFlow XLA/LLVM compilers, revealing similar results. • A burst-based cost model for Tensor Slicing Optimization. • Reducing data transfer between host and NPU on-chip memories. • Maximizing Convolution parallelism and memory reuse. [ABSTRACT FROM AUTHOR]

In edge computing, application components can be placed over a range of computational devices from cloud data centers to nodes at the network edge. Application placement can have significant impact on important metrics like latency and resource utilization. Thus, application placement is an important optimization problem. In edge computing, the characteristics of both the infrastructure and the application may change over time, which may require the dynamic re-optimization of the application placement. Most algorithms suggested so far for the dynamic re-optimization of edge application placement are centralized, i.e., they rely on one entity collecting information from the whole infrastructure and making decisions centrally. However, centralized approaches suffer from limited scalability and are vulnerable to failures. In this paper, we present a decentralized approach for the dynamic re-optimization of edge application placement. We adopt an algorithm of Malek et al. for distributed systems and modify it to make it applicable to edge computing. In this approach, each node makes decisions autonomously, using auctions for coordination. Our empirical results demonstrate that the proposed algorithm is very effective in optimizing edge application placement. In an edge system with 637 edge nodes and 563 end devices, our algorithm achieves 54% higher reduction of application latency than a previous decentralized algorithm. • Optimized placement of application components on cloud and edge devices. • Decentralized optimization algorithm using local knowledge and local modifications. • Auctions and distributed locking for synchronization. • Minimization of application latency. [ABSTRACT FROM AUTHOR]

There are massive jobs submitted in the supercomputer, and the job management system is typically deployed to schedule these jobs and allocate compute resources. FCFS (First Come First Serve) is a popular scheduling policy and the job's priority is determined based on the arrival time. However, under the FCFS strategy, if existing idle resources cannot meet the requirement of the head job in the waiting queue, they cannot be allocated to other jobs, which suffers from resource waste. To optimize the resource utilization, the backfilling method is proposed, which allocates the reserved idle compute nodes to a small-size and short-running non-head job, on the premise of not delaying the original head job. Obtaining the job's runtime in advance is necessary for backfilling and the traditional method relies on the user's estimation. Unfortunately, the estimated runtime provided by users is generally overestimated. Many studies extract features from historical job logs and adopt machine learning to predict the runtime. However, traditional features are insufficient to characterize the job. In this paper, we collect job logs from two supercomputers and present a novel runtime prediction framework called PREP. PREP explores the job's running path as a new feature, which implies plentiful information about the job's properties, such as the user, the project, the scale of data sets, and the parameters used. As there is a strong correlation between the job's runtime and its running path, we group jobs with similar paths into a cluster and train a runtime prediction model for each cluster respectively. Extensive evaluations demonstrate that introducing the new feature can achieve higher prediction accuracy (88.5% and 82.3% in two production supercomputers respectively), and our framework has a more desirable prediction performance than other popular strategies like Last-2 and IRPA. In addition, the predicted runtime is inserted into the real job trace of a slurm simulator to verify the advantages of PREP. • PREP explores the job's running path as a new feature to support runtime prediction. • A strong correlation between the job's runtime and its running path is evaluated. • Multiple machine learning algorithms are adopted and compared when predicting. • PREP framework suits different types of supercomputers and gain desirable prediction result. [ABSTRACT FROM AUTHOR]

Federated Learning is designed for multiple mobile devices to collaboratively train an artificial intelligence model while preserving data privacy. Instead of collecting the raw training data from mobile devices to the cloud, Federated Learning coordinates a group of devices to train a shared model in a distributed manner with the training data located on the devices. However, unbalanced data distribution and heterogeneous hardware configurations across different devices badly hurts the performance of collaborative model and severely impacts the overall training progress. Thus, a framework that can well balance the model accuracy and the training progress is urgently required. In this paper, we propose PAGroup, a privacy-aware grouping framework for high-performance Federated Learning. PAGroup intelligently divides the participating clients into different groups through carefully analyzing the privacy requirement of the training data and the solid social relationship of the participating clients. After that, PAGroup conducts data shaping and capability-ware training in order to improve the model performance while accelerating the overall training process. We evaluate the performance of PAGroup with both simulation and hardware testbed. The evaluation results show that PAGroup improves model accuracy up to 21%. Meanwhile, it decreases 81% communication overhead, 29% computation cost and 84% wall-clock time at best comparing with the baselines. • Specific private data that required by a learned model can be exchanged daily in certain social community. • PAGroup can share private date within task-specific groups organized according to strongly connected social community. • Training devices in a group can be viewed as a "super" client to compatibility to existing optimization algorithms. • The impact of local data scale, diversity, and label distribution to the model performance has been theoretically proved. [ABSTRACT FROM AUTHOR]

• Minimization of both cloud service cost and request peak is addressed using game theory. • Nash equilibrium of the formalized game is proven theoretically. • A distributed Peak Clipping Algorithm (DPCA) is proposed to calculate the Nash equilibrium solution. • Experiments validate the request peak and the payment cost of customer are reduced simultaneously, thereby increasing the benefit. The rapid development of Internet of Things (IoT) technology and the popularity of Artificial Intelligence (Al) technology research have brought new opportunities for the development of cloud computing (CC). With the increasing number of mobile Internet access devices and IoT access devices, the number of task requests from CC customers for AI services in the network has also experienced an explosive growth. In this paper, the focus is on the possible overload of cloud providers during the peak period of cloud service requests. Thetime attributes of cloud task execution are classified to avoid overloading the cloud provider as much as possible. In a distributed cloud environment, it is necessary to consider the time flexible attributes of cloud tasks to reasonably compete for cloud resources. In this work, game theory (GT) is introduced to formulate a cloud service scheduling game, in which participants are cloud customers who participate in the purchase of cloud services. The players' strategies are the time flexibility of each cloud task. The problem is formulated as minimizing the cost of scheduling cloud services and a noncooperative game among the customers (as players) is presented. Then the existence of the Nash equilibrium (NE) solution of the game has been proved and a new algorithm has been proposed in this paper to compute it. In addition, the analysis process of the convergence of the proposed PCA algorithm and the proof of its convergence to NE are also included in this paper. At the end of the paper, simulations were performed to verify the theoretical analysis presented. The experimental results show that the proposed PCA algorithm can converge to the Nash equilibrium very quickly, effectively reducing the peak value and increasing profit. [ABSTRACT FROM AUTHOR]

With the increasing fidelity and resolution enabled by high-performance computing systems, simulation-based scientific discovery is able to model and understand microscopic physical phenomena at a level that was not possible in the past. A grand challenge that the HPC community facing is how to maintain the large amounts of analysis data generated from simulations. In-memory computing, among others, is recognized to be a viable path forward and has experienced tremendous success in the past decade. Nevertheless, there has been a lack of a complete study and understanding of in-memory computing as a whole on HPC systems. Given the enlarging disparity between compute and HPC storage I/O, it is urgent for the HPC community to assess the state of in-memory computing and understand the challenges and opportunities. This paper presents a comprehensive study of in-memory computing with regard to its software evolution, performance, usability, robustness, and portability. In particular, we conduct an indepth analysis on the evolution of in-memory computing based upon more than 3,000 commits, and use realistic workflows for two scientific workloads, i.e., LAMMPS and Laplace to quantitatively assess state-of-the-art in-memory computing libraries, including DataSpaces, DIMES, Flexpath, Decaf and SENSEI on two leading supercomputers, Titan and Cori. Our studies not only illustrate the performance and scalability, but also reveal the key aspects that are of interest to library developers and users, including usability, robustness, portability, potential design defects, etc. • This paper presents a comprehensive study of in-memory computing. • This work covers software performance, usability, robustness, and portability. • An in-depth analysis is conducted on the evolution of in-memory computing. [ABSTRACT FROM AUTHOR]

• We present a theoretical framework that can be used for analyzing, and quantifying the performance of parallel algorithms designed for MS based omics data. • We prove the lower communication bounds for the existing parallel algorithms. • We also prove lower communication bounds that can be theoretically achieved by parallel algorithms for MS based omics analysis. • Extensive experimentation for state of the art tools confirms our theoretical results. • This is first proof of any communication bounds for parallel algorithms for MS based omics. Mass spectrometry (MS) based omics data analysis require significant time and resources. To date, few parallel algorithms have been proposed for deducing peptides from mass spectrometry-based data. However, these parallel algorithms were designed, and developed when the amount of data that needed to be processed was smaller in scale. In this paper, we prove that the communication bound that is reached by the existing parallel algorithms is Ω (m n + 2 r q p) , where m and n are the dimensions of the theoretical database matrix, q and r are dimensions of spectra, and p is the number of processors. We further prove that communication-optimal strategy with fast-memory M = m n + 2 q r p can achieve Ω (2 m n q p) but is not achieved by any existing parallel proteomics algorithms till date. To validate our claim, we performed a meta-analysis of published parallel algorithms, and their performance results. We show that sub-optimal speedups with increasing number of processors is a direct consequence of not achieving the communication lower-bounds. We further validate our claim by performing experiments which demonstrate the communication bounds that are proved in this paper. Consequently, we assert that next-generation of provable , and demonstrated superior parallel algorithms are urgently needed for MS based large systems-biology studies especially for meta-proteomics, proteogenomic, microbiome, and proteomics for non-model organisms. Our hope is that this paper will excite the parallel computing community to further investigate parallel algorithms for highly influential MS based omics problems. [ABSTRACT FROM AUTHOR]

Unified Virtual Memory (UVM) relieves the developers from the onus of maintaining complex data structures and explicit data migration by enabling on-demand data movement between CPU memory and GPU memory. However, on-demand paging soon becomes a performance bottleneck of UVM due to the high latency caused by page table walks and data migration over interconnect. Prefetching is considered a promising solution to this problem given its ability to leverage the locality of program memory access patterns. However, existing locality-based prefetching schemes can not handle all the situations. An ideal prefetcher should not only look at narrow regions of the requested address space but also capture global context to deliver a good prediction of the memory access pattern. This paper proposes a novel framework for page prefetching for UVM through deep learning. We first show that a powerful Transformer learning model can provide high accuracy for UVM page prefetching. We then perform analysis to interpret this Transformer model and derive several insights that allow us to design a simpler model to match the unconstrained model's accuracy with orders of magnitude lower cost. We use a pattern-based method to make the UVM page preditor general to different GPU workloads. We evaluate this framework on a set of 11 memory-intensive benchmarks from popular benchmark suites. Our solution outperforms the state-of-the-art (SOTA) UVM framework, improving the performance by 10.89%, improving the device memory page hit rate by 16.98% (89.02% vs. 76.10% for prior art), and reducing the CPU-GPU interconnect traffic by 11.05%. According to our proposed unified metric, which combines the accuracy, coverage, and page hit rate, our solution is approaching the ideal prefetching scheme more than the SOTA design (0.90 vs. 0.85, with the perfect prefetcher of 1.0). • The first framework for CPU-GPU UVM page prefetching using deep learning. • Revealing insights about UVM prefetching to derive lightweight page predictors. • Significantly improves IPC and memory page hit rate while reducing PCI-e usage. [ABSTRACT FROM AUTHOR]

The wide adoption of IoT technologies has accelerated the accumulation of big data. Recommender systems (RS) is one of the most effective methods to extract user interested items from the huge volume of big data. However, implementing a recommender system over the distributed error-prone IoT devices faces two challenges. On the one hand, the distributed IoT devices may randomly fail to deliver its local data due to hardware malfunction, which may cause unavailability of the recommender system. Moreover, collecting the raw data from the distributed IoT devices may cause data privacy leakage issue, since the privacy data of user-item interaction records may be abused by vicious parties. In view of these challenges, we propose a federated collaborative recommendation model based on microservice framework in this paper to implement privacy preserving distributed recommendation applications. Firstly, we utilize the federated learning framework to train the collaborative recommendation model, where the raw data on each distributed device is kept locally and only item related model parameters are exposed to train the federated recommendation model. Moreover, we adopt the microservice framework to encapsulate different functions of the federated recommender model. Each distributed device can participate in the federated training process via service registration and service discovery function of the microservice framework. Furthermore, we enhance the typical Neural Collaborative Filtering model with the proposed FedNeuMF model by fusing auxiliary user profiles and item attributes to improve the recommendation accuracy. Finally, we conduct a set of experiments on three real-world datasets to check the performance of our proposal. • A federated recommendation model is proposed based on the microservice framework. • Auxiliary information is adopted to enhance the typical neural CF model. • A set of experiments is conducted to verify the performance of the proposal. [ABSTRACT FROM AUTHOR]

Simultaneous Localization And Mapping (SLAM) is crucial for autonomous navigation. ORB-SLAM is a state-of-the-art Visual SLAM system based on cameras used for self-driving cars. In this paper, we propose a high-performance, energy-efficient, and functionally accurate hardware accelerator for ORB-SLAM, focusing on its most time-consuming stage: Oriented FAST and Rotated BRIEF (ORB) feature extraction. The Rotated BRIEF (rBRIEF) descriptor generation is the main bottleneck in ORB computation, as it exhibits highly irregular access patterns to local on-chip memories causing a high-performance penalty due to bank conflicts. We introduce a technique to find an optimal static pattern to perform parallel accesses to banks based on a genetic algorithm. Furthermore, we propose the combination of an rBRIEF pixel duplication cache, selective ports replication, and pipelining to reduce latency without compromising cost. The accelerator achieves a reduction in energy consumption of 14597× and 9609×, with respect to high-end CPU and GPU platforms, respectively. • Feature extraction takes 60% of the localization execution time in current solutions. • Streaming architecture in which the bottleneck is the computation of rBRIEF. • A genetic algorithm can statically reorder the rBRIEF pattern to reduce the latency. • Optimizations include: pixel cache, selective replication of ports and pipelining. • Search of the most energy efficient factors that fulfill the self-drivings requirements. [ABSTRACT FROM AUTHOR]

Option pricing is one of the most active Financial Economics research fields. Black-Scholes-Merton option pricing theory states that risk-neutral density is lognormal. However, markets' pieces of evidence do not support that assumption. More realistic assumptions impose substantial computational burdens to calculate option pricing functions. Risk-neutral density is a pivotal element to price derivative assets, which can be estimated through nonparametric kernel methods. A significant computational challenge exists for determining optimal kernel bandwidths, addressed in this study through a parallel computing algorithm performed using Graphical Processing Units. The paper proposes a tailor-made Cross-Validation criterion function used to define optimal bandwidths. The selection of optimal bandwidths is crucial for nonparametric estimation and is also the most computationally intensive. We tested the developed algorithms through two data sets related to intraday data for VIX and S&P500 indexes. • An example of such big data environments is information associated with financial options contracts. • Second, we developed methods to estimate the risk-neutral density as a pivotal element for options pricing. • Third, we found that nonparametric methods should be adapted for estimating the second derivatives, which relate to the risk-neutral densities. • Fourth, the proposed adaptations imply significant computational burdens defining bandwidths for nonparametric estimators. • Fifth, we found that parallel computing procedures can reduce computational times, compatible with needed dynamic updating. [ABSTRACT FROM AUTHOR]

The L -ary n -dimensional hamming graph K L n is one of the most attractive interconnection networks for parallel processing and computing systems. Analysis of the link fault tolerance of topology structure can provide the theoretical basis for the design and optimization of the interconnection networks. The k -component edge-connectivity c λ k (G) of an interconnection network G , is the minimum number of set of faulty links, such that these malfunctions disconnect the network G with at least k connected subnetworks. It gives a more precise quantitative analysis of indicators of the robustness of a parallel distributed system in the event of faulty links. Let t = ⌊ n 2 ⌋ if L is even, and t = ⌈ n 2 ⌉ if L is odd. In this paper, we prove that the (k + 1) -component edge-connectivity of L -ary n -dimensional hamming graphs is c λ k + 1 (K L n) = (L − 1) n k − e x k (K L n) 2 for k ≤ L t , n ≥ 7 , where e x k (K L n) represents the maximum degree sum of the subgraph induced by all k processors of K L n. As the exact values of (k + 1) -component edge-connectivity of K L n oscillate greatly, an efficient O (log ⁡ N) algorithm is designed to determine the exact values of c λ k + 1 (K L n) for each k ≤ L t and N = L n. Our result improves those of Xu et al. [33] and Liu et al. [27]. • The (k + 1) -component edge-connectivity of L -ary n -dimensional hamming graphs K L n is explored. • Determine the exact value of c λ k + 1 (K L n) for each k ≤ L t and n ≥ 7 , where t = ⌊ n 2 ⌋ if L is even, and t = ⌈ n 2 ⌉ if L is odd. • An efficient O (l o g N) algorithm is designed to determine the exact value of c λ k + 1 (K L n) for each k ≤ L t and N = L n. [ABSTRACT FROM AUTHOR]