Search

Because of the open-collaborative of online encyclopedias, a large number of knowledge triples are improperly classified in online encyclopedia systems, and it is necessary to denoise and refine the open-domain encyclopedia Knowledge Bases (KBs) to improve the quality and precision. However, the lack and inaccuracy of triple semantic features lead to a poor refinement effect. In addition, considering large-scale encyclopedia KBs, the processing of massive knowledge will lead to too much computing time and poor scalability of the algorithm. To solve the problems of knowledge denoising in the Chinese encyclopedia system, first, based on data field theory, this paper proposes a new Cartesian product mapping-based method (TripleES) to calculate the semantic similarity of entity triples, based on which a method for quantifying the quality of entry tags is proposed. Second, to further improve the denoising effect on KBs, this paper proposes a new method (TriplePV) to compute the potential value of triple based on multi-feature fusion strategy to calculate the semantic distance between the "out-of-vocabulary" entry tags and embeds it into the potential function. Third, to ensure our algorithms have good scalability, the proposed denoising algorithms are implemented and optimized in parallel based on the Spark cluster-computing framework. Specifically, Spark-based TripleES (ES_Spark) and Spark-based TriplePV (PV_Spark) algorithms are proposed to calculate the semantic similarity and potential value of triples respectively. Finally, a comprehensive comparative analysis is performed on the denoising effect and time efficiency with the state-of-the-art distributed Chinese encyclopedia knowledge denoising algorithm. The experimental results on real-world datasets show that the parallel denoising algorithm proposed in this paper can improve the efficiency of knowledge denoising and the accuracy of KBs, which outperforms the state-of-the-art methods. [ABSTRACT FROM AUTHOR]

In order to explore potential value of explosively growing data in thermal power unit, this paper proposes a big data mining method based on Hadoop-based Spark cluster-computing framework and algorithms. Firstly, positive and negative balance methods are used to accurately obtain actual net coal consumption, and maximum information coefficient method is used to select all parameters related to optimization objectives. Then, Spark-based Mini-Batch K-means algorithm and Elbow method are constructed to divide whole operating modes. After that, all data are discretized and mapped to corresponding intervals by using Spark-based Elbow method and Mini-Batch K-means algorithm. Finally, Spark-based parallel FP-growth algorithm is used to deeply mine the potential relationships and laws. To verify the proposed method, a 350-MW thermal power unit is taken as a study case. The important conclusions are as follows: (1) the proposed Spark-based Mini-Batch K-means algorithm reduces the calculation time by 57.11% compared with Mini-Batch K-means algorithm, and 85.61% calculation time compared with K-means algorithm. The proposed Spark-based FP-growth algorithm reduces computational time by 32.8% compared with FP-growth algorithm. (2) Strong association rules of whole operating modes are mined, and operating optimization guidance schemes for important parameters are obtained. Take operating mode 1 as an example: if the optimal result can be reasonably applied, it can save 2.942 g coal per kilowatt hour. (3) Besides, we have found out some other potential relationships among parameters, which have important reference value for on-site operators to analyze economy of the thermal power unit. [ABSTRACT FROM AUTHOR]

Swarm Intelligence (SI) algorithms are frequently applied to tackle complex optimization problems. SI is especially used when good solutions are requested for NP hard problems within a reasonable response time. And when such problems possess a very high dimensionality, a dynamic nature, or present intrinsic complex intertwined independent variables, computational costs for SI algorithms may still be too high. Therefore, new approaches and hardware support are needed to speed up processing. Nowadays, with the popularization of GPU and multi-core processing, parallel versions of SI algorithms can provide the required performance on those though problems. This paper aims to describe the state of the art of such approaches, to summarize the key points addressed, and also to identify the research gaps that could be addressed better. The scope of this review considers recent papers mainly focusing on parallel implementations of the most frequently used SI algorithms. The use of nested parallelism is of particular interest, since one level of parallelism is often not sufficient to exploit the computational power of contemporary parallel hardware. The sources were main scientific databases and filtered accordingly to the set requirements of this literature review. [ABSTRACT FROM AUTHOR]

Triangle enumeration is a foundation brick for solving harder graph problems related to social networks, the Internet and transportation, to name a few applications. This problem is well studied in the theory literature, but remains an open problem with big data. In this paper, we defend the idea of solving triangle enumeration with SQL queries evaluating the steps of a new adaptive algorithm with linear speedup. Such SQL approach provides scalability beyond RAM limits, automatic parallel processing and more importantly: linear speedup as more machines are added. We present theory results and experimental validation showing our solution works well with large graphs analyzed on a parallel cluster with many machines, producing a balanced workload even with highly skewed degree vertices. We consider two types of distributed systems: (1) a parallel DBMS that evaluates SQL queries, and (2) a parallel HPC cluster calling the MPI library (called via Python). Extensive benchmark experiments with large graphs show our SQL solution offers many advantages over MPI and competing graph analytic systems. [ABSTRACT FROM AUTHOR]

360-degree videos have become increasingly popular with the application of virtual reality (VR) technology. To encode such kind of videos with ultra-high resolution, an efficient and real-time video encoder becomes a key requirement. The Versatile Video Coding (VVC) standard has good coding performance. However, it has pretty high computational complexity which increasing the application cost of 360-degree videos. Among them, the decision of the quadtree with nested multi-type tree (QTMT) partitioning structure is one of the time-consuming procedures. In this paper, based on the characteristics of 360-degree video with Equirectangular projection (ERP) format, the empirical variogram combined with Mahalanobis distance is introduced to measure the difference between the horizontal and vertical directions of the CU, and a fast partition algorithm is proposed. The experimental results show that the algorithm saves 32.13% of the coding time with only an increase of 0.66% in BDBR. [ABSTRACT FROM AUTHOR]

Quicksort is an important algorithm that uses the divide and conquer concept, and it can be run to solve any problem. The performance of the algorithm can be improved by implementing this algorithm in parallel. In this paper, the parallel sorting algorithm named the Multi-Deque Partition Dual-Deque Merge Sorting algorithm (MPDMSort) is proposed and run on a shared memory system. This algorithm contains the Multi-Deque Partitioning phase, which is a block-based parallel partitioning algorithm, and the Dual-Deque Merging phase, which is a merging algorithm without compare-and-swap operations and sorts the small data with the sorting function of the standard template library. The OpenMP library, which is an application programming interface used to develop the parallel implementation of this algorithm, is implemented in MPDMSort. Two computers (one with an Intel Xeon Gold 6142 CPU and the other with an Intel Core i7-11700 CPU) running Ubuntu Linux are used in this experiment. The results show that MPDMSort is faster than parallel balanced quicksort and multiway merge sort on the large random distribution data. A speedup of 13.81 × and speedup per thread of 0.86 can be obtained. Thus, developers can use these parallel partitioning and merging algorithms to improve the performance of related algorithms. [ABSTRACT FROM AUTHOR]

