Multi-core CPU Architectures Research Articles

GeoTaichi: A Taichi-powered high-performance numerical simulator for multiscale geophysical problems

This study introduces GeoTaichi, an open-source high-performance numerical simulator designed for addressing multiscale geophysical problems. By leveraging the power of the Taichi parallel language, GeoTaichi maximizes the utilization of modern computer resources on multicore CPU and GPU architectures. It offers robust and reliable modules for the discrete element method (DEM), material point method (MPM), and coupled material point-discrete element method (MPDEM). These modules enable efficient solving of large-scale problems while being implemented in pure Python. The design philosophy of GeoTaichi focuses on creating a framework that is readable, extensible, and user-friendly. This paper highlights the coupling procedure of MPDEM, the code structures, and the most important features of GeoTaichi. Rigorous benchmark tests have been conducted to verify the validity and robustness of GeoTaichi. Additionally, the performance of GeoTaichi is compared with similar software tools in the field, underscoring a notable improvement in both computational efficiency and memory savings when compared to existing alternatives. Program summaryProgram title: GeoTaichiCPC Library link to program files:https://doi.org/10.17632/858bmcf7j6.1Developer's repository link:https://github.com/Yihao-Shi/GeoTaichiLicensing provisions: GNU General Public License v3.0Programming language: PythonNature of problem: The simulations of large-deformation geophysical flows and their interaction with structures play a crucial role in the field of geophysics. To address the complexities of these nonlinear problems, the discrete element method (DEM), material point method (MPM), and their coupling (MPDEM) have proven to be highly suitable numerical schemes. However, these schemes impose substantial computational demands, necessitating the development of an efficient framework that can harness modern computer resources on multicore CPU and GPU architectures.Solution method: The open-source code GeoTaichi implements the DEM, MPM, and coupled MPDEM, encompassing a range of constitutive models and contact laws for different geologic materials. The clump particle model is also introduced in DEM to solve granular mechanics involving complex-shaped particles. One significant advantage of GeoTaichi is its utilization of the Taichi parallel language, which is designed to be user-friendly and easily extensible for customized applications.

OpenMP-based parallel MLPG solver for analysis of heat conduction

PurposeIn the present work, we focus on developing an in-house parallel meshless local Petrov-Galerkin (MLPG) code for the analysis of heat conduction in two-dimensional and three-dimensional regular as well as complex geometries.Design/methodology/approachThe parallel MLPG code has been implemented using open multi-processing (OpenMP) application programming interface (API) on the shared memory multicore CPU architecture. Numerical simulations have been performed to find the critical regions of the serial code, and an OpenMP-based parallel MLPG code is developed, considering the critical regions of the sequential code.FindingsBased on performance parameters such as speed-up and parallel efficiency, the credibility of the parallelization procedure has been established. Maximum speed-up and parallel efficiency are 10.94 and 0.92 for regular three-dimensional geometry (343,000 nodes). Results demonstrate the suitability of parallelization for larger nodes as parallel efficiency and speed-up are more for the larger nodes.Originality/valueFew attempts have been made in parallel implementation of the MLPG method for solving large-scale industrial problems. Although the literature suggests that message-passing interface (MPI) based parallel MLPG codes have been developed, the OpenMP model has rarely been touched. This work is an attempt at the development of OpenMP-based parallel MLPG code for the very first time.

A parallel Canny edge detection algorithm based on OpenCL acceleration.

In the process of Canny edge detection, a large number of high complexity calculations such as Gaussian filtering, gradient calculation, non-maximum suppression, and double threshold judgment need to be performed on the image, which takes up a lot of operation time, which is a great challenge to the real-time requirements of the algorithm. The traditional Canny edge detection technology mainly uses customized equipment such as DSP and FPGA, but it has some problems, such as long development cycle, difficult debugging, resource consumption, and so on. At the same time, the adopted CUDA platform has the problem of poor cross-platform. In order to solve this problem, a fine-grained parallel Canny edge detection method is proposed, which is optimized from three aspects: task partition, vector memory access, and NDRange optimization, and CPU-GPU collaborative parallelism is realized. At the same time, the parallel Canny edge detection methods based on multi-core CPU and CUDA architecture are designed. The experimental results show that OpenCL accelerated Canny edge detection algorithm (OCL_Canny) achieves 20.68 times acceleration ratio compared with CPU serial algorithm at 7452 × 8024 image resolution. At the image resolution of 3500 × 3500, the OCL_Canny algorithm achieves 3.96 times the acceleration ratio compared with the CPU multi-threaded Canny parallel algorithm. At 1024 × 1024 image resolution, the OCL_Canny algorithm achieves 1.21 times the acceleration ratio compared with the CUDA-based Canny parallel algorithm. The effectiveness and performance portability of the proposed Canny edge detection parallel algorithm are verified, and it provides a reference for the research of fast calculation of image big data.

