Search

Evolutionary Multi-Tasking (EMT), which shares knowledge across multiple tasks while the optimization progresses online, has demonstrated superior performance in terms of both optimization quality and convergence speed over its single-task counterpart in solving complex optimization problems. However, most of existing EMT algorithms only consider to handle two tasks simultaneously. As the computational cost incurred in the evolutionary search and knowledge transfer increased rapidly with the number of optimization tasks, these EMT algorithms cannot meet today’s requirements of optimization service on the cloud for many real-world applications, where hundreds or thousands of optimization requests (labelled as large-scale EMT) are often received simultaneously and require to be optimized in a short time. Recently, Graphics Processing Unit (GPU) computing has attracted extensive attention to accelerate the applications possessing large-scale data volume that are traditionally handled by the Central Processing Unit (CPU). Taking this cue, towards large-scale EMT, in this paper, we propose a new EMT paradigm based on the island model with the Compute Unified Device Architecture (CUDA), which is able to handle a large number of continuous optimization tasks efficiently and effectively. Moreover, under the proposed paradigm, we develop the GPU-based implicit and explicit knowledge transfer mechanisms for EMT. To evaluate the performance of the proposed paradigm, comprehensive empirical studies have been conducted against its CPU-based counterpart in large-scale EMT.

Existing image databases contain a few diversity of images. Likewise, there is no specific image base available in other situations, leading to the need to undertake additional efforts in capturing images and creating datasets. Many of these datasets contain only a single object in each image, but often the scenario in which projects must operate in production requires several objects per image. Thus, it is necessary to expand original datasets into more complex ones with specific combinations to achieve the goal of the application. This work proposes a technique for image generation to extend an initial dataset. It has been designed generically to work with various images and create a data set from some initial images. The generated set of images is used in a distributed environment. It is possible to perform image generation in this environment, producing datasets with specific images to work in certain applications. The generation of images consists of two methods: generation by deformation and generation by a neural network. With the proposed methods, this work sought to bring as main contributions the specification and implementation of an image generating component so that it is possible to easily integrate it with possible heterogeneous devices capable of parallel computing, such as General Purpose Graphics Processing Unit (GPGPU). In comparison with the existing methods to the proposed one, this one proposes to use the image generator enlarging an initial image bank with the combination of two methods. Some experiments are presented doing generation with handwritten digits to validate the proposed approach. The generator was designed with CUDA and GPU-optimized libraries as TensorFlow-specific modules. The results obtained can optimize the integration process with the simulation of possible stimuli choices, avoiding problems in the generation of image phase tests.

PurposeThis paper aims to evaluate different approaches for the parallelization of compute-intensive tasks. The study compares a Java multi-threaded algorithm, distributed computing solutions with MapReduce (Apache Hadoop) and resilient distributed data set (RDD) (Apache Spark) paradigms and a graphics processing unit (GPU) approach with Numba for compute unified device architecture (CUDA).Design/methodology/approachThe paper uses a simple but computationally intensive puzzle as a case study for experiments. To find all solutions using brute force search, 15! permutations had to be computed and tested against the solution rules. The experimental application comprises a Java multi-threaded algorithm, distributed computing solutions with MapReduce (Apache Hadoop) and RDD (Apache Spark) paradigms and a GPU approach with Numba for CUDA. The implementations were benchmarked on Amazon-EC2 instances for performance and scalability measurements.FindingsThe comparison of the solutions with Apache Hadoop and Apache Spark under Amazon EMR showed that the processing time measured in CPU minutes with Spark was up to 30% lower, while the performance of Spark especially benefits from an increasing number of tasks. With the CUDA implementation, more than 16 times faster execution is achievable for the same price compared to the Spark solution. Apart from the multi-threaded implementation, the processing times of all solutions scale approximately linearly. Finally, several application suggestions for the different parallelization approaches are derived from the insights of this study.Originality/valueThere are numerous studies that have examined the performance of parallelization approaches. Most of these studies deal with processing large amounts of data or mathematical problems. This work, in contrast, compares these technologies on their ability to implement computationally intensive distributed algorithms.