The National Center for Atmospheric Research released a global atmosphere model named Community Atmosphere Model version 5.0 (CAM5), which aimed to provide a global climate simulation for meteorological research. Among them, the cloud microphysics scheme is extremely time-consuming, so developing efficient parallel algorithms faces large-scale and chronic simulation challenges. Due to the wide application of GPU in the fields of science and engineering and the NVIDIA's mature and stable CUDA platform, we ported the code to GPU to accelerate computing. In this paper, by analyzing the parallelism of CAM5 cloud microphysical schemes (CAM5 CMS) in different dimensions, corresponding GPU-based one-dimensional (1D) and two-dimensional (2D) parallel acceleration algorithms are proposed. Among them, the 2D parallel algorithm exploits finer-grained parallelism. In addition, we present a data transfer optimization method between the CPU and GPU to further improve the overall performance. Finally, GPU version of the CAM5 CMS (GPU-CMS) was implemented. The GPU-CMS can obtain a speedup of 141.69 × on a single NVIDIA A100 GPU with I/O transfer. In the case without I/O transfer, compared to the baseline performance on a single Intel Xeon E5-2680 CPU core, the 2D acceleration algorithm obtained a speedup of 48.75 × , 280.11 × , and 507.18 × on a single NVIDIA K20, P100, and A100 GPU, respectively. [ABSTRACT FROM AUTHOR]

This paper proposes a parallel computing analysis model HPM and analyzes the parallel architecture of CPU–GPU based on this model. On this basis, we study the parallel optimization of the ray-tracing algorithm on the CPU–GPU parallel architecture and give full play to the parallelism between nodes, the parallelism of the multi-core CPU inside the node, and the parallelism of the GPU, which improve the calculation speed of the ray-tracing algorithm. This paper uses the space division technology to divide the ground data, constructs the KD-tree organization structure, and improves the construction method of KD-tree to reduce the time complexity of the algorithm. The ground data is evenly distributed to each computing node, and the computing nodes use a combination of CPU–GPU for parallel optimization. This method dramatically improves the drawing speed while ensuring the image quality and provides an effective means for quickly generating photorealistic images. [ABSTRACT FROM AUTHOR]

Graph pattern matching is widely used in real-world applications, such as social network analysis. Since the traditional subgraph isomorphism is NP-complete and often too restrictive to catch sensible matches, relaxed graph pattern matching models are used. However, existing algorithms suffer from limited linear scalability and restricted degrees of parallelism. In this paper, we propose fast parallel algorithms, GPGS and GPDS, for graph simulation and dual simulation, respectively. They make most use of the GPU performance by adopting the edge-centric processing model. We perform parallel computations on the data graph edges to evaluate the matching constraints for each vertex allowing for fast and scalable algorithms. To the best of our knowledge, we present the first GPU-based algorithms for graph simulation and dual simulation. Extensive experiments on synthetic and real-world data graphs demonstrate that our algorithms significantly outperform existing methods, achieving up to 74.8 × acceleration for GPGS and up to 114.2 × acceleration for GPDS. [ABSTRACT FROM AUTHOR]

Sparse general matrix–matrix multiplication (SpGEMM) is a crucial and complex computational task in many practical applications. Improving the performance of SpGEMM on SIMT processors like modern GPUs is challenging due to the unpredictable sparsity of sparse matrices. Although existing GPU solutions have made progress in improving performance through advanced algorithm design, they ignore some optimizations related to specific processor architectures. This can result in a partially inefficient implementation of their algorithms. This paper focuses on optimizing four inefficient parts of the NSparse algorithm on DCU (a GPU-like accelerator). The optimizations include: 1) setting parameters to improve the load balance of the second matrix by extracting maximum row information at runtime; 2) reducing overhead of binning operations by making full use of registers and shared memory effectively; 3) improving numerical SpGEMM performance by adjusting its calculation mode; and 4) enhancing global load balance through finer-grained grouping and kernel configurations. Experiment results demonstrate that when compared to five state-of-the-art SpGEMM algorithms (bhSparse, KokkosKernels, NSparse, rocSparse, and spECK), our optimized method achieves an average of 7.99x (up to 18.2x), 8.01x (up to 20.83x), 2.37x (up to 6.16x), 1.82x (up to 4.20x), and 1.63x (up to 5.01x) speedups on 29 sparse matrices with different sparse structures, respectively. [ABSTRACT FROM AUTHOR]

Application with a set of dependent distributed tasks is generally regarded as a direct acyclic graph or an out-tree. Tree-shaped task graphs are widely applied in a variety of computational domains, including electronic structure computations and sparse matrix factorization. Efficient algorithms for tree-shaped task partition and allocation can dominate the performance of heterogeneous computing systems, as most relevant publications have pointed out. This paper presents efficient algorithms for partitioning and allocating tree-shaped tasks on heterogeneous multiprocessor systems with limited memory to improve task-parallel computing. The proposed main algorithm consists of two stages: partition and allocation. During partition, an algorithm is provided for partitioning a task tree into multiple subtrees. It iteratively partitions the subtrees on the critical path of the quotient tree. During allocation, two algorithms are proposed for task allocation to minimize the task tree's execution time. One is to preferentially allocate the largest subtree of the whole tree, and the other is to preferentially allocate the subtree located on the quotient tree's critical path. Experimental results show that the proposed algorithms significantly improve the latest works in terms of average makespan, both on randomly generated trees and on a real-world dataset. On a real-world dataset, the average makespan of existing work is approximately 6.28 × 10 8 . However, it is approximately 2.13 × 10 8 for our proposed algorithm. This results in a reduction of 64.33%. On randomly generated trees, the average makespan of existing work is approximately 8973. However, it is approximately 4040 for our proposed algorithm. This results in a reduction of 54.96%. [ABSTRACT FROM AUTHOR]