Efficient sweep kernels on shared-memory architectures for the discrete ordinates neutron transport equation on Cartesian and hexagonal geometries

This paper describes the implementation of DONUT, a small multi-group SN-DG transport solver that aims at providing efficient and portable sweep kernels on shared-memory architectures for Cartesian and hexagonal geometries. DONUT heavily relies on the Kokkos C++ library for portability and genericity. First encouraging performance results are presented for multicore CPU architectures.

A consensus-based alternating direction method of multipliers approach to parallelize large-scale minimum-lap-time problems

Minimum-lap-time planning (MLTP) problems, which entail finding optimal trajectories for race cars on racetracks, have received significant attention in the recent literature. They are commonly addressed as optimal control problems (OCPs) and are numerically discretized using direct collocation methods. Subsequently, they are solved as nonlinear programs (NLPs). The conventional approach to solving MLTP problems is serial, whereby the resulting NLP is solved all at once. However, for problems characterized by a large number of variables, distributed optimization algorithms, such as the alternating direction method of multipliers (ADMM), may represent a viable option, especially when multicore CPU architectures are available.This study presents a consensus-based ADMM approach tailored to solving MLTP problems through a distributed optimization algorithm. The algorithm partitions the problem into smaller subproblems based on different sectors of a track, distributing them among multiple processors. ADMM is then used to ensure consensus among the distributed computational processes. In particular, here the term “consensus” denotes the requirement for each subproblem to achieve mutual agreement across the junction areas. The paper also outlines specific strategies leveraging domain knowledge to improve the convergence of the distributed algorithm. The ADMM approach is validated against the serial approach, and numerical results are presented for both single-lap and multilap scenarios. In both cases, the ADMM approach proves superior for problem dimensions of 70k+ variables compared to serial methods. In planning scenarios with complex vehicle models on long track horizons, i.e., for problems with 1M+ variables, the efficiency gain of the ADMM approach is substantial, and it becomes the only viable option to maintain computational times within acceptable limits.

Mdapy: A flexible and efficient analysis software for molecular dynamics simulations

The mdapy is a library for pre- and postprocessing molecular dynamics simulation data. Benefitting from the just-in-time compile technology of TaiChi mdapy can be written in pure Python while possessing similar speed to those written in C++. mdapy is designed with highly paralleled and makes full advantages of modern computer resources on both multicore CPU and GPU architecture. The package implements a fast module to find the neighbors of particles in both free and periodic boundaries, based on which it offers a wide variety of methods to analyze atomic environments, such as standard centrosymmetry parameters, radial distribution function and newer methods, such as atomic entropy fingerprint. In addition, mdapy can be used to create the geometric structure of polycrystals with metallic or graphene grain boundaries by Voronoi diagram. mdapy can directly read the DUMP and DATA format defined in LAMMPS code, and, in practice, it accepts any other format by converting it into NumPy ndarray format. This design philosophy enables seamless integration with abundant scientific ecosystems in the Python community and easy cooperation with other analysis codes like OVITO or freud. Program summaryProgram Title: mdapyCPC Library link to program files:https://doi.org/10.17632/dtdkxvcsc9.1Developer's repository link:https://github.com/mushroomfire/mdapyCode Ocean capsule:https://codeocean.com/capsule/5271472Licensing provisions: BSD 3-clauseProgramming language: Python, C++Nature of problem: Atomic environment analysis and generation of the initial structure are important in molecular dynamics simulations. Many analysis methods relying on particle neighbors, such as radial distribution functions and atomic entropy, are computationally intensive and need to be carefully implemented to scale to large systems. Traditional code is often written in C++ or Fortran to guarantee performance while causing difficulty in installation and secondary development due to the complexity of the programming language.Solution method: mdapy is written in parallel to quickly perform neighbor finding, provides a set of analysis methods and creates an atomic geometry structure on multicore CPU and GPU. Over 95 percent of mdapy is written in Python with a uniform API to call. All data are stored in NumPy ndarray, making users easy to install, use and secondary develop.Additional comments including restrictions and unusual features:1. mdapy provides fast parallel implementations of neighbor finding in periodic and free boundary system.2. mdapy can generate a polycrystalline model with graphene grain boundaries.3. mdapy is helpful for analyzing the melting process by the mean squared displacement and Lindemann index at the atomic level.4. mdapy is very easy to install via pip install mdapy without any compile steps and can be run on Windows, Linux and Mac OS with Python 3.7-3.10.5. mdapy has detailed documentation to make it easier to use.

