Search

Tensor algebra operations such as contractions in computational chemistry consume a significant fraction of the computing time on large-scale computing platforms. The widespread use of tensor contractions between large multi-dimensional tensors in describing electronic structure theory has motivated the development of multiple tensor algebra frameworks targeting heterogeneous computing platforms. In this paper, we present Tensor Algebra for Many-body Methods (TAMM), a framework for productive and performance-portable development of scalable computational chemistry methods. TAMM decouples the specification of the computation from the execution of these operations on available high-performance computing systems. With this design choice, the scientific application developers (domain scientists) can focus on the algorithmic requirements using the tensor algebra interface provided by TAMM, whereas high-performance computing developers can direct their attention to various optimizations on the underlying constructs, such as efficient data distribution, optimized scheduling algorithms, and efficient use of intra-node resources (e.g., graphics processing units). The modular structure of TAMM allows it to support different hardware architectures and incorporate new algorithmic advances. We describe the TAMM framework and our approach to the sustainable development of scalable ground- and excited-state electronic structure methods. We present case studies highlighting the ease of use, including the performance and productivity gains compared to other frameworks. [ABSTRACT FROM AUTHOR]

Edge computing is an emerging paradigm that enables low-latency and high-performance computing at the network edge. However, effectively scheduling complex and interdependent tasks on heterogeneous and dynamic edge computing nodes presents a significant challenge in meeting users' real-time response requirements. To solve this problem, a DGCQN scheduling network that leverages reinforcement learning and graph convolutional neural networks to learn an optimal scheduling strategy is proposed in this paper. The proposed method embeds the graph structure of Directed Acyclic Graph (DAG) tasks and node information of Kubernetes (K8s) clusters into a Q value function, guiding the DQN network in selecting the best action at each step. The method is evaluated across various DAG tasks and edge computing scenarios. Compared with HEFT, DQN, and GOSU, the task completion time of the proposed method is reduced by about 20, 10, and 1.5%, respectively. The results demonstrate the effectiveness of the proposed method. [ABSTRACT FROM AUTHOR]

The digital correlator is one of the most crucial data processing components of a radio telescope array. With the scale of radio interferometeric array growing, many efforts have been devoted to developing a cost-effective and scalable correlator in the field of radio astronomy. In this paper, a 192-input digital correlator with six CASPER ROACH2 boards and seven GPU servers has been deployed as the digital signal processing system for Tianlai cylinder pathfinder located in Hongliuxia observatory. The correlator consists of 192 input signals (96 dual-polarization), 125-MHz bandwidth, and full-Stokes output. The correlator inherits the advantages of the CASPER system, for example, low cost, high performance, modular scalability, and a heterogeneous computing architecture. With a rapidly deployable ROACH2 digital sampling system, a commercially expandable 10 Gigabit switching network system, and a flexible upgradable GPU computing system, the correlator forms a low-cost and easilyupgradable system, poised to support scalable large-scale interferometeric array in the future. [ABSTRACT FROM AUTHOR]

This paper explores the process of migrating CUDA programs to DPC++ using the GASAL2 sequence alignment software. The DPCT tool is utilized during the migration process to automatically convert CUDA APIs to DPC++ APIs. However, the migrated code still requires adaptation and modification to compile and run correctly. This paper evaluates the effectiveness of the DPCT tool in migrating CUDA programs to DPC++ and demonstrates the high-efficiency performance of DPC++ across different architectures. Experiments show that the migrated program maintains the accuracy of the original program and can run on heterogeneous devices with the Intel GPU architecture without code modification. At the same time, the migrated DPC++-based GASAL2 heterogeneous computing performance can reach approximately 90%-95% of the original CUDA-based GASAL2 computing performance, fully demonstrating the feasibility of DPC++ heterogeneous programming. The results provide a promising solution for cross-platform heterogeneous programming to fully utilize a wider range of hardware support [ABSTRACT FROM AUTHOR]

Complex algorithms and enormous data sets require parallel execution of programs to attain results in a reasonable amount of time. Both aspects are combined in the domain of three-dimensional stencil operations, for example, computational fluid dynamics. This work contributes to the research on high-level parallel programming by discussing the generalizable implementation of a three-dimensional stencil skeleton that works in heterogeneous computing environments. Two exemplary programs, a gas simulation with the Lattice Boltzmann method, and a mean blur, are executed in a multi-node multi-graphics processing units environment, proving the runtime improvements in heterogeneous computing environments compared to a sequential program. [ABSTRACT FROM AUTHOR]

This paper presents a general strategy for tracking the scale-span movement process of asteroid regolith materials. It achieves the tracking of the mass movement on the asteroid at a realistic scale, under conditions of high-resolution asteroid surface topography (submeter level) and actual regolith particle sizes. To overcome the memory exponential expansion caused by the enlarged computational domain, we improved the conventional cell-linked list method so that it can be applied to arbitrarily large computational domains around asteroids. An efficient contact detection algorithm for particles and polyhedral shape models of asteroids is presented, which avoids traversing all surface triangles and thus allows us to model high-resolution surface topography. A parallel algorithm based on Compute Unified Device Architecture for the gravitational field of the asteroid is presented. Leveraging heterogeneous computing features, further architectural optimization overlaps computations of the long-range and short-range interactions, resulting in an approaching doubling of computational efficiency compared to the code lacking architectural optimizations. Using the above strategy, a specific high-fidelity discrete element method code that integrates key mechanical models, including the irregular gravitational field, the interparticle and particle-surface interactions, and the coupled dynamics between the particles and the asteroid, is developed to track the asteroid regolith mass movement. As tests, we simulated the landslide of a sand pile on the asteroid's surface during spin-up. The simulation results demonstrate that the code can track the mass movement of the regolith particles on the surface of the asteroid from local landslides to mass leakage with good accuracy. [ABSTRACT FROM AUTHOR]

Business Process as a Service (BPaaS) has recently emerged from the synergy between business process management and cloud computing, allowing companies to outsource and migrate their businesses to the cloud. BPaaS management refers to the set of operations (decomposition, customization, placement, etc.) that maintain a high-quality of the deployed cloud-based businesses. Like its ancestor SaaS, BPaaS placement consists on the dispersion of its composing fragments over multiple cloud availability zones (CAZ). These latter are characterized by their huge, diverse and dynamic data, which are exploited to select the high-performance servers holding BPaaS fragments, while preserving their constraints. These fragments' relations and their placement schemes constitute a dynamic BPaaS information network. However, the few existing BPaaS solutions adopt a static placement strategy, while it is important to take the CAZ dynamic and uncertain nature into account. Also, current solutions do not properly model the BPaaS environment. To offer an efficient BPaaS placement scheme, we combine prediction and learning capabilities, which will help identify the migrating fragments and their new hosting servers. We first model the BPaaS context as a heterogeneous information network. Then, we apply an incremental representation learning approach to facilitate its processing. Using the principles of proximity-aware representation learning, we infer useful knowledge regarding BPaaS fragments and the available servers at different CAZ. Finally based on the degree of closeness between the BPaaS environment's entities (e.g., fragments, servers), we select the optimum cloud availability zone on which the resource-consuming BPaaS fragments are migrated based on a proposed placement scheme. Obtained results were very promising compared to traditional BPaaS placement solutions. [ABSTRACT FROM AUTHOR]