In the big data era, traditional data mining technology cannot meet the requirements of massive data processing with the background of intelligent manufacturing. Aiming at insufficient computing power and low efficiency in mining process, this paper proposes a improved K-means clustering algorithm based on the concept of distributed clustering in cloud computing environment. The improved algorithm (T.K-means) is combined with MapReduce computing framework of Hadoop platform to realize parallel computing, so as to perform processing tasks of massive data. In order to verify the practical performance of T.K-means algorithm, taking machining data of milling Ti-6Al-4V alloy as the mining object. The mapping relationship among cutting parameters, surface roughness, and material removal rate is mined, and the optimized value for cutting parameters is obtained. The results show that T.K-means algorithm can be used to mine the optimal cutting parameters, so that the best surface roughness can be obtained in milling Ti-6Al-4V titanium alloy. [ABSTRACT FROM AUTHOR]

Nowadays, establishing security in data transmission is essential, and it is achieved by cryptography. Encryption of still or video images in specific applications such as Internet of Things, medical and satellite imaging, in applications requiring high-speed encryption, or even in applications where a personal computer is unavailable or cannot be used needs special hardware. In this paper, an image encryption algorithm based on chaos theory named Parallel Chaotic Checksum-based Image Encryption or PCCIE algorithm is proposed that has been able to provide a fast, efficient and secure algorithm with a hardware perspective on the design and parallel system structure. Using high-level synthesis, PCCIE is implemented on a Field Programmable Gate Array (FPGA). The proposed algorithm using small and independent local image buffers solved FPGA internal memory limitation for encryption of large images. Ultimately, a Hexa-core crypto-processor with single-precision floating-point and fixed-point precision has been designed, capable of encrypting 256 × 256 and Full HD images in 2.13 and 59.52 milliseconds, respectively, at 469 and 16 frames per second. [ABSTRACT FROM AUTHOR]

The sparse triangular solver (SpTRSV) is mostly used for scientific and engineering applications. The structured-grid triangular solver of regular dependencies (STRSV) is a special kind of SpTRSV. Some general SpTRSVs that disregards the regularity of the matrix are unsuitable for solving this problem. This paper proposes an efficient parallel algorithm for STRSV on the SW26010 (a kind of China independently designed many-core processors), namely swStructTRSV. The algorithm makes full use of the fine-grained and low latency communication characteristics of the SW26010 to reduce the waiting time for synchronization, maximizes the regularity of access to improve memory access bandwidth, and achieves overlap between memory access and computation simultaneously. Moreover, the idea of the algorithm can be extended to incomplete LU factorization (ILU factorization) because of consistent dependencies. The experimental results on a core group(8 * 8 network composed of 64 cores) of SW26010 show that swStructTRSV can achieve an average speedup of over 30 in the sequential version. swStructTRSV on SW26010 achieves solving speedups of 2.2 and 6.3 over the fast STRSV (fSpTRSV) previously implemented on SW26010 and MKL on Intel Xeon Gold 6132, respectively. swStructTRSV significantly outperforms cuSparse on NVIDIA TITAN RTX in terms of overall execution time. [ABSTRACT FROM AUTHOR]

The results of a parallel implementation of a randomized vector algorithm for solving systems of linear equations are presented in the paper. The solution is represented in the form of a Neumann series. The stochastic method computes this series by sampling only random columns, avoiding multiplication of matrix by matrix and matrix by vector. We consider the case when the matrix is too large to fit in random-access memory (RAM). We use two approaches to solve this problem. In the first approach, the matrix is divided into parts that are distributed among MPI processes and stored in the available RAM of the cluster nodes. In the second approach, the entire matrix is stored on each node's hard drive, loaded into RAM, and processed in parts. Independent Monte Carlo experiments for random column indices are distributed among MPI processes or OpenMP threads for both approaches to matrix storage. The efficiency of parallel implementations is analyzed. Results are given for a system governed by dense matrices of size 10 4 and 10 5 . [ABSTRACT FROM AUTHOR]

Fault diagnosis of interconnection networks is vital to ensuring the reliability and maintenance of multiprocessor systems. Based on graph theory, diagnostic algorithms for solving the problem of fault diagnosis in interconnection networks have been widely studied. As the number of processors in multiprocessor systems has increased in recent years, fault diagnosis algorithms based on graph theory cannot meet the current diagnosis requirements of some interconnection networks, such as t-diagnosable systems. In this paper, we use the evolution diagnosis approach to study fault diagnosis in t-diagnosable systems under the PMC model. First, for a t-diagnosable system G with a syndrome σ , we use a simple centralized algorithm to generate its simplified diagnosis graph G f , which contains all the faulty nodes in G. Based on the graph, we prove that the faulty node set in G is the minimum cover set of G f . Next, we prove that the problem of computing the minimum cover set for G f is equivalent to the problem of computing the optimal solution of a zero-one integer program. Using this result, we propose a novel genetic algorithm to solve the problem of the zero-one integer program. The simulation results show that the diagnostic accuracy of our proposed algorithm is equal to or greater than 96% and that the proposed algorithm outperforms its competitors in terms of diagnostic accuracy, number of iterations and running time. [ABSTRACT FROM AUTHOR]

This paper deals with the facility layout problem (FLP) in manufacturing systems, the main purpose of the paper is to solve the static facility layout problem as a quadratic assignment problem QAP using approximated approaches. We present Bio-geography Based Optimization meta-heuristic BBO and a parallel hybrid BBO with tabu search PBBO-TS algorithm to solve the facility layout problem. Parallel computing is implemented to diversify the search, to increase the performance of BBO algorithm, and to accelerate the speed of the running time. The proposed approaches were tested on QAPLIB benchmark instances and compared with some of the best performing sequential and parallel algorithms in the literature. The comparisons prove that the proposed algorithm PBBO-TS produce satisfactory results. In addition, the performance of the parallel implementation of the program is studied in terms of speedup and efficiency; the obtained results show that the parallel implemented system is scalable. [ABSTRACT FROM AUTHOR]

In this paper, a novel parallel algorithm is proposed to solve the problems of heavy computation and long simulation time in the field of compressible flows. In this algorithm, a third-order upwind scheme and a fourth-order central difference scheme are employed, with a third-order Runge-Kutta method for time stepping. Considering the powerful floating-point computing ability of the Graphics Processing Unit (GPU), this paper establishes the algorithm on the basis of GPU. Moreover, the direct numerical simulation method is adopted in this algorithm to improve the solution accuracy of the simulation results. To further enhance the efficiency of the algorithm, several optimization strategies are explored in the design of the algorithm as well. Both accuracy and feasibility of the algorithm are verified by a classical two-dimensional example. Compared with solving this example on the Central Processing Unit platform, the experimental results demonstrate that the maximum speedup ratio achieved by our approach is 18.03 times. [ABSTRACT FROM AUTHOR]