Diabetic retinopathy is one of the dangerous fundus diseases that leads to irreversible loss of vision. In the case of untimely or incorrect treatment, blindness occurs. Currently, laser coagulation is a common treatment method. An ophthalmologist uses a laser to apply a series of burns to the retina. The success of the operation depends entirely on the experience of the doctor. The automatic formation of a preliminary plan of coagulates allows us to solve a number of problems related to the operation, such as long manual placement of coagulates or adjustment of laser power. Thus, the probability of a doctor’s error is reduced, and the preparation time for the operation is significantly reduced. One of the key stages in the formation of the plan is the segmentation of the fundus image. This stage is carried out with the help of texture features, the calculation of which takes a long time. In relation to this, this study proposes high-performance algorithms for the segmentation of fundus images using CUDA technologies, which significantly speed up sequential versions and outperform parallel algorithms.

A digitized analog signal often encounters a high-frequency noisy background which degrades the signal-to-noise ratio (SNR) particularly in case of low signal strength. Despite quite a lot of hardware- and software-based approaches have been reported to date to deal with the noise issue, it is still a challenging task to real-time retrieve the noise-contaminated low-frequency information efficiently without degrading the original bandwidth. In this paper, we report a modified unsharp-masking (UM)-based Graphics Processing Unit (GPU)-accelerated algorithm to efficiently suppress a high-frequency noisy background in a digitized two-dimensional image. The proposed idea works effectively even if noise-density is high and signal of interest is comparable or weaker than the maximum noise level. While suppressing the noisy background, the original resolution remains least compromised. We first explore the effectiveness of the algorithm by means of simulated images and subsequently extend our demonstration towards a real-world life-science imaging application. Securing a potential for real-time applicability, we implement the algorithm via Compute Unified Device Architecture (CUDA)-acceleration and preserve a $ < 300~\mu \text{s}$ processing time for a $1000\times 1000$ -sized 8-bit data set.

In this paper we investigate the utilization of variadic templates for numerical methods and finite difference schemes. Specifically, an efficient method for defining multivariate functions in the ...

Stencil codes (a.k.a. nearest-neighbor computations) are widely used in image processing, machine learning, and scientific applications. Stencil codes incur nearest-neighbor data exchange because the value of each point in the structured grid is calculated as a function of its value and the values of a subset of its nearest-neighbor points. When running on Graphics Processing Unit (GPUs), stencil codes exhibit a high degree of data sharing between nearest-neighbor threads. Sharing is typically implemented through shared memories, shuffle instructions, and on-chip caches and often incurs performance overheads due to the redundancy in memory accesses. In this article, we propose Neighbor Data (NeDa), a direct nearest-neighbor data sharing mechanism that uses two registers embedded in each streaming processor (SP) that can be accessed by nearest-neighbor SP cores. The registers are compiler-allocated and serve as a data exchange mechanism to eliminate nearest-neighbor shared accesses. NeDa is embedded carefully with local wires between SP cores so as to minimize the impact on density. We place and route NeDa in an open-source GPU and show a small area overhead of 1.3%. The cycle-accurate simulation indicates an average performance improvement of 21.8% and power reduction of up to 18.3% for stencil codes in General-Purpose Graphics Processing Unit (GPGPU) standard benchmark suites. We show that NeDa’s performance is within 13.2% of an ideal GPU with no overhead for nearest-neighbor data exchange.

El propósito de este trabajo es responder a la pregunta sobre la viabilidad de ejecutar una aplicación, cuyas tareas principales son la comunicación con una base de datos, en diferentes entornos. Tradicionalmente, la ejecución de un programa viene gestionada por una Unidad de Procesamiento Central (CPU). Sin embargo, se ha observado el gran potencial de las Unidades de Procesamiento Gráfico (GPU) para ejecutar tareas de mayor complejidad o que requieren un procesado de datos muy elevado. Con este proyecto quieren observarse las implicaciones que supone ejecutar la misma aplicación en un escenario, donde la mayor parte de tareas las ejecuta una GPU. Finalmente, se tendrán en cuenta las implicaciones energéticas y de rendimiento para determinar si esta transición es realmente una opción viable. The aim of this project is to answer the question on the viability of running an application, of which the main tasks consist in communicating with a database, in different environments. Traditionally, the Central Processing Unit (CPU) oversees the execution of a program. Nonetheless, Graphic Processing Units (GPU) have shown a high potential when processing big amounts of data or more complex information. The goal is to observe the different implications that migrating from one environment to another, will have. All in all, energy usage and performance implications will be considered, to determine whether this alternative is a viable solution, or not.