While the importance of indexing strategies for optimizing query performance in database systems is widely acknowledged, the impact of rapidly evolving hardware architectures on indexing techniques has been an underexplored area. As modern computing systems increasingly leverage parallel processing capabilities, multi-core CPUs, and specialized hardware accelerators, traditional indexing approaches may not fully capitalize on these advancements. This comprehensive experimental study investigates the effects of hardware-conscious indexing strategies tailored for contemporary and emerging hardware platforms. Through rigorous experimentation on a real-world database environment using the industry-standard TPC-H benchmark, this research evaluates the performance implications of indexing techniques specifically designed to exploit parallelism, vectorization, and hardware-accelerated operations. By examining approaches such as cache-conscious B-Tree variants, SIMD-optimized hash indexes, and GPU-accelerated spatial indexing, the study provides valuable insights into the potential performance gains and trade-offs associated with these hardware-aware indexing methods. The findings reveal that hardware-conscious indexing strategies can significantly outperform their traditional counterparts, particularly in data-intensive workloads and large-scale database deployments. Our experiments show improvements ranging from 32.4% to 48.6% in query execution time, depending on the specific technique and hardware configuration. However, the study also highlights the complexity of implementing and tuning these techniques, as they often require intricate code optimizations and a deep understanding of the underlying hardware architecture. Additionally, this research explores the potential of machine learning-based indexing approaches, including reinforcement learning for index selection and neural network-based index advisors. While these techniques show promise, with performance improvements of up to 48.6% in certain scenarios, their effectiveness varies across different query types and data distributions. By offering a comprehensive analysis and practical recommendations, this research contributes to the ongoing pursuit of database performance optimization in the era of heterogeneous computing. The findings inform database administrators, developers, and system architects on effective indexing practices tailored for modern hardware, while also paving the way for future research into adaptive indexing techniques that can dynamically leverage hardware capabilities based on workload characteristics and resource availability. [ABSTRACT FROM AUTHOR]

This article introduces a mechanism for ensuring trusted GPU shader execution that adheres to the NIST Cybersecurity Framework (CSF) 2.0 standard. The CSF is a set of best practices for reducing cybersecurity risks. We focus on the CSF’s identification, protection, detection, and response mechanisms for GPU-specific security. To this end, we exploit recent advancements in side-channel analysis and hardware-assisted security for the real-time and introspective monitoring of shader execution. We prototype our solution and measure its performance across different GPU platforms. The evaluation results demonstrate the effectiveness of the proposed mechanism in detecting anomalous shader behaviors that only incur modest overhead at runtime. Integrating the CSF 2.0 principles into the proposed GPU shader pipeline leads to an organizational recipe for securing heterogeneous computing resources. [ABSTRACT FROM AUTHOR]

The concept of "all cores are created equal" has been popular for several decades due to its simplicity and effectiveness in CPU (Central Processing Unit) design. The more cores the CPU has, the higher performance the host owns and the higher the power consumption. However, power-saving is also one of the key goals for servers in data centers and embedded devices (e.g., mobile phones). The big.LITTLE multicore architecture, which contains high-performance cores (namely big core) and power-saved cores (namely little core), has been developed by ARM (Advanced RISC Machine) and Intel to trade off performance and power efficiency. Facing the new heterogeneous computing architecture, the traditional lock algorithms, which are designed to run on homogeneous computing architecture, cannot work optimally as usual and drop into the performance issue for the difference between big core and little core. In our preliminary experiment, we observed that, in the big.LITTLE multicore architecture, all these lock algorithms exhibit sub-optimal performance. The FIFO-based (First In First Out) locks experience throughput degradation, while the performance of competition-based locks can be divided into two categories. One of them is big-core-friendly, so their tail latency increases significantly; the other is little-core-friendly. Not only does the tail latency increase, but the throughput is also degraded. Motivated by this observation, we propose a Core-Aware Lock for the big.LITTLE multicore architecture named CAL, which keeps each core having an equal opportunity to access the critical section in the program. The core idea of the CAL is to take the slowdown ratio as the matric to reorder lock requests of these big and little cores. By evaluating benchmarks and a real-world application named LevelDB, CAL is confirmed to achieve fairness goals in heterogeneous computing architecture without sacrificing the performance of the big core. Compared to several traditional lock algorithms, the CAL's fairness has increased by up to 67%; and Its throughput is 26% higher than FIFO-based locks and 53% higher than competition-based locks, respectively. In addition, the tail latency of CAL is always kept at a low level. [ABSTRACT FROM AUTHOR]

Summary: Since the dawn of quantum computing (QC), theoretical developments like Shor's algorithm proved the conceptual superiority of QC over traditional computing. However, such quantum supremacy claims are difficult to achieve in practice because of the technical challenges of realizing noiseless qubits. In the near future, QC applications will need to rely on noisy quantum devices that offload part of their work to classical devices. One way to achieve this is by using parameterized quantum circuits in optimization or even in machine learning tasks. The energy requirements of quantum algorithms have not yet been studied extensively. In this article, we explore several optimization algorithms using both theoretical insights and numerical experiments to understand their impact on energy consumption. Specifically, we highlight why and how algorithms like quantum natural gradient descent, simultaneous perturbation stochastic approximations or circuit learning methods, are at least 2×$$ 2\times $$ to 4×$$ 4\times $$ more energy efficient than their classical counterparts; why feedback‐based quantum optimization is energy‐inefficient; and how techniques like Rosalin can improve the energy efficiency of other algorithms by a factor of ≥$$ \ge $$20×$$ \times $$. Finally, we use the NchooseK high‐level programming model to run optimization problems on both gate‐based quantum computers and quantum annealers. Empirical data indicate that these optimization problems run faster, have better success rates, and consume less energy on quantum annealers than on their gate‐based counterparts. [ABSTRACT FROM AUTHOR]