The differential characteristics with high probability are critical for differential cryptanalysis. The process of searching such differential characteristics, especially the best one, is time-consuming. We believe that the modern hybrid computing systems can be used to accelerate the search process. However, to the best of our knowledge, the existing solutions are not designed for heterogeneous architectures. In this paper, we propose a parallel search algorithm for the best differential characteristic. Our method can be applied to any substitution–permutation network (SPN) block ciphers after making minor modifications. We implemented the proposed parallel search algorithm for PRESENT block cipher and also a sequential version, which based on the classic Matsui's method, for comparison. The experimental result shows that the parallel algorithm using both CPU and GPU can achieve at least 4.4x and up to 18x speed-up compared to the sequential version. [ABSTRACT FROM AUTHOR]

We consider a class of saddle point problems frequently arising in the areas of image processing and machine learning. In this paper, we propose a simple primal-dual algorithm, which embeds a general proximal term induced with a positive definite matrix into one subproblem. It is remarkable that our algorithm enjoys larger stepsizes than many existing state-of-the-art primal-dual-like algorithms due to our relaxed convergence-guaranteeing condition. Moreover, our algorithm includes the well-known primal-dual hybrid gradient method as its special case, while it is also of possible benefit to deriving partially linearized primal-dual algorithms. Finally, we show that our algorithm is able to deal with multi-block separable saddle point problems. In particular, an application to a multi-block separable minimization problem with linear constraints yields a parallel algorithm. Some computational results sufficiently support the promising improvement brought by our relaxed requirement. [ABSTRACT FROM AUTHOR]

Through decoupling the data plane from the control planes, the Software Defined Network (SDN) improves the network flexibility and has gained much attention from both academia and industry. In order to apply to Wide Area Network (WAN), the logically centralized and physically distributed multi-controller network architecture is proposed. In this situation, how many controllers are required and where they should be placed is a urgent problem to be solved, which is called the Controller Placement Problem (CPP). This paper discusses the joint optimization of latency and required number of controllers considering revenue cost and network architecture. We propose a Density-based Controller Placement Algorithm (DCPA), which can obtain the optimal number of controllers and then divides the entire network into multiple sub-networks adaptively. In each sub-network, the controllers are deployed with the purpose of minimizing the average propagation latency and the worst-case propagation latency between controllers and switches at the same time. We conduct experiments on 8 real network topologies from the OS3E and Internet Topology Zoo to evaluate the performance of algorithm. The results verify that DCPA can always find out the optimal solution with a low time consumption to reduce latency for different network scales, which reduces latency by up to 46, 11 and 7 when compared with Density-Based Controller Placement (DBCP), Pareto-based Optimal COntroller placement (POCO) and Clustering-based Network Partition Algorithm (CNPA), respectively, and reduce the load of controllers by up to 38, 20 and 13 when compared with DBCP, POCO and CNPA, respectively. As a result, our proposed DCPA can decrease the controller cost, propagation latency and controller load simultaneously when solving CPP. [ABSTRACT FROM AUTHOR]

Circuits in a graph are interesting structures and identifying them is of an important relevance for many applications. However, enumerating circuits is known to be a difficult problem, since their number can grow exponentially. In this paper, we propose fast parallel approaches for enumerating elementary circuits of directed graphs based on graphics processing unit (GPU). Our algorithms are based on a massive exploration of the graph in a breadth-first search strategy. Algorithm V-FEC explores the graph starting from different vertices simultaneously. To further reduce the search space, we present T-FEC, another algorithm that uses triplets as an initial set to start exploring. To the best of our knowledge, those are the first parallel GPU-based algorithms for finding all circuits of a given graph. In addition, they find circuits of a given length and circuits with a specific vertex or edge. The evaluation results show that the proposed approaches achieve up to 190x speed-up over Johnson's algorithm, one of the most efficient sequential algorithms for finding circuits. [ABSTRACT FROM AUTHOR]

The sparse precision matrix plays an essential role in the Gaussian graphical model since a zero off-diagonal element indicates conditional independence of the corresponding two variables given others. In the Gaussian graphical model, many methods have been proposed, and their theoretical properties are given as well. Among these, the sparse precision matrix estimation via scaled lasso (SPMESL) has an attractive feature in which the penalty level is automatically set to achieve the optimal convergence rate under the sparsity and invertibility conditions. Conversely, other methods need to be used in searching for the optimal tuning parameter. Despite such an advantage, the SPMESL has not been widely used due to its expensive computational cost. In this paper, we develop a GPU-parallel coordinate descent (CD) algorithm for the SPMESL and numerically show that the proposed algorithm is much faster than the least angle regression (LARS) tailored to the SPMESL. Several comprehensive numerical studies are conducted to investigate the scalability of the proposed algorithm and the estimation performance of the SPMESL. The results show that the SPMESL has the lowest false discovery rate for all cases and the best performance in the case where the level of the sparsity of the columns is high. [ABSTRACT FROM AUTHOR]

Tridiagonal system solver is a basic kernel and has been well-supported in mainstream numerical libraries. The purpose of this paper is to devise an efficient parallel algorithm to solve a large-scale tridiagonal system. Based on the performance analysis of the classic Thomas algorithm and matrix splitting method, we propose a parallel Thomas split (PTS) algorithm. Compared with the matrix splitting method, the PTS algorithm can achieve an acceleration of 10.34 × . Furthermore, we propose a Sunway parallel Thomas split (swPTS) algorithm based on the sw26010pro manycore processor. In the swPTS algorithm, we propose a specific data partitioning scheme to implement MPI+Athread parallelism. In the reduced set of equations, a new reduction approach for the Sunway architecture is proposed. Experiments show that the parallel elimination stage of our swPTS algorithm achieves up to 38.31 × speedup over a PTS algorithm, and overall reaches 5.74 × speedup over a Thomas algorithm. [ABSTRACT FROM AUTHOR]