Coprocessor architectures in High Performance Computing are prevalent in today’s scientific computing clusters and require specialized knowledge for proper utilization. Various alternative paradigms for parallel and offload computation exist, but little is known about the human factors impacts of using the different paradigms. With computer science student participants from the University of Nevada, Las Vegas with no previous exposure to Graphics Processing Unit programming, our study compared NVIDIA CUDA C/C++ as a control group and the Thrust library. The designers of Thrust claim their higher level of abstraction enhances programmer productivity. The trial was conducted on 91 participants and was administered through our computerized testing platform. Although the study was narrowly focused on the basic steps of an offloaded computation problem and was not intended to be a comprehensive evaluation of the superiority of one approach or the other, we found evidence that although Thrust was designed for ease of use, the abstractions tended to be confusing to students and in several cases diminished productivity. Specifically, abstractions in Thrust for (i) memory allocation through a C++ Standard Template Library-style vector library call, (ii) memory transfers between the host and Graphics Processing Unit coprocessor through an overloaded assignment operator, and (iii) execution of an offloaded routine through a generic transform library call instead of a CUDA kernel routine all performed either equal to or worse than CUDA.

The alternating direction method of multipliers (ADMM) is a powerful operator splitting technique for solving structured convex optimization problems. Due to its relatively low per-iteration computational cost and ability to exploit sparsity in the problem data, it is particularly suitable for large-scale optimization. However, the method may still take prohibitively long to compute solutions to very large problem instances. Although ADMM is known to be parallelizable, this feature is rarely exploited in real implementations. In this paper we exploit the parallel computing architecture of a graphics processing unit (GPU) to accelerate ADMM. We build our solver on top of OSQP, a state-of-the-art implementation of ADMM for quadratic programming. Our open-source CUDA C implementation has been tested on many large-scale problems and was shown to be up to two orders of magnitude faster than the CPU implementation., Journal of Parallel and Distributed Computing, 144, ISSN:0743-7315, ISSN:1096-0848

The current stage of information technology is characterized by the accumulation of a large amount of data. For processing such arrays, systems often have to use sorting operations, which occupy about 40 % of the total time of working with data. The main ways to increase the speed of data sorting operations are the development of parallel methods and algorithms focused on mass-parallel computing tools with large shared memory (GPUs, which are SIMD processors) and the implementation on a device with using modern database elements such as very large-scale integration (VLSI). Analysis of existing literature sources showed that the existing sorting methods consist of two main operations. The first operation is a pairwise comparison and the second one is a permutation of elements in the case when the order of these values does not meet the sorting conditions. But most of these sorting methods are focused on sequential implementation and are not suitable for parallel computing. However, merge sorting is an exception. Due to the basic operation and algorithm of the method, merge sorting provides the opportunity of the high scaling on parallel systems since the input array could be separated on a huge amount of subsets that are not related to each other and each subset could be calculated in parallel. Considering the parallel characteristics of merge sorting, the best option for software implementation is GPU with program model CUDA. CUDA is software and hardware architecture for parallel computing from Nvidia, which can significantly increase computing performance because it focuses on a multi-core architect. The use of CUDA and appropriate algorithms reduces sorting time by about 100 times compared to using only the CPU. Thus, the paper considers the approach and steps for improving the parallel method of merge sorting and provides the algorithm for implementing the method of merge sorting on the graphics processing unit with CUDA architecture.