Dependent tasks are typically modeled using directed acyclic graphs (DAGs), and scheduling algorithms based on DAGs have been extensively researched. Most of the existing algorithms assume that the task or communication duration is deterministic. Nevertheless, any delays in task execution or communication can significantly affect the scheduling results. Aiming at minimizing the DAGs' makespan, a heuristic algorithms called heterogeneous optimistic complete time (HOCT) is proposed. The algorithm assumes that the task characteristic values are modeled randomly. It calculates task priorities based on the acceleration ratio and allocates computing resources using an optimistic execution timetable. Then, a Monte-Carlo simulation-based scheduling algorithm which built on the top of HOCT is proposed. Experimental results show that the proposed algorithm achieves better makespan of the stochastic DAG. It also provides a more robust scheduling solution to unpredictability than critical-path-on-a-processor, heterogeneous earliest finish time-no cross and parental prioritization earliest finish time algorithms. [ABSTRACT FROM AUTHOR]

Currently, research on the lattice Boltzmann method mainly focuses on its numerical simulation and applications, and there is an increasing demand for large-scale simulations in practical scenarios. In response to this situation, this study successfully implemented a large-scale heterogeneous parallel algorithm for the lattice Boltzmann method using OpenMP, MPI, Pthread, and OpenCL parallel technologies on the "Dongfang" supercomputer system. The accuracy and effectiveness of this algorithm were verified through the lid-driven cavity flow simulation. The paper focused on optimizing the algorithm in four aspects: Firstly, non-blocking communication was employed to overlap communication and computation, thereby improving parallel efficiency. Secondly, high-speed shared memory was utilized to enhance memory access performance and reduce latency. Thirdly, a balanced computation between the central processing unit and the accelerator was achieved through proper task partitioning and load-balancing strategies. Lastly, memory access efficiency was improved by adjusting the memory layout. Performance testing demonstrated that the optimized algorithm exhibited improved parallel efficiency and scalability, with computational performance that is 4 times greater than before optimization and 20 times that of a 32-core CPU. [ABSTRACT FROM AUTHOR]

The distributed energy power system needs to provide sufficient and flexible computing power on demand to meet the increasing digitization and intelligence requirements of the smart grid. However, the current distribution of the computing power and loads in the energy system is unbalanced, with data center loads continuously increasing, while there is a large amount of idle computing power at the edge. Meanwhile, there are a large number of real-time computing tasks in the distributed energy power system, which have strict requirements on execution deadlines and require reasonable scheduling of multi-level heterogeneous computing power to meet real-time computing demands. Based on the aforementioned background and issues, this paper studies the real-time service scheduling problem in a multi-level heterogeneous computing network of distributed energy power systems. Specifically, we consider the divisibility of tasks in the model. This paper presents a hierarchical real-time task-scheduling framework specifically designed for distributed energy power systems. The framework utilizes an orchestrating agent (OA) as the execution environment for the scheduling module. Building on this, we propose a hierarchical selection algorithm for choosing the appropriate network layer for real-time tasks. Further, we develop two scheduling algorithms based on greedy strategy and genetic algorithm, respectively, to effectively schedule tasks. Experiments show that the proposed algorithms have a superior success rate in scheduling compared to other current algorithms. [ABSTRACT FROM AUTHOR]

This article provides an enhanced parallelization of the WSM7 microphysics scheme for the Weather Research and Forecasting Model (WRF). The parallelization is designed to maximize the utilization of a heterogeneous computing system consisting of CPUs, GPUs or both. Therefore the reference implementation of the WSM7 scheme is re-implemented for the heterogeneous execution model. For each time step, a dynamic load distribution is introduced which balances the computational load between the two components aiming for an overall minimum execution time. The evaluation of the parallelized implementation is done for a specific weather situation. Specifically, the precipitation of the low-pressure zone "Bernd" from July 2021 is simulated using an Intel Core i7-7700 CPU and a NVIDIA GTX 1070 GPU. The results show a speedup of up to 28.51 for the GPU version in comparison with the reference implementation. The heterogeneous dynamic load balancing increases the speedup achieved even further by introducing a distribution factor that is updated for each time step. [ABSTRACT FROM AUTHOR]

In the era of heterogeneous computing, a new paradigm called accelerator level parallelism (ALP) has emerged. In ALP, accelerators are used concurrently to provide unprecedented levels of performance and energy efficiency. To reach that there are many problems to be solved, one of the most challenging being co-execution. In this paper, we present a new scheduling framework called POAS, a general method for providing co-execution to applications. Our proposal consists of four steps: predict, optimize, adapt and schedule. With POAS, an unseen application can be executed concurrently in ALP with little effort. We evaluate POAS on a heterogeneous environment consisting of CPUs, GPUs (CUDA cores), and XPUs (Tensor cores) on two different fields, namely linear algebra (matrix multiplication benchmark) and deep learning (convolution benchmark). Our experiments prove that POAS provides excellent performance and completes the tasks within a time very close to the optimal time for the hardware and applications used, with a negligible execution time overhead. Moreover, the POAS predictor performed exceptionally well, achieving very low RMSE values for both use cases. Therefore, POAS can be a valuable tool for fully exploiting ALP and improving overall performance over offloading in heterogeneous settings. [ABSTRACT FROM AUTHOR]

With the continuous development and maturity of the fifth-generation mobile network (5G) technology, the demand for multimedia service access is increasing, which poses huge challenges to the connectivity, caching capabilities, and computing capabilities of the Internet of Things (IoT) devices. Therefore, edge computing, as the key to achieving efficient edge data preprocessing and improving data access and response, is considered to be a hot technology for the next generation of mobile networks and future development. However, the current imbalance of computing resources on the edge, the lack of collaboration between nodes, and the lack of adaptability of optimization methods in a dynamic environment pose challenges to the development of edge computing. To strengthen the collaboration of nodes in the edge environment, we designed a collaborative task offloading and resource scheduling framework, including macro base station collaborative space (ξ BSCS) and micro base station collaborative space (μ BSCS) to balance computing and caching resources in heterogeneous wireless networks. In addition, we formulate the collaborative computing offloading problem as a Markov Decision Process (MDP), and deep reinforcement learning (DRL) agents are deployed to make task offloading and resource allocation decisions. The DRL agent is deployed in each base station (BS) in a decentralized manner, observing the available computing and caching resources on the edge side, and designing an optimal resource allocation strategy for task offloading to maximize the benefits of the long-term system. The data-driven simulation results verify that the proposed scheme is effective in reducing the overall consumption of the system, maximizing the long-term benefits of edge resource allocation, and improving the success rate of task completion. [ABSTRACT FROM AUTHOR]