Automatic segmentation and parallel phased least squares for highly efficient geodetic network parameter estimation

This paper describes a novel automatic segmentation algorithm and parallel phased least squares strategy. These developments have been motivated by a requirement to repeatedly estimate extremely large parameter sets from massive and constantly changing geodetic networks in a highly efficient manner. The challenge of solving parameter sets efficiently, together with the inverse of the normal equations to obtain the full matrix of parameter estimate precisions, may be addressed by using highly optimised parallel matrix factorisation libraries. While offering notable reductions in time on multi-core CPU architectures, the simultaneous solution of extremely large measurement sets still requires excessive amounts of time and computational resources (if attainable). Historically, the challenge has been addressed by geodesists through a range of Helmert blocking or matrix partitioning techniques and sequential least squares models. While capable of producing rigorous parameter estimates, certain methods suffer from computational inefficiency; implementation complexity; inflexibility in re-forming the parameterised expressions upon the introduction of new measurements or non-rigorous variance matrices. Tienstra's phased least squares method is able to overcome all of the aforementioned problems, provided an efficient and flexible process is available for rigorously subdividing the parameters and measurements. In this contribution, we present an automatic segmentation algorithm and a strategy for parallelising Tienstra's phased least squares method using a dynamic scheduling queue. These developments offer a breakthrough in geodetic methodology, in that for the first time they allow for the rigorous solution of both parameters and variances from massive systems of observation equations subject to continual change in an adaptive and highly efficient manner.

HEGrid: A high efficient multi-channel radio astronomical data gridding framework in heterogeneous computing environments

The challenge to fully exploit the potential of existing and upcoming scientific instruments like large single-dish radio telescopes is to process the collected massive data effectively and efficiently. As a ”quasi 2D stencil computation” with the ”Moore neighborhood pattern”, gridding is the most computationally intensive step in data reduction pipeline for radio astronomy studies, enabling astronomers to create correct sky images for further analysis. However, the existing gridding frameworks can either only run on multi-core CPU architecture or do not support high-concurrency, multi-channel data gridding. Their performance is then limited, and there are emerging needs for innovative gridding frameworks to process data from large single-dish radio telescopes like the Five-hundred-meter Aperture Spherical Telescope (FAST). To address those challenges, we developed a High Efficient Gridding framework, HEGrid, by overcoming the above limitations. HEGrid is the first effort to solve the gridding of multi-channel data from the large single-dish radio telescope by multi-pipeline concurrency in the CPU–GPU heterogeneous environment. Specifically, we propose and construct the gridding pipeline in heterogeneous computing environments and achieve multi-pipeline concurrency for high performance multi-channel processing. Furthermore, we propose pipeline-based co-optimization to alleviate the potential negative performance impact of possible intra- and inter-pipeline low computation and I/O utilization, including component share-based redundancy elimination, thread-level data reuse and overlapping I/O and computation. Our experiments are based on both simulated datasets and actual FAST observational datasets. The results show that HEGrid outperforms other state-of-the-art gridding frameworks by up to 5.5x and has robust hardware portability, including AMD Radeon Instinct GPU and NVIDIA GPU.

GPU and CPU-Based Parallel FDTD Methods for Frequency-Dependent Transmission Line Models