Decision trees (DTs) are one of the most popular white-box machine-learning techniques. Traditionally, DTs are induced using a top-down greedy search that may lead to sub-optimal solutions. One of the emerging alternatives is an evolutionary induction inspired by the biological evolution. It searches for the tree structure and tests simultaneously, which results in less complex DTs with at least comparable prediction performance. However, the evolutionary search is computationally expensive, and its effective application to big data mining needs algorithmic and technological progress. In this paper, noting that many trees or their parts reappear during the evolution, we propose a reuse strategy. A fixed number of recently processed individuals (DTs) is stored in a so-called repository. A part of the repository entry (related to fitness calculations) is maintained on a CPU side to limit CPU/GPU memory transactions. The rest of the repository entry (tree structures) is located on a GPU side to speed up searching for similar DTs. As the most time-demanding task of the induction is the DTs’ evaluation, the GPU first searches similar DTs in the repository for reuse. If it fails, the GPU has to evaluate DT from the ground up. Large artificial and real-life datasets and various repository strategies are tested. Results show that the concept of reusing information from previous generations can accelerate the original GPU-based solution further. It is especially visible for large-scale data. To give an idea of the overall acceleration scale, the proposed solution can process even billions of objects in a few hours on a single GPU workstation.

Yere nüfuz eden radar (GPR), bir duvarın arkasına gizlenebilen veya duvarın içine yerleştirilebilen nesnelerin algılanması için kullanılan ultra geniş bantlı bir elektromanyetik sensördür. GPR yöntemi, arayüzde yer alan yüksek hızda bir anten tarafından yatay yönde yeraltına gönderilen elektromanyetik dalgaların, yine alıcı tarafından yatay yönde yansıtılmasının kaydedilmesi prensibi üzerine çalışır. Gömülü yapılar; toplanan veriler, bilgisayar programları ve çeşitli filtreler kullanılarak algılanır. Hava cepleri gibi duvarlar arasında gizlenmiş hedeflerin bulunması arkeologlara yardımcı olur. Bu çalışmada, toprağın dağılımı için Lorentz modeli kullanılmıltır. Sınır koşullarını sönümleyip açık bir alanı simüle etmek için mükemmel uyumlu katman (PML) kullanılmış ve dağıtıcı medyaya uyacak şekilde genişletilmiştir. Sonlu farklı zaman alanı (FDTD) yöntemi, elektromanyetik alanların zaman basamaklamasındaki kısmi diferansiyel denklemleri ayrıştırmak için kullanılır. FDTD hesaplaması çok yavaş çalışmaktadır. Bu sorunu çözmek için grafik işlem biriminde (GPGPU) genel amaçlı programlama yapılabilmektedir. Bu çalışmada GPU'ya CUDA kullanılarak 3-B FDTD yöntemi uygulanmış ve 10 kat hızlanmıştır., Ground-penetrating radar (GPR) is an ultra-wideband electromagnetic sensor used for the detection of objects which may be hidden behind a wall or inserted within the wall. The GPR method works on the principle of recording the reflection of electromagnetic waves sent to the underground at high speed from the interfaces by an antenna located in the horizontal direction, again by the receiver in the horizontal direction. Embedded structures are detected using collected data, computer programs, and various filters. Search for the presence of designated targets hidden between the walls, such as air pockets is help to archaeologists. In this work the Lorentz model was used for the distribution of the soil. The perfectly matched layer (PML) used for absorbing boundary conditions to simulate an open space and its expanded to match dispersive media. The finite-difference time-domain (FDTD) method is used to decompose partial differential equations for time cascading of the electromagnetic fields. FDTD calculation works very slowly. General-purpose programming can be done on the graphics processing unit (GPGPU) to solve this problem. In this work, the 3-D FDTD method was applied to the GPU by using CUDA and it was 10 times faster.

Sediment transport simulations are important in practical engineering. In this study, a graphics processing unit (GPU)-based numerical model coupling hydrodynamical and morphological processes was developed to simulate water flow, sediment transport, and morphological changes. Aiming at accurately predicting the sediment transport and sediment scouring processes, the model resolved the realistic features of sediment transport and used a GPU-based parallel computing technique to the accelerate calculation. This model was created in the framework of a Godunov-type finite volume scheme to solve the shallow water equations (SWEs). The SWEs were discretized into algebraic equations by the finite volume method. The fluxes of mass and momentum were computed by the Harten, Lax, and van Leer Contact (HLLC) approximate Riemann solver, and the friction source terms were calculated by the proposed a splitting point-implicit method. These values were evaluated using a novel 2D edge-based MUSCL scheme. The code was programmed using C++ and CUDA, which could run on GPUs to substantially accelerate the computation. The aim of the work was to develop a GPU-based numerical model to simulate hydrodynamical and morphological processes. The novelty is the application of the GPU techniques in the numerical model, making it possible to simulate the sediment transport and bed evolution in a high-resolution but efficient manner. The model was applied to two cases to evaluate bed evolution and the effects of the morphological changes on the flood patterns with high resolution. This indicated that the GPU-based high-resolution hydro-geomorphological model was capable of reproducing morphological processes. The computational times for this test case on the GPU and CPU were 298.1 and 4531.2 s, respectively, indicating that the GPU could accelerate the computation 15.2 times. Compared with the traditional CPU high-grid resolution, the proposed GPU-based high-resolution numerical model improved the reconstruction speed more than 2.0–12.83 times for different grid resolutions while remaining computationally efficient.