The new generation of heterogeneous CPU/GPU computer systems offer much greater computational performance but are not yet widely used for climate modeling. One reason for this is that traditional climate models were written before GPUs were available and would require an extensive overhaul to run on these new machines. In addition, even conventional "high–resolution" simulations don't currently provide enough parallel work to keep GPUs busy, so the benefits of such overhaul would be limited for the types of simulations climate scientists are accustomed to. The vision of the Simple Cloud‐Resolving Energy Exascale Earth System (E3SM) Atmosphere Model (SCREAM) project is to create a global atmospheric model with the architecture to efficiently use GPUs and horizontal resolution sufficient to fully take advantage of GPU parallelism. After 5 years of model development, SCREAM is finally ready for use. In this paper, we describe the design of this new code, its performance on both CPU and heterogeneous machines, and its ability to simulate real‐world climate via a set of four 40 day simulations covering all 4 seasons of the year. Plain Language Summary: This paper describes the design and development of a 3 km version of the Energy Exascale Earth System Model (E3SM) atmosphere model, which has been fully rewritten in C++ using the Kokkos library for performance portability. This newly rewritten model is able to take advantage of the state–of–the–science high performance computing systems which use graphical processor units (GPUs) to mitigate much of the computational expense which typically plagues high–resolution global modeling. Taking advantage of this high–performance we are able to run four seasons of simulations at 3 km global resolution. We discuss the biases, including the diurnal cycle, by comparing model results with satellite and Atmospheric Radiation Measurement ground‐based site data. Key Points: Describes the C++/Kokkos implementation of the Simple Cloud–Resolving E3SM Atmosphere Model (SCREAMv1)SCREAMv1 leverages GPUs to surpass one simulated year per compute day at global 3 km resolutionHigh resolution improves some meso‐scale features and the diurnal cycle but large‐scale biases require improvement across all four seasons [ABSTRACT FROM AUTHOR]

Copyright of Journal of South-Central Minzu University (Natural Science Edition) is the property of Journal of South-Central Minzu University (Natural Science Edition) Editorial Office and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

In the realm of heterogeneous computing, the efficient allocation of resources is pivotal for optimizing system performance. However, user-submitted tasks are often complex and have varied resource demands. Moreover, the dynamic nature of resource states in such platforms, coupled with variations in resource types and capabilities, results in significant intricacy of the system environment. To this end, we propose a scheduling algorithm based on hierarchical reinforcement learning, namely MD-HRL. Such an algorithm could simultaneously harmonize task completion time, device power consumption, and load balancing. It contains a high-level agent (H-Agent) for task selection and a low-level agent (L-Agent) for resource allocation. The H-Agent leverages multi-hop attention graph neural networks (MAGNA) and one-dimensional convolutional neural networks (1DCNN) to encode the information of tasks and resources. Kolmogorov–Arnold networks is then employed for integrating these representations while calculating subtask priority scores. The L-Agent exploits a double deep Q network to approximate the best strategy and objective function, thereby optimizing the task-to-resource mapping in a dynamic environment. Experimental results demonstrate that MD-HRL outperforms several state of the art baselines. It reduces makespan by 12.54%, improves load balancing by 5.83%, and lowers power consumption by 6.36% on average compared with the suboptimal method. [ABSTRACT FROM AUTHOR]

The exponential growth of IoT devices and the surge in the data volume, coupled with the rise of latency-sensitive applications, has led to a heightened interest in fog computing to meet user demands. In this context, the service provisioning problem consists of dynamically selecting desirable fog computing nodes and routing user traffic to these nodes. Given that the fog computing layer is composed of heterogeneous nodes, which vary in resource capacity, availability, and power sources, the service provisioning problem becomes challenging. Existing solutions, often using classical optimization approaches or heuristic algorithms due to the NP-hardness of the problem, have struggled to address the issue effectively, particularly in accounting for the heterogeneity of fog nodes and uncertainty of the ad hoc fog nodes. These techniques show exponential computation times and deal only with small network scales. To overcome these issues, we are motivated to replace these approaches with deep reinforcement learning (DRL) techniques, specifically employing the proximal policy optimization (PPO) algorithm to understand the dynamic behavior of the environment. The main objective of the proposed DRL-based dynamic service provisioning (DDSP) algorithm is minimizing service provisioning costs while considering service delay constraints, the uncertainty of ad hoc fog nodes, and the heterogeneity of both ad hoc and dedicated fog nodes. Extensive simulations demonstrate that our approach provides a near-optimal solution with high efficiency. Notably, our proposed algorithm selects more stable fog nodes for service provisioning and successfully minimizes cost even with uncertainty regarding ad hoc fog nodes, compared to heuristic algorithms. [ABSTRACT FROM AUTHOR]

A cloud computing environment is a distributed system where idle resources are accessible across a wide area network, such as the Internet. Due to the diverse specifications of these resources, computational clouds exhibit high heterogeneity. Task scheduling, the process of dispatching cloud applications onto processing nodes, becomes a critical challenge in such environments. Ensuring high utilization in this heterogeneous environment entails identifying suitable machines or virtual machines capable of efficiently executing jobs, constituting a multi-objective optimization problem. This paper proposes a dynamic Learning Automata-based Task Assignment algorithm, named LATA, to address this challenge. In the algorithm, each application is represented as a Directed Acyclic Graph, with tasks as nodes and data dependencies as edges. Initially, tasks are grouped based on their data dependencies to consolidate independent tasks into one group. Subsequently, a variable-structure learning automaton is assigned to each group of tasks to identify appropriate task-machine combinations. The primary objectives of LATA include minimizing makespan and energy consumption by facilitating efficient task placement to achieve load balance and maximize resource utilization. Additionally, an enhancement is proposed, involving the use of a different grouping policy prior to task assignment to further improve performance. Computer simulation results demonstrate the superior performance of the proposed algorithms in highly heterogeneous environments compared to state-of-the-art algorithms. Notably, total execution time and energy consumption decrease by up to 50% and 37%, respectively. [ABSTRACT FROM AUTHOR]

Along with the rising popularity of pay-as-you-go cloud services, many businesses and communities are deploying their business or scientific workflow applications on cloud-based computing platforms. The primary responsibility of cloud service providers is to reduce the monetary cost and execution time of Infrastructure as a Service (IaaS) cloud services. The majority of current solutions for cost and makespan reduction were developed for conventional cloud platforms and are incompatible with heterogeneous computing systems (HCS) having service-based resource management approaches and pricing models. Fog-cloud infrastructures (FCI) have emerged as desirable target areas for workflow automation across several fields of application. In heterogeneous FCI, the execution of workflows involving tasks having different properties might influence the performance in terms of resource usage. The primary goal of this research is to efficiently offload the computational task and optimally schedule the workflow in such diverse computing environment. In this article, we present a novel strategy for building an environment that includes techniques for offloading and scheduling while balancing competing demands from the user and the resource providers. In order to address the issue of uncertainty, our approach incorporates a fuzzy dominance-based task clustering and offloading technique. To construct a suitable execution sequence of tasks that helps to limit the precedence relationship, by preserving dependency constraints among the tasks, a novel algorithm for tasks segmentation is employed. To simplify the problem of the complexity, a hybrid-heuristics based on Harmony Search Algorithm (HSA) and Genetic Algorithm (GA) for resource scheduling algorithm is used. The multi-objective optimization using three competing objectives is taken into consideration for investigation in heterogeneous FCI. The fitness function derived includes minimization of makespan and cost along with maximization of resource utilization. We performed experimental research using five workflow datasets in order to investigate and verify the efficacy of our proposed technique. We contrasted our proposed strategy with the primary, closely comparable strategies. Extensive testing using scientific workflows confirms the effectiveness of our offloading approach. Our solution provided a substantially better cost-makespan tradeoffs, while achieving significantly less energy consumption and can execute marginally quicker than the existing algorithms. [ABSTRACT FROM AUTHOR]