Finite-difference time-domain (FDTD) is a popular method utilized for solving frequency-dependent transmission line structures. It is also conveniently applicable to nonuniform wires. The FDTD algorithm discretizes the transmission line problem into a finite number of space-segments and solve for the voltage and current of each segment at every time-step. Therefore, they inherently involve more computations per timestep than conventional terminal based models. In this letter, parallel implementations of a modified FDTD algorithm for a frequency-dependent transmission line problem using multicore CPU and GPU architectures are proposed in order to increase its computational efficiency. Accuracy and performance of the parallel FDTD methods are discussed with examples. The results indicate that a speedup of a few folds compared to serial execution is achieved by the parallel implementation using multicore CPU architecture whereas a massive speedup is achieved by using GPU. The proposed model is also suitable for modelling transmission lines in massively parallel electromagnetic transient (EMT) simulation methods.

Multi-time scale electric vehicle charging load forecasting considering constant current charging and parallel computing

At present, the concept of ecological civilization has been widely recognized by the whole world, and a series of policies that guarantees the evolution of the electric vehicle (EV) industry has been implemented by multiple countries. Therefore, it is significant to predict the charging load of EVs to solve the challenges of power system planning and operation. The Monte Carlo (MC) method is preferred by many scholars in EV charging load prediction because it is very suitable for describing random characteristics with a good prediction effect. To obtain more reliable and efficient prediction results, this paper analyzes the application of parallel computing technology in MC simulation. Firstly, EVs in the region are classified according to their battery capacity. Based on the voltage change curve of lithium-ion power batteries in the process of constant current charging under different capacities, the charging power, charging time, and state of charge (SOC) of EVs are investigated. Secondly, the behavior characteristics of users and the driving parameter characteristics of EVs are studied respectively, and the probability distribution model of multi-source information is established. Thirdly, parallel computing technology in the computer field is introduced, and an improved MC method is proposed based on the multi-core CPU architecture. After fully considering the complex constant current charging process after fitting, the charging load of EVs in a region of East China is simulated. Finally, the time cost and the load forecasting results of serial and parallel methods are compared and analyzed, and the progressiveness and effectiveness of the parallel method are verified. Results show that the charging load has four peaks in a day, taxis are the main source of the peak load of the power grid, the charging load of buses fluctuates the most, and private cars are the main backup capacity to participate in V2G dispatching in the future. In addition, under the experimental conditions set in this paper, compared with the traditional serial MC method, the improved MC method based on parallel computing shows good performance with the acceleration effect improved by 7 to 12 times.

Construction of Artistic Design Patterns Based on Improved Distributed Data Parallel Computing of Heterogeneous Tasks

With the continuous upgrading of hardware in the terminal equipment, how to provide high-performance computing for low-tech threshold users has become a current research hotspot. In the era of green high-performance computing, the heterogeneous computing system can provide good versatility, performance, and efficiency and has broad development prospects. This article provides an in-depth analysis and research on the construction and application of improved models using the artistic design pattern of heterogeneous tasks and parallel computing. Based on the hardware resources in the existing desktop system, this article optimizes the original heterogeneous parallel technology from the aspects of task division and data transmission to reduce the complexity of data allocation and processing for users. Based on the analysis and study of the multicore CPU and GPU architectures in the desktop system, as well as the original CPU-GPU heterogeneous parallel technology, this article optimizes the solution of heterogeneous parallel computing, designs a heterogeneous parallel computing architecture, and deploys a heterogeneous parallel computing architecture. The nodes of the desktop system constitute the parallel computing system. In terms of task allocation, the computing system divides tasks according to the parallelism of tasks. According to the computing resources and bandwidth conditions of each heterogeneous node, starting from the parallel execution time, the task scheduling algorithm is optimized, and the load balancing scheduling scheme is designed to achieve the optimal allocation of resources. In terms of storage resources, the computing system adopts distributed storage as a whole. The CPU-GPU heterogeneous parallel in the desktop system adopts virtual unified storage. Global distributed storage and local shared storage are used to balance overall performance and programming complexity. This article introduces the design and implementation of JTangSync, a distributed heterogeneous data synchronization system. The system adopts a distributed architecture, and each node is organized by a data source module, a data transmission module, a processor module, etc. The data source module is responsible for extracting data, the data transmission module is mainly responsible for efficient data transmission, and the processor module is responsible for data processing. More importantly, each module is designed as a replaceable plug-in, which is convenient for secondary expansion. Each node relies on ZooKeeper to form a cluster, which realizes distributed functions such as centralized management of distributed resources, failover, and resumed transmission. Compared with the mainstream scheduling algorithms HEFT, CPOP, PEFT, and HSIP on heterogeneous systems participating in the experimental evaluation, the scheduling length ratio of DONF series algorithms is reduced by 36.3%–67.5% and the parallelism is increased by 17%–125% in terms of efficiency. Compared with the existing database synchronization system, the JTangSync system has built-in multiple heterogeneous database data sources and supports the synchronization of complex heterogeneous databases. The system supports users to develop and customize their own data sources and data processing programs, to promote secondary development. By adopting the custom compressed data exchange format and network optimization methods such as packet merging, caching, and adaptive compression algorithm, the system has high performance.