NIST (National Institute of Standards and Technology) statistical test recognized as the most authoritative is widely used in verifying the randomness of binary sequences. The Non-overlapping Template Matching Test as the 7th test of the NIST Test Suit is remarkably time consuming and the slow performance is one of the major hurdles in the testing process. In this paper, we present an efficient bit-parallel matching algorithm and segmented scan-based strategy for execution on Graphics Processing Unit (GPU) using NVIDIA Compute Unified Device Architecture (CUDA). Experimental results show the significant performance improvement of the parallelized Non-overlapping Template Matching Test, the running speed is 483 times faster than the original NIST implementation without attenuating the test result accuracy.

In this paper, we propose a hybrid parallel programming approach for a numerical solution of a two-dimensional acoustic wave equation using an implicit difference scheme for a single computer. The calculations are carried out in an implicit finite difference scheme. First, we transform the differential equation into an implicit finite-difference equation and then using the alternating direction implicit (ADI) method, we split the equation into two sub-equations. Using the cyclic reduction algorithm, we calculate an approximate solution. Finally, we change this algorithm to parallelize on graphics processing unit (GPU), GPU + Open Multi-Processing (OpenMP), and Hybrid (GPU + OpenMP + message passing interface (MPI)) computing platforms. The special focus is on improving the performance of the parallel algorithms to calculate the acceleration based on the execution time. We show that the code that runs on the hybrid approach gives the expected results by comparing our results to those obtained by running the same simulation on a classical processor core, Compute Unified Device Architecture (CUDA), and CUDA + OpenMP implementations.

Correcting for eddy currents, movement-induced distortion and gradient inhomogeneities is imperative when processing diffusion MRI (dMRI) data, but is highly computing resource-intensive. Recently, Compute Unified Device Architecture (CUDA) was implemented for the widely-used eddy-correction software, 'eddy', which reduces processing time and allows more comprehensive correction. We investigated processing speed, performance and compatibility of CUDA-enabled eddy-current correction processing compared to commonly-used non-CUDA implementations. Four representative dMRI datasets from the Human Connectome Project, Alzheimer's Disease Neuroimaging Initiative and Chronic Diseases Connectome Project were processed on high-specification and regular workstations through three different configurations of 'eddy'. Processing times and graphics processing unit (GPU) resources used were monitored and compared. Using CUDA reduced the 'eddy' processing time by a factor of up to five. The CUDA slice-to-volume correction method was also faster than non-CUDA eddy except when datasets were large. We make a series of recommendations for eddy configuration and hardware. We suggest that users of eddy-correction software for dMRI processing utilise CUDA and take advantage of the slice-to-volume correction option. We recommend that users run eddy on computers with at least 32GB motherboard random access memory (RAM), and a graphics card with at least 4.5GB RAM and 3750 cores to optimise processing time.

Matrix-free solvers for finite element method (FEM) avoid assembly of elemental matrices and replace sparse matrix-vector multiplication required in iterative solution method by an element level dense matrix-vector product. In this paper, a novel matrix-free strategy for FEM is proposed which computes element level matrix-vector product by using only the symmetric part of the elemental matrices. The proposed strategy is developed to take advantage of the massive parallelism of Graphics Processing Unit (GPU). A unique data structure is also introduced which ensures localized and coalesced memory access suitable for a GPU while storing only the symmetric part of the elemental matrices. In addition, the proposed strategy emphasizes the efficient use of register cache, uniform workload distribution, reducing thread synchronization, and maintaining sufficient granularity to make the best use of GPU resources. The performance of the proposed strategy is evaluated by solving elasticity and heat conduction problems using 4-noded quadrilateral element with two degrees of freedom (DOFs) and one DOF per node, respectively. The performance is compared with the matrix-free solver strategies on GPU from the literature. It is found that a maximum speedup of 4.9 $$\times $$ is obtained for the elasticity problem and a maximum of 3.2 $$\times $$ speedup for the heat conduction problem. Further, the proposed strategy takes the least amount of GPU memory as compared to the existing strategies.