The rapid advancement in embedded AI, driven by integrating deep neural networks (DNNs) into embedded systems for real-time image and video processing, has been notably pushed by AI-specific platforms like the AMD Xilinx Vitis AI on the MPSoC-FPGA platform. This platform utilizes a configurable Deep Processing Unit (DPU) for scalable resource utilization and operating frequencies. Our study employed a detailed methodology to assess the impact of various DPU configurations and frequencies on resource utilization and energy consumption. The findings reveal that increasing the DPU frequency enhances resource utilization efficiency and improves performance. Conversely, lower frequencies significantly reduce resource utilization, with only a borderline decrease in performance. These trade-offs are influenced not only by frequency but also by variations in DPU parameters. These findings are critical for developing energy-efficient AI-driven systems in Advanced Driver Assistance Systems (ADAS) based on real-time video processing. By leveraging the capabilities of Xilinx Vitis AI deployed on the Kria KV260 MPSoC platform, we explore the intricacies of optimizing energy efficiency through multi-task learning in real-time ADAS applications. [ABSTRACT FROM AUTHOR]

Summary: The data‐intensive workflow application executes tasks on edge servers and cloud platforms in a heterogeneous big‐data computing environment. Cloud and edge servers are vulnerable to node attacks and malicious links due to their wireless connections. Thus, detecting and mitigating rogue nodes in edge server communication environments during workflow execution is crucial. In today's workflow execution landscape, there is a rising emphasis on resolving Quality of Service (QoS) and security concerns within homogeneous execution settings. Workflow execution on diverse computing platforms has received limited research. We are developing an edge‐cloud‐specific Multi‐Layer Security and Quality‐Aware (MLSQA) framework to solve research issues in this area. Node attacks are detected via reputation‐based security features in the MLSQA framework, whereas link attacks are detected using machine learning. A unique trade‐off metrics technique optimizes workflow security and QoS parameters, reducing energy usage and makespan. In addition, a fault‐tolerant, energy‐efficient job offloading technique is described in detail to improve the system's resilience to errors. The experiment is conducted using complex (i.e., memory and CPU intensive) scientific procedures with intermediate job dependencies, namely Inspiral workflow. The MLSQA framework excels in threat detection, demonstrating lower false alarms, reduced energy consumption, and quicker implementation than the recent secure workflow execution architecture. [ABSTRACT FROM AUTHOR]

This work presents a performance-oriented study of a heterogeneous application developed with Intel OneAPI to solve two well-known diffusion problems: heat diffusion and image denoising. We have explored CPU+iGPU and CPU+FPGA schemes, applying dynamic load balancing and conducting experiments on Intel DevCloud. The results demonstrate that the CPU+iGPU scheme outperforms the execution times achieved by the fastest device when the problem is sufficiently computationally demanding. We also found that the performance of the CPU+FPGA scheme is heavily affected by bandwidth limitations and specific strategies to manage memory efficiently are required. Moreover, it was demonstrated that dynamic workload balancing is crucial due to possible performance fluctuations in any of the implicated devices. In conclusion, Intel OneAPI provides a helpful tool for multi-platform development using a unique high-level language, DPC++. However, developing specific code for each platform is necessary to achieve optimal performance. [ABSTRACT FROM AUTHOR]

FlowDenoising is a new approach to noise reduction in biological volumes obtained with three-dimensional electron microscopy (3DEM). Its abilities to enhance the structural features stem from the fact that an anisotropic Gaussian filtering is steered according to the local structures. To this end, the Optical Flow (OF) among consecutive slices is estimated, which is the most computationally expensive step in this approach. In this article, a hybrid CPU/GPU implementation of FlowDenoising is introduced and evaluated. It exploits parallel computing by distributing the workload among multiple cores and takes advantage of the massive processing in GPUs to accelerate the OF estimation. The hybrid implementation provides remarkable speed-up factors and an important reduction of the processing time, which is particularly relevant for the denoising of huge volumes typically found in 3DEM. [ABSTRACT FROM AUTHOR]

The service-oriented heterogeneous cloud computing system offers paid computing services through its powerful processors. However, task execution failures caused by processors can diminish application reliability and user service quality. Replication technology can enhance application reliability, but an inappropriate number of replicas may occupy valuable computing resources. To address this, we propose FastMinRR, a fault-tolerant scheduling algorithm that rapidly minimizes the number of replicas while meeting reliability requirements. FastMinRR initially allocates all tasks to the currently available and most reliable processor without replication, utilizing a priority queue to store tasks based on increasing reliability. Subsequently, FastMinRR dequeues a task, increases its replicas, updates reliability, recalculates application reliability, and enqueues the task. This process repeats until the application reliability aligns with requirements. Experiments demonstrate that, compared to existing fault-tolerant scheduling algorithms in service-oriented heterogeneous cloud computing systems, FastMinRR efficiently increases the minimum number of task replicas and meets application reliability requirements. [ABSTRACT FROM AUTHOR]

This paper proposes a parallel algorithm exploiting heterogeneous computing and edge computing for anomaly detection (AD) in remotely sensed multispectral images. These images present high spatial resolution and are captured onboard unmanned aerial vehicles. AD is applied to identify patterns within an image that do not conform to the expected behavior. In this paper, the anomalies correspond to human-made constructions that trigger alarms related to the integrity of fluvial ecosystems. An algorithm based on extracting spatial information by using extinction profiles (EPs) and detecting anomalies by using the Reed–Xiaoli (RX) technique is proposed. The parallel algorithm presented in this paper is designed to be executed on multi-node heterogeneous computing platforms that include nodes with multi-core central processing units (CPUs) and graphics processing units (GPUs) and on a mobile embedded system consisting of a multi-core CPU and a GPU. The experiments are carried out on nodes of the FinisTerrae III supercomputer and, with the objective of analyzing its efficiency under different energy consumption scenarios, on a Jetson AGX Orin. [ABSTRACT FROM AUTHOR]