Parallel Discrete Convolutions on Adaptive Particle Representations of Images.

We present data structures and algorithms for native implementations of discrete convolution operators over Adaptive Particle Representations (APR) of images on parallel computer architectures. The APR is a content-adaptive image representation that locally adapts the sampling resolution to the image signal. It has been developed as an alternative to pixel representations for large, sparse images as they typically occur in fluorescence microscopy. It has been shown to reduce the memory and runtime costs of storing, visualizing, and processing such images. This, however, requires that image processing natively operates on APRs, without intermediately reverting to pixels. Designing efficient and scalable APR-native image processing primitives, however, is complicated by the APR's irregular memory structure. Here, we provide the algorithmic building blocks required to efficiently and natively process APR images using a wide range of algorithms that can be formulated in terms of discrete convolutions. We show that APR convolution naturally leads to scale-adaptive algorithms that efficiently parallelize on multi-core CPU and GPU architectures. We quantify the speedups in comparison to pixel-based algorithms and convolutions on evenly sampled data. We achieve pixel-equivalent throughputs of up to 1TB/s on a single Nvidia GeForce RTX 2080 gaming GPU, requiring up to two orders of magnitude less memory than a pixel-based implementation.

Accelerating CPU-Based Sparse General Matrix Multiplication With Binary Row Merging

Sparse general matrix multiplication (SpGEMM) is a fundamental building block for many real-world applications. Since SpGEMM is a well-known memory-bounded application with vast and irregular memory accesses, considering the memory access efficiency is of critical importance for optimizing SpGEMM. Yet, the existing methods put less consideration into the memory subsystem and achieved suboptimal performance. In this paper, we thoroughly analyze the memory access patterns of SpGEMM and their influences on the memory subsystem. Based on the analysis, we propose a novel and more efficient accumulation method named BRMerge for the multi-core CPU architectures. The BRMerge accumulation method follows the row-wise dataflow. It first accesses the <i>B</i> matrix, generates the intermediate lists for one output row, and stores these intermediate lists in a consecutive memory space, which is implemented by a ping-pong buffer. It then immediately merges these intermediate lists generated in the previous phase two by two in a tree-like hierarchy between two ping-pong buffers. The architectural benefits of BRMerge are 1) streaming access patterns, 2) minimized TLB cache misses, and 3) reasonably high L1/L2 cache hit rates, which result in both low access latency and high bandwidth utilization when performing SpGEMM. Based on the BRMerge accumulation method, we propose two SpGEMM libraries named BRMerge-Upper and BRMerge-Precise, which use different allocation methods. Performance evaluations with 26 commonly used benchmarks on two CPU servers show that the proposed SpGEMM libraries significantly outperform the state-of-the-art SpGEMM libraries.

LISFLOOD-FP 8.0: the new discontinuous Galerkin shallow-water solver for multi-core CPUs and GPUs