Applications that exploit the architectural details of high-performance computing (HPC) systems have become increasingly invaluable in academia and industry over the past two decades. The most important hardware development of the last decade in HPC has been the general purpose graphics processing unit (GPGPU), a class of massively parallel devices that now contributes the majority of computational power in the top 500 supercomputers. As these systems grow, small costs such as latency—due to the fixed cost of memory accesses and communication—accumulate in a large simulation and become a significant barrier to performance. The swept time-space decomposition rule is a communication-avoiding technique for time-stepping stencil update formulas that attempts to reduce latency costs. This work extends the swept rule by targeting heterogeneous, CPU/GPU architectures representing current and future HPC systems. We compare our approach to a naive decomposition scheme with two test equations using an MPI+CUDA pattern on 40 processes over two nodes containing one GPU. The swept rule produces a factor of 1.9 to 23 speedup for the heat equation and a factor of 1.1 to 2.0 speedup for the Euler equations, using the same processors and work distribution, and with the best possible configurations. These results show the potential effectiveness of the swept rule for different equations and numerical schemes on massively parallel compute systems that incur substantial latency costs.

In this study, we compared the modified bounce-back (BB) method and immersed boundary (IB) method for the treatments of no-slip boundary condition based on the Lattice Boltzmann Method (LBM) for turbulent flow. The benchmark case of flow past a square cylinder confined in a rectangular duct has been simulated with two schemes at Re d = 3000. The turbulent flow was modeled using Large Eddy Simulation (LES). The conventional Smagorinsky subgrid scheme was used to resolve the small-scale motions. The proposed algorithm is parallelized to run on NVIDIA Tesla P100 Graphics Processing Unit (GPU) using Compute Unified Device Architecture (CUDA) programming language. The results obtained from the bounce-back and immersed boundary method has been validated with the experimental and LES data reported in the literature for different turbulent statistics including time-averaged velocities, root-mean-square velocity fluctuations, and Reynolds shear stress. Later, the comparison between the two approaches discussed in terms of accurate predictions for the drag coefficient. The computational efficiency on GPU for both methods has also been reported. [copyright information to be updated in production process]

In order to improve the cost-effectiveness ratio, the next-generation vehicle needs to meet the requirements of reuse, while adopting a lighter structural weight, so it is necessary to realize the strength calculation and condition monitoring of key components in the digital twin. Most of the current monitoring methods are based on the characteristics of various data acquisition systems, but they need the support of a large number of flight data. The disadvantages of the above strategy can be avoided by reducing the structure of aircraft components to a finite element model and quickly checking the key components in the health management system. In order to solve the problem of fast calculation of the finite element model of the key components of the aircraft, a parallel algorithm and framework of large-scale sparse matrix preprocessing conjugate gradient method based on CUDA(Compute Unified Device Architecture) technology is proposed in the multi GPU(Graphics Processing Unit) workstation cluster environment. Once the sparse matrix is too large to be processed in a single workstation, this paper discusses how to realize the optimized data segmentation in the distributed multi-GPU computing environment. For the problem of iterative solution of matrix preprocessing, two preprocessing strategies of matrix bandwidth reduction parallelization and incomplete Cholesky decomposition are proposed, and asynchronous task concurrency and load balancing strategies are designed on the architecture. The calculation of some examples in the standard sparse matrix database shows that the algorithm and architecture proposed in this paper have the ability to solve large-scale sparse matrix quickly and efficiently, and can complete the fast strength verification of vehicle components.