The generalized Schwarz algorithm for a class of elliptic quasi-variational inequalities related to impulse control problems is studied in this paper. The principal result is to prove the error estimate in L ∞ -norm for m subdomains with overlapping nonmatching grids. This approach combines the geometrical convergence and the uniform convergence. [ABSTRACT FROM AUTHOR]

Counting number of triangles in the graph is considered a major task in many large-scale graph analytics problems such as clustering coefficient, transitivity ratio, trusses, etc. In recent years, MapReduce becomes one of the most popular and powerful frameworks for analyzing large-scale graphs in clusters of machines. In this paper, we propose two new MapReduce algorithms based on graph partitioning. The two algorithms avoid the problem of duplicate counting triangles that other algorithms suffer from. The experimental results show a high efficiency of the two algorithms in comparison with an existing algorithm, overcoming it in the execution time performance, especially in very large-scale graphs. [ABSTRACT FROM AUTHOR]

Convex clustering has received recently an increased interest as a valuable method for unsupervised learning. Unlike conventional clustering methods such as k-means, its formulation corresponds to solving a convex optimization problem and hence, alleviates initialization and local minima problems. However, while several algorithms have been proposed to solve convex clustering formulations, including those based on the alternating direction method of multipliers (ADMM), there is currently a limited body of work on developing scalable parallel and distributed algorithms and solvers for convex clustering. In this paper, we develop a parallel, ADMM-based method, for a modified convex clustering sum-of-norms (SON) formulation for master–worker architectures, where the data to be clustered are partitioned across a number of worker nodes, and we provide its efficient, open-source implementation (available on Parallel ADMM-based convex clustering. https://github.com/lidijaf/Parallel-ADMM-based-convex-clustering. Accessed on 10 June 2022) for high-performance computing (HPC) cluster environments. Extensive numerical evaluations on real and synthetic data sets demonstrate a high degree of scalability and efficiency of the method, when compared with existing alternative solvers for convex clustering. [ABSTRACT FROM AUTHOR]

Aiming at the low processing speed of the Sobel edge detection algorithm and the equipment limitations of Compute Unified Device Architecture (CUDA) implementation algorithm acceleration, a Sobel edge detection parallel algorithm based on Open Computing Language (OpenCL) architecture is proposed. The algorithm uses the heterogeneous mode of CPU + GPU to achieve algorithm acceleration. According to the parallel structure and hardware characteristics of Graphics Processing Unit (GPU), the parallel algorithm adopts two acceleration technologies, multi-level storage technology, and vector access technology, which optimizes the data storage structure, improves the data access efficiency, and reduces the complexity of the algorithm. Unlike the CUDA implementation algorithm acceleration for NVIDIA graphics card devices, the OpenCL parallel improved algorithm has no device limitations. Experimental results show that compared with the CPU serial algorithm, the OpenMP parallel algorithm, and the CUDA parallel algorithm, the parallel algorithm has obtained 9.55 times, 2.23 times, and 1.17 times speedup, respectively. The parallel algorithm in this paper shows good data expansibility and platform portability and can provide technical support for the deep application of massive image data. [ABSTRACT FROM AUTHOR]

The Jacobi iterative algorithm has the characteristic of low computational load, and multiple components of the solution can be solved independently. This paper applies these characteristics to the ternary optical computer, which can be used for parallel optimization because it has a large number of data bits and reconfigurable processor bits. Therefore, a new parallel design scheme is constructed to solve the problem of slow efficiency in solving large linear equations. And the elaborate experiment is used to verify. The experimental method is to simulate the calculation on the ternary optical computer experimental platform. Then, the resource consumption is numerically calculated and summarized to measure the feasibility of the parallel design. Eventually, the results show that the parallel design has obvious advantages in computing speed. The Jacobi iterative algorithm is optimized in parallel on ternary optical processor for the first time. There are two parallel highlights of the scheme. First, the n components are calculated in full parallel. Second, the modified signed-digit (MSD) multiplier based on the minimum module and one-step MSD adder are used to calculate each component to eliminate the impact of large amount of data on calculation time. The research provides a new method for fast solution of large linear equations. [ABSTRACT FROM AUTHOR]

Border tracking in binary images is an important kernel for many applications. There are very efficient sequential algorithms, most notably, the algorithm proposed by Suzuki et al., which has been implemented for CPUs in well-known libraries. However, under some circumstances, it would be advantageous to perform the border tracking in GPUs as efficiently as possible. In this paper, we propose a parallel version of the Suzuki algorithm that is designed to be executed in GPUs and implemented in CUDA. The proposed algorithm is based on splitting the image into small rectangles. Then, a thread is launched for each rectangle, which tracks the borders in its associated rectangle. The final step is to perform the connection of the borders belonging to several rectangles. The parallel algorithm has been compared with a state-of-the-art sequential CPU version, using two different CPUs and two different GPUs for the evaluation. The computing times obtained show that in these experiments with the GPUs and CPUs that we had available, the proposed parallel algorithm running in the fastest GPU is more than 10 times faster than the sequential CPU routine running in the fastest CPU. [ABSTRACT FROM AUTHOR]

Biological interaction databases accommodate information about interacted proteins or genes. Clustering on the networks formed by the interaction information for finding regions highly connected could reveal the functional affinities or structural similarities between protein or gene entities. With the ever-increasing amounts of information in these databases, the runtime of a clustering task is more and more unaffordable. In this paper, we propose a heterogeneous parallel algorithm focusing on accelerating clustering tasks using distributed CPU–GPU clusters. Our parallel implementation is based on the original serial algorithm of the Markov clustering (MCL). In our parallel implementation, we utilize both the CPUs and GPUs to exploit the power of heterogeneous platforms. With the BioGRID biological interaction database, we have tested the proposed algorithm on a computer cluster equipped with NVIDIA Tesla P100 GPU accelerators. The result shows that, the algorithm is efficient in GPU memory usage and inter-node data transmission, and it can complete the clustering task in 3.2 minutes with the best speedup of 70.02 times compared to the serial counterpart.We believe our work can provide key insights for realizing fast MCL analyses on large-scale biological data, with distributed CPU–GPU computer clusters. [ABSTRACT FROM AUTHOR]

Pathfinding problem has several applications in our life and widely used in virtual environments. It has different goals such as shortest path, secure path, or optimal path. Pathfinding problem deals with a large amount of data since it considers every point located in 2D or 3D scenes. The number of possibilities in such a problem is huge. Moreover, it depends on determining standards of best path definition. In this paper, we introduce a parallel A* algorithm to find the optimal path using Apache Spark. The proposed algorithm is evaluated in terms of runtime, speedup, efficiency, and cost on a generated dataset with different sizes (small, medium, and large). The generated dataset considers real terrain challenges, such as the slope and obstacles. Hadoop Insight cluster provided by Azure has been used to run the application. The proposed algorithm reached a speedup up to 4.85 running on six worker nodes. [ABSTRACT FROM AUTHOR]

Minimum cost parenthesizing problem (MPP for short) is a well-known example of the polyadic-nonserial dynamic-programming problem. This paper presents two efficient parallel algorithms on the coarse-grained multicomputer model for solving the MPP. By allowing processors to stay active as long as possible thanks to our irregular partitioning technique of dependency graph, these algorithms minimize their idle time and promote load-balancing between them. The algorithms also reduce the latency time of processors (which is the largest part of the overall communication time) by allowing them to start evaluating subproblems as soon as the data they need are available. The first algorithm runs in O n 3 / 4 k p execution time with O 2 k p communication rounds. The second runs in O n 3 / 2 k p execution time with O 4 k p communication rounds. n is the input data size, p is the number of processors, and k is a parameter used in the partitioning technique of our algorithms. The experimental results obtained show that these new algorithms are better than the most efficient previous solutions. [ABSTRACT FROM AUTHOR]

Prior algorithms on graph simulation for distributed graphs are not scalable enough as they exhibit heavy message passing. Moreover, they are dependent on the graph partitioning quality that can be a bottleneck due to the natural skew present in real-world data. As a result, their degree of parallelism becomes limited. In this paper, we propose an efficient parallel edge-centric approach for distributed graph pattern matching. We design a novel distributed data structure called ST that allows a fine-grain parallelism, and hence guarantees linear scalability. Based on ST, we develop a parallel graph simulation algorithm called PGSim. Furthermore, we propose PDSim, an edge-centric algorithm that efficiently evaluates dual simulation in parallel. PDSim combines ST and PGSim in a Split-and-Combine approach to accelerate the computation stages. We prove the effectiveness and efficiency of these propositions through theoretical guarantees and extensive experiments on massive graphs. The achieved results confirm that our approach outperforms existing algorithms by more than an order of magnitude. [ABSTRACT FROM AUTHOR]

In the field of multi-objective optimization algorithms, multi-objective Bayesian Global Optimization (MOBGO) is an important branch, in addition to evolutionary multi-objective optimization algorithms. MOBGO utilizes Gaussian Process models learned from previous objective function evaluations to decide the next evaluation site by maximizing or minimizing an infill criterion. A commonly used criterion in MOBGO is the Expected Hypervolume Improvement (EHVI), which shows a good performance on a wide range of problems, with respect to exploration and exploitation. However, so far, it has been a challenge to calculate exact EHVI values efficiently. This paper proposes an efficient algorithm for the exact calculation of the EHVI for in a generic case. This efficient algorithm is based on partitioning the integration volume into a set of axis-parallel slices. Theoretically, the upper bound time complexities can be improved from previously O (n 2) and O (n 3) , for two- and three-objective problems respectively, to Θ (n log n) , which is asymptotically optimal. This article generalizes the scheme in higher dimensional cases by utilizing a new hyperbox decomposition technique, which is proposed by Dächert et al. (Eur J Oper Res 260(3):841–855, 2017). It also utilizes a generalization of the multilayered integration scheme that scales linearly in the number of hyperboxes of the decomposition. The speed comparison shows that the proposed algorithm in this paper significantly reduces computation time. Finally, this decomposition technique is applied in the calculation of the Probability of Improvement (PoI). [ABSTRACT FROM AUTHOR]

Hpcfolder is a user-friendly high-performance computing tool that can be used to analyze the performance of algorithms parallelized using MPI. It is possible to view the parallel algorithm's performance in a python notebook file that reads data values from a file and plots graphs by performing calculations on the data values. These plots that are generated by the python script inside the python script in a python notebook are useful in understanding changes in various performance metrics with variation in the number of processes and the problem size. A comparative study was also performed between two simple algorithms which are the multiplication using repeated addition algorithm (which is not computationally intensive) and the matrix multiplication algorithm (which is computationally intensive), and meaningful insights were provided to show the difference in performance of both the algorithms with a variation in the problem size and the number of processors. The goal of this paper is to present how a simple tool can be developed from scratch that can help users analyze the performance of parallel algorithms using MPI. [ABSTRACT FROM AUTHOR]

Embedding an interconnection network into another network is one of the important problems in parallel processing. In this paper, we study embedding of linear arrays (paths) of maximum length in O-shaped meshes (O-shaped grid graphs). This is equal to finding a longest path in an O-shaped mesh (grid graph). An O-shaped mesh is a 2D mesh that a smaller 2D mesh is removed from it. The removed nodes can be considered as faulty processor. We give a linear-time parallel algorithm for this problem. To show the algorithm finds an optimal path, first we prove some upper bounds on the length of the longest paths, then we show that how our algorithm meets these upper bounds. [ABSTRACT FROM AUTHOR]

Influence maximization in social networks refers to the process of finding influential users who make the most of information or product adoption. The social networks is prone to grow exponentially, which makes it difficult to analyze. Critically, most of approaches in the literature focus only on modeling structural properties, ignoring the social behavior in the relations between users. For this, we tend to parallelize the influence maximization task based on social behavior. In this paper, we introduce a new parallel algorithm, named PSAIIM, for identification of influential users in social network. In PSAIIM, we uses two semantic metrics: the user's interests and the dynamically-weighted social actions as user interactive behaviors. In order to overcome the size of actual real-world social networks and to minimize the execution time, we used the community structure to apply perfect parallelism to the CPU architecture of the machines to compute an optimal set of influential nodes. Experimental results on real-world networks reveal effectiveness of the proposed method as compared to the existing state-of-the-art influence maximization algorithms, especially in the speed of calculation. [ABSTRACT FROM AUTHOR]

Travelling salesman problem (TSP) is a graph problem that has been widely used in many applications, especially for transportation and logistics. Because TSP is a NP hard problem, minimizing the complexity of TSP algorithms is an important problem. Many heuristic algorithms have been proposed to compute the TSP tours of a given static graph. But limited studies have been done on time-evolving graph (TEG) where the graph can change over time due to update events, such as weight changes on edges or vertices. It is a more challenging problem because the speed of TSP computations must be high enough to catch up the graph update frequency. In this paper, we make the very first attempt to minimize the computation time of solving TSP on time-evolving graphs. By exploring parallel computing power and reusing previous computing results, we proposed a distributed and incremental TSP algorithm which can be implemented on vertex-centric parallel graph computing frameworks to efficiently find TSP tours on large changing graphs. Our incremental algorithm can maintain shortest TSP tour with minimum amount of recomputation. Through our experimental evaluation, we have shown incremental TSP algorithm is 98% faster than distributed algorithm. [ABSTRACT FROM AUTHOR]

Given two datasets of points (called Query and Training), the Group (K) Nearest-Neighbor (GKNN) query retrieves (K) points of the Training with the smallest sum of distances to every point of the Query. This spatial query has been studied during the recent years and several performance improving techniques and pruning heuristics have been proposed. In previous work, we presented the first MapReduce algorithm, consisting of alternating local and parallel phases, which can be used to effectively process the GKNN query when the Query fits in memory, while the Training one belongs to the Big Data category. In this paper, we present a significantly improved algorithm that incorporates a new high-performance refining method, a fast way to calculate distance sums for pruning purposes and several other minor coding and algorithmic improvements. Moreover, we transform this algorithm (which has been implemented in the Hadoop framework) to SpatialHadoop (a popular distributed framework that is dedicated to spatial processing), using a novel two-level partitioning method. Using real world and synthetic datasets, we also present a thorough experimental study of the Hadoop and SpatialHadoop versions of the algorithm, including a backstage analysis of the algorithm's performance, using metrics that highlight its internal functioning. Finally, we present an experimental comparison of the Hadoop, the SpatialHadoop versions and the version of our previous work, showing that the improved versions are the big winners, with the SpatialHadoop one being faster than its Hadoop counterpart. [ABSTRACT FROM AUTHOR]

This paper provides iterative construction of a common solution associated with the classes of equilibrium problems (EP) and split convex feasibility problems. In particular, we are interested in the EP defined with respect to the pseudomonotone bifunction, the fixed point problem (FPP) for a finite family of -demicontractive operators, and the split null point problem. From the numerical standpoint, combining various classical iterative algorithms to study two or more abstract problems is a fascinating field of research. We, therefore, propose an iterative algorithm that combines the parallel hybrid extragradient algorithm with the inertial extrapolation technique. The analysis of the proposed algorithm comprises theoretical results concerning strong convergence under a suitable set of constraints and numerical results. [ABSTRACT FROM AUTHOR]

The present study proposes a novel method based on evolutionary and fuzzy approaches for unifying two-level perfect nested loops. In this method, the Shuffled Frog Leaping Algorithm (SFLA) is used for achieving optimal answers, and simultaneously, three critical factors are applied as an input in determining basic dependence vectors. The use of fuzzy logic versus fixed coefficients for these three factors has led to the creation of optimal results with high variability and has solved the problem regarding the existence of the main vectors. In addition, the present algorithm has been proposed for many input data so that it can be used in parallel compilers automatically and with low complexity. After implementing and evaluating the proposed method, it was found that, compared to other existing methods, the results achieved were very close to optimal, in the least time, and with the lowest Dependence Cone Size (DCS) and highest number of input vectors. [ABSTRACT FROM AUTHOR]

Given a text and a pattern over an alphabet, the classic exact matching problem searches for all occurrences of the pattern in the text. Unlike exact matching, order-preserving pattern matching (OPPM) considers the relative order of elements, rather than their exact values. In this paper, we propose efficient algorithms for the OPPM problem using the “duel-and-sweep” paradigm. For a pattern of length m and a text of length n, our serial algorithm runs in O(n+mlogm)\documentclass[12pt]{minimal}\usepackage{amsmath}\usepackage{wasysym}\usepackage{amsfonts}\usepackage{amssymb}\usepackage{amsbsy}\usepackage{mathrsfs}\usepackage{upgreek}\setlength{\oddsidemargin}{-69pt}\begin{document}$$O(n + m\log m)$$\end{document} time, and our parallel algorithm runs in O(log2m)\documentclass[12pt]{minimal}\usepackage{amsmath}\usepackage{wasysym}\usepackage{amsfonts}\usepackage{amssymb}\usepackage{amsbsy}\usepackage{mathrsfs}\usepackage{upgreek}\setlength{\oddsidemargin}{-69pt}\begin{document}$$O(\log ^2 m)$$\end{document} time and O(nlog2m)\documentclass[12pt]{minimal}\usepackage{amsmath}\usepackage{wasysym}\usepackage{amsfonts}\usepackage{amssymb}\usepackage{amsbsy}\usepackage{mathrsfs}\usepackage{upgreek}\setlength{\oddsidemargin}{-69pt}\begin{document}$$O(n \log ^2 m)$$\end{document} work with O(logm)\documentclass[12pt]{minimal}\usepackage{amsmath}\usepackage{wasysym}\usepackage{amsfonts}\usepackage{amssymb}\usepackage{amsbsy}\usepackage{mathrsfs}\usepackage{upgreek}\setlength{\oddsidemargin}{-69pt}\begin{document}$$O(\log m)$$\end{document} time and O(mlogm)\documentclass[12pt]{minimal}\usepackage{amsmath}\usepackage{wasysym}\usepackage{amsfonts}\usepackage{amssymb}\usepackage{amsbsy}\usepackage{mathrsfs}\usepackage{upgreek}\setlength{\oddsidemargin}{-69pt}\begin{document}$$O(m \log m)$$\end{document} work pattern preprocessing on the Priority Concurrent Read Concurrent Write Parallel Random-Access Machines (P-CRCW PRAM). [ABSTRACT FROM AUTHOR]

Graph embedding is an important technology in simulating parallel structures and designing VLSI layout. Hypercube is one of the most significant interconnection networks in parallel computing systems. The exchanged hypercube is an important variant of the hypercube, which is obtained by systematically deleting edges from a hypercube. It not only retains several valuable and desirable properties of the hypercube, but also has lower hardware cost. In this paper, we first give an exact formula of minimum wirelength of exchanged hypercube layout into a grid. Furthermore, we propose an O(N) algorithm for embedding exchanged hypercube into a gird with load 1, expansion 1 and minimum wirelength and derive a linear layout of exchanged hypercube with minimum number of tracks and efficient layout areas. Finally, we present simulation experiments of our embedding algorithm on network overhead and total wirelength, which conduce to estimate the total wirelength and chip area. [ABSTRACT FROM AUTHOR]

ChainMail algorithm is a physically based deformation algorithm that has been successfully used in virtual surgery simulators, where time is a critical factor. In this paper, we present a parallel algorithm, based on ChainMail, and its efficient implementation that reduces the time required to compute deformations over large medical 3D datasets by means of modern GPU capabilities. We also present a 3D blocking scheme that reduces the amount of unnecessary processing threads. For this purpose, this paper describes a new parallel boolean reduction scheme, used to efficiently decide which blocks are computed. Finally, through an extensive analysis, we show the performance improvement achieved by our implementation of the proposed algorithm and the use of the proposed blocking scheme, due to the high spatial and temporal locality of our approach. [ABSTRACT FROM AUTHOR]

In this paper, we propose parallel graph-grammar-based algorithm for the longest-edge refinements and the pollution simulations in Lesser Poland area. We introduce graph-grammar productions for Rivara's longest-edged algorithm for the local refinement of unstructured triangular meshes. We utilize the hyper-graph to represent the computational mesh and the graph-grammar productions to express the longest-edge mesh refinement algorithm. The parallelism in the original Rivara's longest edge refinement algorithm is obtained by processing different longest edge refinement paths in different three ads. Our graph-grammar-based algorithm allows for additional parallelization within a single longest-edge refinement path. The graph-grammar-based algorithm automatically guarantees the validity and conformity of the generated mesh; it prevents the generation of duplicated nodes and edges, elongated elements with Jacobians converging to zero, and removes all the hanging nodes automatically from the mesh. We test the algorithm on generating a surface mesh based on a topographic data of Lesser Poland area. The graph-grammar productions also generate the layers of prismatic three-dimensional elements on top of the triangular mesh, and they break each prismatic element into three tetrahedral elements. Next, we propose graph-grammar productions generating element matrices and right-hand-side vectors for each tetrahedral element. We utilize the Streamline Upwind Petrov–Galerkin (SUPG) stabilization for the pollution propagation simulations in Lesser Poland area. We use the advection–diffusion-reaction model, the Crank–Nicolson time integration scheme, and the graph-grammar-based interface to the GMRES solver. [ABSTRACT FROM AUTHOR]

We suggest in this paper a parallel implementation of cellular automation and global random walk algorithms for solving drift–diffusion–recombination problems which in contrast to the classical random walk on spheres (RWS) methods calculate the solution in any desired family of m prescribed points. The method uses only N trajectories in contrast to mN trajectories in the conventional RWS algorithm. The idea is based on the adjoint symmetry property of the Green function and a double randomization approach. The synchronous multi-particle cellular automaton model of drift–diffusion–recombination is based on known cellular automata. The global RWS and cellular automaton models are tested against the exact solutions of the equation. The accuracy and computer time of both algorithms is analyzed. Parallel codes for the Monte Carlo and cellular automaton algorithms are implemented. The domain decomposition method is employed for the cellular automaton parallel implementation. The global random walk algorithm is parallelized by the Monte Carlo trajectories distribution among the cluster cores. The efficiency of the parallel codes is studied. [ABSTRACT FROM AUTHOR]

Huber robust regression (HRR) has attracted much attention in machine learning due to its greater robustness to outliers compared to least-squares regression. However, existing algorithms for HRR are computationally much less efficient than those for least-squares regression. Based on a maximally split alternating direction method of multipliers (MS-ADMM) for model fitting, a highly computationally efficient algorithm referred to as the modified MS-ADMM is derived in this article for HRR. After analyzing the convergence of the modified MS-ADMM, a parameter selection scheme is presented for the algorithm. With the parameter values calculated via this scheme, the modified MS-ADMM converges very rapidly, much faster than several typical HRR algorithms. Through applications in the training of stochastic neural networks and comparisons with existing algorithms, the modified MS-ADMM is shown to be computationally much more efficient than the convex quadratic programming method, the Newton method, the iterative reweighted least-squares method, and Nesterov's accelerated gradient method. Implementation of the proposed algorithm on a GPU-based parallel computing platform demonstrates its higher GPU acceleration ratio compared to the competing methods and, thus, its greater superiority in computational efficiency over the competing methods. [ABSTRACT FROM AUTHOR]

Runtime verification is a monitoring technique to gain assurance about well-being of a program at run time. Most existing approaches use sequential monitors; i.e., when the state of the program with respect to an event of interest changes, the monitor interrupts the program execution, evaluates a set of logical properties, and finally resumes the program execution. In this paper, we propose a GPU-based method for design and implementation of monitors that enjoy two levels of parallelism: the monitor (1) works along with the program in parallel, and (2) evaluates a set of properties in a parallel fashion as well. Our parallel monitoring algorithms effectively exploit the many-core platform available in the GPU. In addition to parallel processing, our approach benefits from a true separation of monitoring and functional concerns, as it isolates the monitor in the GPU. Thus, our monitoring approach incurs minimal intrusion, as executing monitoring tasks take place in a different computing hardware from execution of the program under inspection. Our method is fully implemented for parametric and non-parametric 3-valued linear temporal logic. Our experimental results show significant reduction in monitoring overhead, monitoring interference, and power consumption due to leveraging the GPU technology. In particular, we observe that our parallel verification algorithms are indeed scalable. [ABSTRACT FROM AUTHOR]

The slope calculation algorithm is one of the most widely used geospatial algorithms employing the 3x3 moving window technique (along with calculation of aspect, curvature and flow direction). This work presents an approach consisting of transforming a slope algorithm from a sequential form into a version that can exploit vector and parallel traits of multicore architectures with vector instructions. This approach allows us to take advantage of the potential of the modern multicore processors. The basic idea for optimizing the 3x3 moving window computation is to split the equation used to calculate the result into parts that operate on data that are known to exist in adjacent memory locations. The research was conducted on two multicore architectures without the change in the code — the older architecture was Sandy Bridge and the newer one was Haswell (with more cores). The efficiency of the developed slope algorithm was verified in practice with the use of DEM files of the same resolution but of different sizes. We showed through the numerical experiments that our approach gives better time performance than the original algorithm (and other tools) — and with no loss of accuracy. [ABSTRACT FROM AUTHOR]