Abstract. LISFLOOD-FP 8.0 includes second-order discontinuous Galerkin (DG2) and first-order finite-volume (FV1) solvers of the two-dimensional shallow-water equations for modelling a wide range of flows, including rapidly propagating, supercritical flows, shock waves or flows over very smooth surfaces. The solvers are parallelised on multi-core CPU and Nvidia GPU architectures and run existing LISFLOOD-FP modelling scenarios without modification. These new, fully two-dimensional solvers are available alongside the existing local inertia solver (called ACC), which is optimised for multi-core CPUs and integrates with the LISFLOOD-FP sub-grid channel model. The predictive capabilities and computational scalability of the new DG2 and FV1 solvers are studied for two Environment Agency benchmark tests and a real-world fluvial flood simulation driven by rainfall across a 2500 km2 catchment. DG2's second-order-accurate, piecewise-planar representation of topography and flow variables enables predictions on coarse grids that are competitive with FV1 and ACC predictions on 2–4 times finer grids, particularly where river channels are wider than half the grid spacing. Despite the simplified formulation of the local inertia solver, ACC is shown to be spatially second-order-accurate and yields predictions that are close to DG2. The DG2-CPU and FV1-CPU solvers achieve near-optimal scalability up to 16 CPU cores and achieve greater efficiency on grids with fewer than 0.1 million elements. The DG2-GPU and FV1-GPU solvers are most efficient on grids with more than 1 million elements, where the GPU solvers are 2.5–4 times faster than the corresponding 16-core CPU solvers. LISFLOOD-FP 8.0 therefore marks a new step towards operational DG2 flood inundation modelling at the catchment scale. LISFLOOD-FP 8.0 is freely available under the GPL v3 license, with additional documentation and case studies at https://www.seamlesswave.com/LISFLOOD8.0 (last access: 2 June 2021).

Binned k-d Tree Construction for Sparse Volume Data on Multi-Core and GPU Systems.

While k-d trees are known to be effective for spatial indexing of sparse 3-d volume data, full reconstruction, e.g. due to changes to the alpha transfer function during rendering, is usually a costly operation with this hierarchical data structure. In a recent publication we showed how to port a clever state of the art k-d tree construction algorithm to a multi-core CPU architecture and by means of thorough optimization we were able to obtain interactive reconstruction rates for moderately sized to large data sets. The construction scheme is based on maintaining partial summed-volume tables that fit in the L1 cache of the multi-core CPU and that allow for fast occupancy queries. In this work we propose a GPU implementation of the parallel k-d tree construction algorithm and compare it with the original multi-core CPU implementation. We conduct a thorough comparative study that outlines performance and scalability of our implementation.

Adaptively accelerating FWM2DA seismic modelling program on multi-core CPU and GPU architectures

This paper presents work done towards porting of FWM2DA, an open source program, on multi-core CPU and GPU architectures. FWM2DA is a Fortran90 sequential program which performs acoustic wave propagation of single source location for the 2D subsurface earth model using finite difference time domain modelling. We have reproduced this program using C programming language and upgraded its functionality for performing acoustic wave propagation of multiple source locations and allowing different grid spacing in x and z direction for the subsurface earth model. Performance of the upgraded version is improved by implementing inter-node and intra-node parallelization. Inter-node parallelization is implemented using MPI for efficiently utilizing the distributed memory while intra-node parallelization focuses on efficient utilization of underlying architecture’s resources. Outcome of these programs are compared with that of the original FWM2DA program for Sigsbee2a model and found similar thus establishing the correctness of implementation done. The developed programs are tested using two layer subsurface earth model of 5000 X 5000 grid dimension on PARAM Shreshta system having Intel Xeon Gold 6148F Skylake CPU and NVIDIA Tesla V100 GPU. Ported programming models are evaluated for execution time for wavefield propagation of single source location using two layer subsurface earth model. Performance gain of 8.6X for OpenMP, 83.22X for OpenACC and 107.77X for CUDA C implementation are recorded over the sequential C program. The multi-core CPU program is further optimized and overall 29.37X performance is achieved with respect to the sequential C program. Performance of CUDA C program is also improved by making use of shared memory in GPU and 1.18X speedup is recorded with respect to the baseline CUDA C program. The numerical experiments demonstrate the effectiveness and robustness of the developed programs with high scalability and efficiency on multi-core CPU and GPU based HPC system.

Schedule Synthesis for Halide Pipelines on GPUs

The Halide DSL and compiler have enabled high-performance code generation for image processing pipelines targeting heterogeneous architectures through the separation of algorithmic description and optimization schedule. However, automatic schedule generation is currently only possible for multi-core CPU architectures. As a result, expert knowledge is still required when optimizing for platforms with GPU capabilities. In this work, we extend the current Halide Autoscheduler with novel optimization passes to efficiently generate schedules for CUDA-based GPU architectures. We evaluate our proposed method across a variety of applications and show that it can achieve performance competitive with that of manually tuned Halide schedules, or in many cases even better performance. Experimental results show that our schedules are on average 10% faster than manual schedules and over 2× faster than previous autoscheduling attempts.