This paper presents new parallel strategies for preprocessing and solving the issue of Boolean Satisfaction (SAT) on Heterogeneous systems of multicore and many-core CPU and Graphics Processing Unit (GPU) using Open Multi-Processor (OpenMP) and NVIDIA - CUDA. We propose exceptionally proficient and parallel techniques for SAT simplifications using the variable elimination method based on the Davis-Putnam-Logemann-Loveland (DPLL) slitting rule algorithm performed with a shared-memory model on a multicore CPU platform, where the clause elimination subsumption and the pure-literal removal techniques are completely performed on the CUDA framework. We demonstrate how efficient an evolutionary SAT solver is by using the suggested heterogeneous pre-processing, leading to important acceleration improvements in the solution's quality enhancement. The penalization of the transformative SAT solver is executed with Ant Colony Optimization (ACO) scheme utilizing CUDA. (Compute Unified Device Architecture) We perform thorough benchmarks to test the performance of our preprocessor and solver implementations against various random SAT formulas. The promoted H-SAT pre-processor scheme has gotten a speed-up of a factor 15x over the sequential implementation with statistical reductions on the original CNF which becomes up to 49% and 43% in case of literals and clauses numbers exclusively, where the H-SAT gain strength the solvability of the ACO solver by 100% in some cases.

The SKA (Square Kilometre Array) radio telescope will become the most sensitive telescope by correlating a large number of antenna nodes to form a giant antenna array. The data generated from such a large number of antenna nodes will pose a huge storage problem and require real-time data processing to make the best use of data, and the SKA Scientific Data Processing becomes the bottleneck of the whole processing flow. However, the existing high-performance CPU- and GPU (Graphics Processing Unit)-based solutions cannot satisfy the performance requirements and power budget requirements well [1] . Due to the consideration of the high energy efficiency of hardware accelerators and the flexibility and cost of prototype design, in this paper, we explore the FPGA(Field Programmable Gate Array)-based prototype of one of the most computationally demanding procedures in SKA scientific data processing: degridding. Through the analysis of algorithm behavior and bottlenecks, we design and optimize the memory architecture and computing logic of an FPGA-based prototype. Besides, with the consideration of the relations between the required data of processing multiple spectral channels, we reuse the shared data in processing neighboring spectral channels, and the performance further improves. The functionality and performance of our design have been verified on the target FPGA board, and the software-based benchmarks were also measured on comparable CPU and GPU platforms, indicating that the FPGA-based prototype achieves 2.74 times and 2.03 times speedup, 7.64 times and 7.42 times energy efficiency than the MPI(Message Passing Interface)-based CPU benchmark and the CUDA (Compute Unified Device Architecture)-based GPU benchmark, respectively.

Objective: This study intends to develop an accurate, real-time tumor tracking algorithm for the automated radiation therapy for cancer treatment using Graphics Processing Unit (GPU) computing. Although a previous moving mesh based tumor tracking approach has been shown to be successful in delineating the tumor regions from a sequence of magnetic resonance image, the algorithm is computationally intensive and its computation time on standard Central Processing Unit (CPU) processors is too slow to be used clinically especially for automated radiation therapy system. Method: A re-implementation of the algorithm on a low-cost parallel GPU-based computing platform is utilized to accelerate this computation at a speed that is amicable to clinical usages. Several components in the registration algorithm such as the computation of similarity metric are inherently parallel which fits well with the GPU parallel processing capabilities. Solving a partial differential equation numerically to generate the mesh deformation is one of the computationally intensive components which has been accelerated by utilizing a much faster shared memory on the GPU. Results: Implemented on an NVIDIA Tesla K40c GPU, the proposed approach yielded a computational acceleration improvement of over 5 times its implementation on a CPU. The proposed approach yielded an average Dice score of 0.87 evaluated over 600 images acquired from six patients. Conclusion: This study demonstrated that the GPU computing approach can be used to accelerate tumor tracking for automated radiation therapy for mobile lung tumors. Clinical Impact: Accurately tracking mobile tumor boundaries in real-time is important to automate radiation therapy and the proposed study offers an excellent option for fast tumor region tracking for cancer treatment., We present the estimation of 3D left ventricular (LV) motion using the fusion of different 2D cine magnetic resonance (CMR) sequences acquired during routine imaging sessions. We show that fusing the information from short and long-axis views of CMR improves the accuracy of cardiac tissue motion estimation.