The motivation of task scheduling in heterogeneous computing systems is the optimal management of heterogeneous distributed resources as well as the exploitation of system capabilities. Energy consumption is one of the most important issues in dealing with task scheduling in heterogeneous distributed systems. In addition to energy, the task completion time and the task cost have also been added to the concerns of the users. Since the nature of computing systems is heterogeneous and dynamic, task scheduling with traditional methods is inefficient. Meta-heuristic approaches for task scheduling in heterogeneous distributed systems are open problems that have attracted the attention of researchers. So far, many meta-heuristic approaches have addressed the task scheduling problem. However, most of these algorithms are developed for homogeneous systems and optimize only one of the quality-of-service parameters. With this motivation, this paper presents an optimization for energy-aware design of task scheduling in heterogeneous distributed systems using meta-heuristic approaches. We simultaneously consider several parameters such as energy, task completion time and task execution cost for task scheduling. The Harris Hawk Optimization (HHO) algorithm is considered for the optimization task due to its adaptability to large search spaces. We combine HHO with a greedy algorithm to avoid local optima and early convergence. The evaluation of the proposed method has been done through numerical simulations. Experimental results show promising performance of the proposed method in terms of energy consumption. [ABSTRACT FROM AUTHOR]

With the continuous emergence of intelligent network applications and complex tasks for mobile terminals, the traditional single computing model often fails to meet the greater requirements of computing and network technology, thus promoting the formation of a new computing power network architecture, of 'cloud, edge and end' three-level heterogeneous computing. For complex divisible computing tasks in the network, task decomposition and offloading help to realize a distributed execution of tasks, thus reducing the overall running time and improving the utilization of fragmented resources in the network. However, in the process of task decomposition and offloading, there are problems, such as there only being a single method of task decomposition; that too large or too small decomposition granularity will lead to an increase in transmission delay; and the pursuit of low-delay and low-energy offloading requirements. Based on this, a complex divisible computing task decomposition and offloading scheme is proposed. Firstly, the computational task is decomposed into multiple task elements based on code partitioning, and then a density-peak-clustering algorithm with an improved adaptive truncation distance and clustering center (ATDCC-DPC) is proposed to cluster the task elements into subtasks based on the task elements themselves and the dependencies between the task elements. Secondly, taking the subtasks as the offloading objects, the improved Double Deep Q-Network subtask offloading algorithm (ISO-DDQN) is proposed to find the optimal offloading scheme that minimizes the delay and energy consumption. Finally, the proposed algorithms are verified by simulation experiments, and the scheme in this paper can effectively reduce the task delay and energy consumption and improve the service experience. [ABSTRACT FROM AUTHOR]

As a GPU has become an essential component in high performance computing, it has been attempted by many works to leverage GPU computing in Hadoop. However, few works considered to fully utilize the GPU in Hadoop and only a few works studied utilizing both CPU and GPU at the same time. In this paper, we propose a CPU-GPU hybrid scheduling in Hadoop, where both CPUs and GPUs in a node are exploited as much as possible in an adaptive manner. The technical barrier stands in that the optimal number of GPU tasks is not known in advance, and the total number of Containers in a node cannot be changed once a Hadoop job starts. In the proposed approach, we first determine the initial number of Containers as well as the hybrid execution mode, then the proposed dynamic scheduler adjusts the number of Containers for a GPU and a CPU with the help of a GPU monitor during the job execution. It also employs a load-balancing algorithm for the tail. The experiments with various benchmarks show that the proposed CPU-GPU hybrid scheduling achieves 3.87 × of speedup on average against the 12-core CPU-only Hadoop. [ABSTRACT FROM AUTHOR]

Real-time online trajectory map-matching has emerged as a critical component in the era of location-based services (LBS) and intelligent transportation systems (ITS). It refers to the process of aligning a user's GPS trajectory data with the corresponding road network in real-time. This technology has significant implications for various industries and applications. As our reliance on LBS and ITS continues to grow, the demand for faster, more accurate, and more reliable trajectory map-matching methods becomes increasingly important. Contemporary online map-matching predominantly employs stream processing techniques. Based on stream processing frameworks, we propose a heterogeneous hybrid architecture for map-matching. The architecture integrates Spark Streaming and graphics processing unit (GPU) heterogeneous computing for the first time. The hidden Markov model is employed as the map-matching algorithm, and Spark Streaming serves as the distributed processing platform. We conduct map-matching experiments using a GPS taxi trajectory dataset in Beijing's Haidian District. The results demonstrate that in comparison to other analogous research, our framework's performance has increased by over ten times, possessing a superior data processing capability and lower latency. This research provides a novel approach of stream-based heterogeneous computation for processing large-scale geographic data. [ABSTRACT FROM AUTHOR]

Cloud services are now seeing significant advancements and have witnessed a growing demand. Hence, implementing Load Balancing is necessary to enhance resource usage by effectively distributing workload among numerous Virtual Machines (VMs). The present research aims to address task scheduling challenges and achieve efficient load balancing for all VMs by implementing a novel noncooperative load balancing algorithm called Multi-agent Independent Deep Q Networks (MAIDQN-LB) in cloud computing heterogeneous networks. The list of tasks is passed to MAIDQN-LB, which will search for a list of VM to be allocated, maintaining the load of all VMs. This procedure facilitates the identification of optimized VMs, the allocation of workloads based on the optimal solution derived from the analysis and optimize the performance parameters. The performance analysis considers essential parameters, including makespan time, average turnaround time, average response time, degree of imbalance (DI), task rejection rate (TRR), and convergence loss. The findings indicate that MAIDQN-LB demonstrates superior performance compared to the current system, exhibiting enhancements of 1.82% and 0.05% regarding DI and TRR. [ABSTRACT FROM AUTHOR]

The diversity and scarcity of resources across devices in heterogeneous computing environments can impact their ability to meet users' quality-of-service (QoS) requirements, especially in open real-time environments where computational loads are unpredictable. Despite this uncertainty, timely responses to events remain essential to ensure desired performance levels. To address this challenge, this paper introduces collaborative service execution, enabling resource-constrained IoT devices to collaboratively execute services with more powerful neighbors at the edge, thus meeting non-functional requirements that might be unattainable through individual execution. Nodes dynamically form clusters, allocating resources to each service and establishing initial configurations that maximize QoS satisfaction while minimizing global QoS impact. However, the complexity of open real-time environments may hinder the computation of optimal local and global resource allocations within reasonable timeframes. Thus, we reformulate the QoS optimization problem as a heuristic-based anytime optimization problem, capable of interrupting and quickly adapting to environmental changes. Extensive simulations demonstrate that our anytime algorithms rapidly yield satisfactory initial service solutions and effectively optimize the solution quality over iterations, with negligible overhead compared to the benefits gained. [ABSTRACT FROM AUTHOR]