Real time SVD-based clutter filtering using randomized singular value decomposition and spatial downsampling for micro-vessel imaging on a Verasonics ultrasound system

Singular value decomposition (SVD)-based clutter filters can robustly reject the tissue clutter as compared with the conventional high pass filter-based clutter filters. However, the computational burden of SVD makes real time SVD-based clutter filtering challenging (e.g. frame rate at least 10–15 Hz with region of interest of about 4 × 4 cm2). Recently, we proposed an acceleration method based on randomized SVD (rSVD) clutter filtering and randomized spatial downsampling, which can significantly reduce the computational complexity without compromising the clutter rejection capability. However, this method has not been implemented on an ultrasound scanner and tested for its performance. In this study, we implement this acceleration method on a Verasonics scanner using a multi-core CPU architecture, and evaluate the selections of the imaging and processing parameters to enable real time micro-vessel imaging. The Blood-to-Clutter Ratio (BCR) performance was evaluated on a Verasonics machine with different settings of parameters such as block size and ensemble size. The demonstration of real time process was implemented on a 12-core CPU (downsampling factor of 12, 12-threads in this study) host computer. The processing time of the rSVD-based clutter filter was less than 30 ms and BCRs were higher than 20 dB as the block size, ensemble size and the rank of tissue clutter subspace were set as 30 × 30, 45 and 26 respectively. We also demonstrate that the micro-vessel imaging frame rate of the proposed architecture can reach approximately 22 Hz when the block size, ensemble size and the rank of tissue clutter subspace were set as 20 × 20 pixels, 45 and 26 respectively (using both images and supplementary videos). The proposed method may be important for real time 2D scanning of tumor microvessels in 3D to select and store the most representative 2D view with most abnormal micro-vessels for better diagnosis.

A fast matrix-free elasto-plastic solver for predicting residual stresses in additive manufacturing

Process planning for additive manufacturing (AM) today relies heavily on multi-physics, multi-scale simulation. The focus of this paper is on one aspect of AM simulation, namely, part-level elasto-plastic simulation for residual stress and distortion predictions. This is one of the crucial steps in AM process optimization, but is computationally expensive, often requiring the use of large computer clusters.The primary bottleneck in elasto-plastic simulation is the repeated solution of large linear systems of equations. While there is a wide range of linear solvers, most cannot exploit the unique structured nature of the mesh underlying AM simulation. Here, we revisit a specific matrix-free solver, namely rigid-body deflated solver that has been successfully deployed for solving large linear elastic problems in such scenarios. The salient feature of this solver is that the stiffness matrix is never assembled, thereby reducing the memory requirements significantly, leading to large computational gains.The objective of this paper is to extend the above solver to elasto-plasticity by efficiently updating the element tangent stiffness matrices, and the corresponding deflation matrix. The performance of the proposed method is evaluated on a benchmark problem using multi-core CPU and GPU architectures, and compared against ANSYS. Then, part-level residual stresses and distortion are predicted using the proposed solver. The present work is restricted to associative plasticity with von-Mises yield criteria, but can be extended to other plasticity models.

Parallelizing Word2Vec in Shared and Distributed Memory

Word2vec is a widely used algorithm for extracting low-dimensional vector representations of words. State-of-the-art algorithms including those by Mikolov et al. [1] , [2] have been parallelized for multi-core CPU architectures, but are based on vector-vector operations with “Hogwild” updates that are memory-bandwidth intensive and do not efficiently use computational resources. In this paper, we propose “HogBatch” by improving reuse of various data structures in the algorithm through the use of minibatching and negative sample sharing, hence allowing us to express the problem using matrix multiply operations. We also explore different techniques to distribute word2vec computation across nodes in a computer cluster, and demonstrate good strong scalability up to 32 nodes. The new algorithm is particularly suitable for modern multi-core/many-core architectures, especially Intel's latest Knights Landing processors, and allows us to scale up the computation near linearly across cores and nodes, and process hundreds of millions of words per second, which is the fastest word2vec implementation to the best of our knowledge. We released the source code for reproducible research and general usage.