The dark channel prior (DCP)-based single image removal algorithm achieved excellent performance. However, due to the high complexity of the algorithm, it is difficult to satisfy the demands of real-time processing. In this article, we present a Graphics Processing Unit (GPU) accelerated parallel computing method for the real-time processing of high-definition video haze removal. First, based on the memory access pattern, we propose a simple but effective filter method called transposed filter combined with the fast local minimum filter algorithm and integral image algorithm. The proposed method successfully accelerates the parallel minimum filter algorithm and the parallel mean filter algorithm. Meanwhile, we adopt the inter-frame atmospheric light constraint to suppress the flicker noise in the video haze removal and simplify the estimation of atmospheric light. Experimental results show that our implementation can process the 1080p video sequence with 167 frames per second. Compared with single thread Central Processing Units (CPU) implementation, the speedup is up to 226&times, with asynchronous stream processing and qualified for the real-time high definition video haze removal.

The acceleration of parallel high-throughput first-principle calculations in the context of 3D (three dimensional) periodic boundary conditions for low-dimensional systems, and particularly 2D materials, is an important issue for new material design. Where the scalability rapidly deflated due to the use of large void unit cells along with a significant number of atoms, which should mimic layered structures in the vacuum space. In this report, we explored the scalability and performance of the Quantum ESPRESSO package in the hybrid central processing unit - graphics processing unit (CPU-GPU) environment. The study carried out in the comparison to CPU-based systems for simulations of 2D magnets where significant improvement of computational speed was achieved based on the IBM ESSL SMP CUDA library. As an example of physics-related results, we have computed and discussed the ionicity-covalency and related ferro- (FM) and antiferro-magnetic (AFM) exchange competitions computed for some CrX3 compounds. Further, it has been demonstrated how this exchange interplay leads to high-order effects for the magnetism of the 1L-RuCl3 compound.

Several methods are proposed to accelerate the calculation of RCS (radar cross section), and integrate shooting and bouncing rays-physical optics (SBR-PO) methods into graphics processing unit (GPU). The SBR-PO method is used to solve the multiple reflection behavior of electromagnetic waves on the target model, and the scattered field is calculated by PO integral. The ray tracing engine OptiX and the Unified Computing Architecture (CUDA) are used to reduce the calculation time of the SBR-PO method and improve the calculation efficiency of RCS. Compare the results calculated by the SBR-PO method with the results calculated by the commercial software FEKO. The results fully demonstrate the feasibility and efficiency of integrating the SBR-PO method into OptiX and GPU.

Floods are the most frequent disasters, causing widespread damage resulting in loss of lives and properties. In this paper, we present Sinotech Engineering Consultants Hydrodynamic (SEC-HY21) simulation modeling to predicted floods and estimate their damage efficiently. However, SEC-HY21 still suffers from the slow simulation rate due to its data dependency structure which does not make the numerical model of SEC-HY21 parallelizable. In this research, a near real-time flood simulation has been reached by Compute Unified Device Architecture (CUDA) parallel implementation on NVIDIA Graphics Processing Unit (GPU) to accelerate the performance of the slowest module in the SEC-HY21 package, namely iFlux. The experimental results have shown that the CUDA-based parallel implementation has made the SEC-HY21 simulation modeling ∼ 14× faster than before.

The computing power of the Graphics Processing Unit (GPU) has received great attention in recent years, as 140 supercomputers with NVIDIA GPUs were ranked in the TOP500 for November 2020 [1]. However, CUDA, which is widely used in GPU programming, needs to be written at a low level and often requires the specialized knowledge of the GPU memory hierarchy and execution models. In this study, we used OpenACC [2], which semi-automatically generates kernel code by inserting directives into a program to speed up the application. The target application was benchmark program based on the plasma turbulence analysis code, gyrokinetic Vlasov code (GKV). With our implementation of OpenACC, kernel2, kernel3, and kernel4 of the benchmark were 31.43, 7.08, and 10.74 times faster, respectively, compared to CPU sequential execution. Thus, we succeeded in increasing the applications’ speed. In the future, we will port the rest of the code to the GPU environment to run the entire GKV on GPUs.