Sequence alignment is a critical factor in the variant analysis of genomic research. Since the FM (Ferrainas–Manzini) index was developed, it has proven to be a model in a compact format with efficient pattern matching and high-speed query searching, which has attracted much research interest in the field of sequence alignment. Such characteristics make it a convenient tool for handling large-scale sequence alignment projects executed with a small memory. In bioinformatics, the massive success of next-generation sequencing technology has led to an exponential growth in genomic data, presenting a computational challenge for sequence alignment. In addition, the use of a heterogeneous computing system, composed of various types of nodes, is prevalent in the field of HPC (high-performance computing), which presents a promising solution for sequence alignment. However, conventional methodologies in short-read alignment are limited in performance on current heterogeneous computing infrastructures. Therefore, we developed a parallel sequence alignment to investigate the applicability of this approach in NUMA-based (Non-Uniform Memory Access) heterogeneous architectures against traditional alignment algorithms. This proposed work combines the LF (longest-first) distribution policy with the EP (enhanced partitioning) strategy for effective load balancing and efficient parallelization among heterogeneous architectures. The newly proposed LF-EP-based FM aligner shows excellent efficiency and a significant improvement over NUMA-based heterogeneous computing platforms. We provide significantly improved performance over several popular FM aligners in many dimensions such as read length, sequence number, sequence distance, alignment speedup, and result quality. These resultant evaluation metrics cover the quality assessment, complexity analysis, and speedup evaluation of our approach. Utilizing the capabilities of NUMA-based heterogeneous computing architectures, our approach effectively provides a convenient solution for large-scale short-read alignment in the heterogeneous system. [ABSTRACT FROM AUTHOR]

Suppose that a sequence of random pairs (X 1 , Y 1) , ... , (X n , Y n) is subject to a gradual change in the sense that for K 1 ≤ K 2 ∈ { 1 , ... , n } , the joint distribution is F before K 1 , G after K 2 , and gradually moving from F to G between the two times of change K 1 and K 2 . This setup elegantly generalizes the abrupt-change model that is usually assumed in the change-point analysis. Under this configuration, asymptotically unbiased estimates of Kendall's tau up to and after the change are proposed, as well as tests and estimators of change points related to these measures. The asymptotic behaviour of the introduced estimators and test statistics is rigorously investigated, in particular by demonstrating a general result on weighted indexed U-statistics computed under a heterogeneous pattern. A simulation study is conducted to examine the sampling properties of the proposed methods under different scenarios of change in the dependence structure of bivariate series. An illustration is given on a time series of monthly atmospheric carbon dioxide concentrations and global temperature for the period 1959–2015. [ABSTRACT FROM AUTHOR]

Efficient allocation of tasks and resources is crucial for the performance of heterogeneous cloud computing platforms. To achieve harmony between task completion time, device power consumption, and load balance, we propose a Graph neural network-enhanced Elite Particle Swarm Optimization (EPSO) model for collaborative scheduling, namely GraphEPSO. Specifically, we first construct a Directed Acyclic Graph (DAG) to model the complicated tasks, thereby using Graph Neural Network (GNN) to encode the information of task sets and heterogeneous resources. Then, we treat subtasks and independent tasks as basic task units while considering virtual or physical devices as resource units. Based on this, we exploit the performance adaptation principle and conditional probability to derive the solution space for resource allocation. Besides, we employ EPSO to consider multiple optimization objectives, providing fine-grained perception and utilization of task and resource information. It also increases the diversity of particle swarms, allowing GraphEPSO to adaptively search for the global optimal solution with the highest probability. Experimental results demonstrate the superiority of our proposed GraphEPSO compared to several state-of-the-art baseline methods on all evaluation metrics. [ABSTRACT FROM AUTHOR]

The integration of quantum processing units (QPUs) in a heterogeneous high-performance computing environment requires solutions that facilitate hybrid classical–quantum programming. Standards such as OpenCL facilitate the programming of heterogeneous environments, consisting of CPUs and hardware accelerators. This study presents an innovative method that incorporates QPU functionality into OpenCL, standardizing quantum processes within classical environments. By leveraging QPUs within OpenCL, hybrid quantum–classical computations can be sped up, impacting domains like cryptography, optimization problems, and quantum chemistry simulations. Using Portable Computing Language (Jääskeläinen et al. in Int J Parallel Program 43(5):752–785, 2014. https://doi.org/10.1007/s10766-014-0320-y) and the Qulacs library (Suzuki et al. in Quantum 5:559, 2021. https://doi.org/10.22331/q-2021-10-06-559), results demonstrate, for instance, the successful execution of Shor's algorithm (Nielsen and Chuang in Quantum computation and quantum information, 10th anniversary edn. Cambridge University Press, Cambridge, 2010), serving as a proof of concept for extending the approach to larger qubit systems and other hybrid quantum–classical algorithms. This integration approach bridges the gap between quantum and classical computing paradigms, paving the way for further optimization and application to a wide range of computational problems. [ABSTRACT FROM AUTHOR]

Heterogeneous platforms composed of multiple different types of computing devices (such as CPUs, GPUs, and Intel MICs) have been widely used recently. However, most of parallel applications developed in such a heterogeneous platform usually only utilize a certain kind of computing device due to the lack of easy‐to‐use heterogeneous cooperative parallel programming models. To reduce the difficulty of heterogeneous cooperative parallel programming, a directive‐based heterogeneous cooperative parallel programming framework called HeteroPP is proposed. HeteroPP provides an easier way for programmers to fully exploit multiple different types of computing devices to concurrently and cooperatively perform data‐parallel applications on heterogeneous platforms. An extension to OpenMP directives and clauses is proposed to make it possible for programmers to easily offload a data‐parallel compute kernel to multiple different types of computing devices. A source‐to‐source compiler is designed to help programmers to automatically generate multiple device‐specific compute kernels that can be concurrently and cooperatively performed on heterogeneous platforms. Many experiments are conducted with 12 typical data‐parallel applications implemented with HeteroPP on a heterogeneous CPU‐GPU‐MIC platform. The results show that HeteroPP not only greatly simplifies the heterogeneous cooperative parallel programming, but also can fully utilize the CPUs, GPU, and MIC to efficiently perform these applications. [ABSTRACT FROM AUTHOR]

A key benefit of the Open Computing Language (OpenCL) software framework is its capability to operate across diverse architectures. Field programmable gate arrays (FPGAs) are a high-speed computing architecture used for computation acceleration. This study investigates the impact of memory access time on overall performance in general FPGA computing environments through the creation of eight benchmarks within the OpenCL framework. The developed benchmarks capture a range of memory access behaviors, and they play a crucial role in assessing the performance of spinning and sleeping on FPGA-based architectures. The results obtained guide the formulation of new implementations and contribute to defining an abstraction of FPGAs. This abstraction is then utilized to create tailored implementations of primitives that are well-suited for this platform. While other research endeavors concentrate on creating benchmarks with the Compute Unified Device Architecture (CUDA) to scrutinize the memory systems across diverse GPU architectures and propose recommendations for future generations of GPU computation platforms, this study delves into the memory system analysis for the broader FPGA computing platform. It achieves this by employing the highly abstracted OpenCL framework, exploring various data workload characteristics, and experimentally delineating the appropriate implementation of primitives that can seamlessly integrate into a design tailored for the FPGA computing platform. Additionally, the results underscore the efficacy of employing a task-parallel model to mitigate the need for high-cost synchronization mechanisms in designs constructed on general FPGA computing platforms. [ABSTRACT FROM AUTHOR]

Heterogeneous computing has been developing continuously in the field of high-performance computing because of its high performance and energy efficiency. More and more accelerators have emerged, such as GPU, FPGA, DSP, AI accelerator, and so on. Usually, the accelerator is connected to the host CPU as a peripheral device to form a tightly coupled heterogeneous computing node, and then, a parallel system is constructed by multiple nodes. This organization is computationally efficient, but not flexible. When new accelerators appear, it is difficult to join the system that has been built. At the hardware level, we create an array of accelerators and connect them to the existing system through a high-speed network. At the software level, we dynamically organize computing resources from various arrays to build a virtual heterogeneous computing node. This approach also includes a standard programming environment. Therefore, it is a more flexible, elastic, and scalable heterogeneous computing organization. In this paper, a supernode OpenCL implementation is proposed for hybrid parallel computing systems, in which virtual supernodes can be dynamically constructed between different computing arrays, and a standard OpenCL environment is implemented based on RDMA communication of high-speed interconnection, which can be combined with the system-level MPI programming environment, thereby realizing the large-scale parallel computing of the hybrid array. SNCL is compatible with existing MPI/OpenCL programs without the need for additional modifications. Experiments show that the runtime overhead of the supernode OpenCL environment is very low, and it is suitable for deploying applications with high computing density and large data scale between different arrays to utilize their computing power without affecting scalability. [ABSTRACT FROM AUTHOR]

The finite‐difference time‐domain (FDTD) method often demands numerous grids for fine structure analysis, leading to high computational costs. To address this challenge, a subgridding scheme emerges as an attractive solution. However, the explicit nature of the FDTD subgrid method, constrained by Courant–Friedrichs–Lewy (CFL) conditions, can lead to inefficiencies with complex structures. In response, the leapfrog alternating‐direction implicit (ADI)‐FDTD method, exhibiting unconditional stability, has been developed to overcome CFL limitations. This paper presents a hybrid approach merging the one‐step leapfrog ADI‐FDTD method with a subgridding scheme using heterogeneous computing. By optimizing hardware usage and leveraging different device performances, this approach maximizes throughput in heterogeneous systems. Central processing units and graphics processing units handle workloads to minimize system latency. Simulation results on heterogeneous platforms demonstrate superior efficiency over single processor setups while maintaining simulation accuracy, especially in analyzing electromagnetic scattering from multiscale structures. [ABSTRACT FROM AUTHOR]

In the current computing environment, the significance of distributed heterogeneous systems has gained prominence. The research on scheduling problems in distributed systems that consider energy consumption has garnered substantial attention due to its potential to enhance system stability, achieve energy savings, and contribute to environmental preservation. However, efficient scheduling in such systems necessitates not only the consideration of energy consumption but also the ability to adapt to the dynamic nature of the system. To tackle these challenges, we propose an online energy-aware scheduling algorithm for deadline-constrained applications in distributed heterogeneous systems, leveraging dynamic voltage and frequency scaling (DVFS) techniques. First, the algorithm models the continuously arriving applications and heterogeneous processors and proposes a novel task-sorting method to prioritize tasks, ensuring that more applications are completed within their respective deadlines. Second, the algorithm controls the selection range of processors based on the task's subdeadline and assigns the task to the processor with the minimum energy consumption. Through experiments conducted with randomly generated applications, our approach consistently exhibits superior performance when compared to similar scheduling algorithms. [ABSTRACT FROM AUTHOR]

While tensor accelerated compilers have proven effective in deploying deep neural networks (DNN) on general-purpose hardware, optimizing for FPGA remains challenging due to the complex DNN architectures and the heterogeneous, semi-open compute units. This paper introduces the Automatic Kernel Generation for DNN on CPU-FPGA (AKGF) framework for efficient deployment of DNN on heterogeneous CPU-FPGA platforms. AKGF generates an intermediate representation (IR) of the DNN using TVM's Halide IR, annotates the operators of model layers in the IR to compute them on the corresponding hardware cores, and further optimizes the operator code for CPU and FPGA using ARM's function library and the polyhedral model to enhance model inference speed and power consumption. The experimental tests conducted on a CPU-FPGA board validate the effectiveness of AKGF, demonstrating significant acceleration ratios (up to 6.7x) compared to state-of-the-art accelerators while achieving a 2x power optimization. AKGF effectively leverages the computational capabilities of both CPU and FPGA for high-performance deployment of DNN on CPU-FPGA platforms. [ABSTRACT FROM AUTHOR]

In this work, we detail the GPU-porting of an in-house pseudo-spectral solver tailored towards large-scale simulations of interface-resolved simulation of drop- and bubble-laden turbulent flows. The code relies on direct numerical simulation of the Navier-Stokes equations, used to describe the flow field, coupled with a phase-field method, used to describe the shape, deformation, and topological changes of the interface of the drops or bubbles. The governing equations – Navier-Stokes and Cahn-Hilliard equations – are solved using a pseudo-spectral method that relies on transforming the variables in the wavenumber space. The code targets large-scale simulations of drop- and bubble-laden turbulent flows and relies on a multilevel parallelism. The first level of parallelism relies on the message-passing interface (MPI) and is used on multi-core architectures in CPU-based infrastructures. A second level of parallelism relies on OpenACC directives and cuFFT libraries and is used to accelerate the code execution when GPU-based infrastructures are targeted. The resulting multiphase flow solver can be efficiently executed in heterogeneous computing infrastructures and exhibits a remarkable speed-up when GPUs are employed. Thanks to the modular structure of the code and the use of a directive-based strategy to offload code execution on GPUs, only minor code modifications are required when targeting different computing architectures. This improves code maintenance, version control and the implementation of additional modules or governing equations. [ABSTRACT FROM AUTHOR]