Multithreaded Computation Research Articles

An improved method planning path of an autonomous ground robot with using the MBD-RRT*FFT algorithm

The study analyzed the problems associated with planning the path of robots and increasing the accuracy and reliability of their guidance in real time. To solve this problem, a practical study was conducted, based on the obtained analysis, a modification of the asymptotically optimal BD-RRT*FT algorithm and was proposed and improved the MBD-RRT*FFT algorithm. was developed. Which, when applied in dynamic environments due to the use of multi-threaded computations, has better dynamic scheduling capabilities, and the use of Fitch's optimal search result selection algorithm provides a general tendency to choose the optimal straight-line path. To verify the effectiveness of the proposed algorithm improvement method, simulations were carried out using our own simulation program. A comparison of the MBD-RRT*FFT algorithm with other algorithms was carried out on three maps with an evaluation of performance indicators. In order to evaluate the behavior of the program, as well as to identify bottlenecks in the execution of the algorithm, the memory load of the decision-making system was monitored at all stages of the verification. This made it possible to see an increase in the consumption of memory resources by 12-15%, but taking into account the obtained results regarding the optimality and speed of calculations, conclusions were made regarding the minimal impact. Additional understanding of the need for careful selection of the hardware component of decision-making systems is provided. The scientific novelty of the method consists in the application of a scientific and methodological apparatus for improving the BD-RRT*FT algorithm, which ensured further development in terms of expanding and supplementing known data on algorithms with robot path planning and increasing accuracy and reliability in real time. The method includes methods of research, systematization and adjustment of new and previously acquired knowledge.

An extension to Voro++ for multithreaded computation of Voronoi cells

Voro++ is a software library written in C++ for computing the Voronoi tessellation, a technique in computational geometry that is widely used for analyzing systems of particles. Voro++ was released in 2009 and is based on computing the Voronoi cell for each particle individually. Here, we take advantage of modern computer hardware, and extend the original serial version to allow for multithreaded computation of Voronoi cells via the OpenMP application programming interface. We test the performance of the code, and demonstrate that it can achieve parallel efficiencies greater than 95% in many cases. The multithreaded extension follows standard OpenMP programming paradigms, allowing it to be incorporated into other programs. We provide an example of this using the VoroTop software library, performing a multithreaded Voronoi cell topology analysis of up to 102.4 million particles. Program summaryProgram title:Voro++CPC Library link to program files:https://doi.org/10.17632/tddc4w4zkk.1Developer's repository link:https://github.com/chr1shr/voroLicensing provisions: BSD 3-clause (with LBNL modification)Programming language: C++External routines/libraries: OpenMPNature of problem: Multithreaded computation of the Voronoi tessellation in two and three dimensionsSolution method: The Voro++ library is built around several C++ classes that can be incorporated into other programs. The two largest components are the container... classes that spatially sort input particles into a grid-based data structure, allowing for efficient searches of nearby particles, and the voronoicell... classes that represent a single Voronoi cell as an arbitrary convex polygon or polyhedron. The Voronoi cell for each particle is built by considering a sequence of plane cuts based on neighboring particles, after which many different statistics (e.g. volume, centroid, number of vertices) can be computed. Since each Voronoi cell is calculated individually, the Voronoi cells can be computed using multithreading via OpenMP.

Implementation of ADE-CFS-PML for the Single Field WCS-FDTD Method

In this letter, the auxiliary differential equation (ADE) form of the complex-frequency-shifted perfectly matched layer (CFS-PML) is implemented for the single field (SF) weakly conditionally stable (WCS) finite difference time domain (FDTD) method. The magnetic field terms in the auxiliary variables of ADE-CFS-PML are eliminated, conforming to the SF formulation. The reflection error and stability of the proposed method is verified with numerical examples. Results show that the proposed method is stable and features low reflection error when the maximum time step is chosen for the SF-WCS-FDTD method. The higher multithread computation efficiency of the proposed method is also demonstrated.

The efficiency of multithreaded computing in casting simulation software

The utilization of computer simulation software for casting process simulation is becoming essential in the advancement of casting technology in aviation and other high-tech engineering fields. With the increase in the number of computational cores in modern CPUs, the use of multi-threaded computations is becoming increasingly relevant. In this study, the efficiency of multi-threaded computations in modeling casting processes was evaluated using finite element method casting simulation software ProCast and PoligonSoft, which utilize parallel computing architectures with distributed (DMP) and shared (SMP) memory, respectively. Computations were performed on Intel and AMD-based computers, varying the number of computational threads from 4 to 32. The calculation efficiency was evaluated by measuring the calculation speed increase in the filling and solidification of GP25 castings made of ML10 alloy, as well as the complex task of filling and solidification modeling nickel superalloy casing castings with radiation heat transfer simulation. The results indicate that the minimum computation time in ProCast software is observed when using 16 computational threads. This pattern holds true for both computing systems (Intel and AMD processors), and increasing the number of threads beyond this point does not make a practical difference. The performance decrease in this scenario can be attributed to the low-performance energy-efficient cores in systems based on Intel processors or the decrease in core frequency and full loading of physical cores in systems based on AMD processors. Multi-threading the modeling task in PoligonSoft software is less efficient than in ProCast, which is a result of the shared-memory architecture used in PoligonSoft. Despite the significant difference in parallel efficiency, the task of GP25 casting solidification in both PoligonSoft and ProCast is solved in a time close enough to be considered sufficient.

Sim[formula omitted]PIM: A complete simulation framework for Processing-in-Memory

With the help of modern memory integration technologies, Processing-in-Memory (PIM) has emerged as a practical approach to mitigate the memory wall while improving performance and energy efficiency in contemporary applications. Since these designs encompass accelerating and increasing the efficiency of critical specific and general-purposed applications, it is expected that these accelerators will be coupled to existing systems and consequently with systems capable of multi-thread computing. However, there is a lack of tools capable of quickly simulating different PIMs designs and their suitable integration with other hosts. This gap is even worse when considering simulations of multi-core systems. This work presents Sim2PIM, a Simple Simulator for PIM devices that seamlessly integrates any PIM architecture with the host processor and memory hierarchy. The framework simulation achieves execution speeds and accuracy on par with the perf tool on host code, less than 10% run-time overhead, and around 2% difference in metrics. Additionally, by exploring the thread parallelism in the application and utilizing the host hardware, Sim2PIM can achieve more than 8× simulation speedup compared to a sequential simulation and orders of magnitude compared to other simulators. Sim2PIM is available to download at https://pim.computer/.

Simulation modeling of a computer system multithreaded architecture using AnyLogic

The simulation is the most effective way to investigate information processing in computer systems. Computer system simulation is advantageous due to the fact, that such class of systems are well formalized in the form of queuing systems. Any computer system can be considered in terms of queuing system theory as an interconnected set of requests for service, system re-sources, queues to resources, and rules of service. The problem with the study of computer systems is that the existing simulation software tools have been developed as universal tools for the study of general-purpose systems. There are no specialized libraries or separate modeling tools for the study of computer systems. Therefore, modeling computer systems based on the use of standard libraries of such a modern modeling tool as AnyLogic, and the possible creation of elements of a specialized library is of great importance. The objective of the paper is to model multithreaded computing in a multiprocessor computer system using AnyLogic software. The designed computer system diagram enables us to have a deep insight into all details of information processing, and the obtained characteris-tics of the computer system, such as CPU usage coefficients, queue dynamics, distribution of thread execution time in the system, etc., allow us to determine the most effective configuration of the system, the parameters of its elements and operation modes.

The Algorithm of Angular Superresolution Using the Cholesky Decomposition and its Implementation Based on Parallel Computing Technology

An algorithm of angular superresolution based on the Cholesky decomposition, which is a modification of the Capon algorithm, is proposed. It is shown that the proposed algorithm makes it possible to abandon the inversion of the covariance matrix of input signals. The proposed algorithm is compared with the Capon algorithm by the number of operations. It is established that the proposed algorithm, with a large dimension of the problem, provides some gain both when implemented on a single-threaded and multithreaded computer. Numerical estimates of the performance of the proposed and original algorithm using parallel computing technology CUDA NVidia are obtained. It is established that the proposed algorithm saves GPU computing resources and is able to solve the problem of constructing a spatial spectrum with an increase in the dimension of the covariance matrix of input signals by almost two times.

A Tightly-Coupled Framework for Large-Scale Map Construction With Multiple Non-Repetitive Scanning LiDARs

With the ability of providing direct and accurate enough range measurements, light detection and ranging (LiDAR) is playing an essential role in localization and detection for autonomous vehicles. Since single LiDAR suffers from hardware failure and performance degradation intermittently, we present a multi-LiDAR integration scheme in this article. Our framework tightly couples multiple non-repetitive scanning LiDARs with inertial, encoder, and global navigation satellite system (GNSS) into pose estimation and simultaneous global map generation. Primarily, we formulate a precise synchronization strategy to integrate isolated sensors, and the extracted feature points from separate LiDARs are merged into a single sweep. The fused scans are introduced to compute the scan-matching correspondences, which can be further refined by additional real-time kinematic (RTK) measurements. Based thereupon, we construct a factor graph along with the inertial preintegration result, estimated ground constraints, and RTK data. For the purpose of maintaining a restricted number of poses for estimation, we deploy a keyframe based sliding-window optimization strategy in our system. The real-time performance is guaranteed with multi-threaded computation, and extensive experiments are conducted in challenging scenarios. Experimental results show that the utilization of multiple LiDARs boosts the system performance in both robustness and accuracy.

Fast Multithreaded Computations System Implemented in ZYNQ Architecture

The paper brings an idea of fast synchronization of multithreaded computations in CPUs. It is dedicated to the implementation of multi-context PLC control or simulation tasks obtained by a dedicated automatic compiler. The synchronization mechanism is implemented as guarded memory cells that enable fast data exchange and seamless synchronization of mutually bounded processing threads. The idea has been verified using Xilinx PSoC ZYNQ architecture. Proposed mechanisms enhance the scheduling of computation tasks and significantly simplify implementing synchronization. The essential idea is based on a specific memory area with data flow control.

High Performance Computing Environment using General Purpose Computations on Graphics Processing Unit

Here a report of a development phase of an environment of high performance computing (HPC) using general purpose computations on the graphics processing unit (GPGPU) is presented. The HPC environment accommodates computational tasks which demand massive parallelisms or multi-threaded computations. For this purpose, GPGPU is utilized because such tasks require many computing cores running in parallel. The development phase consists of several stages, followed by testing its capabilities and performance. For starters, the HPC environment will be served for computational projects of students and members of the Faculty of Information Technology, Universitas Kristen Maranatha. The goal of this paper is to show a design of a HPC which is capable of running complex and multi-threaded computations. The test results of the HPC show that the GPGPU numerical computations have superior performance than the CPU, with the same level of precision.

MILIOM: Tightly Coupled Multi-Input Lidar-Inertia Odometry and Mapping

In this letter we investigate a tightly coupled Lidar-Inertia Odometry and Mapping (LIOM) scheme, with the capability to incorporate multiple lidars with complementary field of view (FOV). In essence, we devise a time-synchronized scheme to combine extracted features from separate lidars into a single pointcloud, which is then used to construct a local map and compute the feature-map matching (FMM) coefficients. These coefficients, along with the IMU preinteration observations, are then used to construct a factor graph that will be optimized to produce an estimate of the sliding window trajectory. We also propose a key frame-based map management strategy to marginalize certain poses and pointclouds in the sliding window to grow a global map, which is used to assemble the local map in the later stage. The use of multiple lidars with complementary FOV and the global map ensures that our estimate has low drift and can sustain good localization in situations where single lidar use gives poor result, or even fails to work. Multi-thread computation implementations are also adopted to fractionally cut down the computation time and ensure real-time performance. We demonstrate the efficacy of our system via a series of experiments on public datasets collected from an aerial vehicle.

ВЫЯВЛЕНИЕ СКРЫТЫХ УЯЗВИМОСТЕЙ В ИСХОДНОМ КОДЕ МНОГОПОТОЧНЫХ ПРОГРАММ ПОСРЕДСТВОМ АНАЛИЗА ФУНКЦИОНАЛЬНЫХ ПЕРЕХОДОВ

The article presents a new set-theoretic model and procedures that reduce the time required to detect hidden vulnerabilities in the source code of multi-threaded computer programs, as well as the results of mathematical modeling. Hidden vulnerabilities in the article are under-stood as vulnerabilities leading to data races and deadlocks, since they have a stochastic nature of manifestation during testing, which greatly complicates their identification. The presented model describes the state of each thread of a multi-threaded computer program currently exe-cuting a function and the contents of the function call stack. At the same time, it remains pos-sible to use the model in verification by the Model Checking method, and also eliminates the need to solve the problem of searching for the model invariant. The presented procedures make it possible to formulate specifications for the verification method on models, the implementa-tion of which makes it possible to identify vulnerabilities leading to data races and deadlocks in the source code of multithreaded programs

A Fast and Power-Efficient Hardware Architecture for Non-Maximum Suppression

Non-maximum suppression (NMS) is an indispensable post-processing step in face detection. The vast majority of face detection methods need NMS to merge the candidate detected face boxes that belong to the same face. However, the standard NMS is a greedy and local optimization technique which suffers from several shortcomings, such as high complexity ( ${O}$ ( ${N} ^{\boldsymbol {2}}$ )), high latency, and large power consumption. This brief alleviates these problems and presents an efficient hardware architecture for NMS, meanwhile, carries out the optimization for the calculation unit to achieve the reduction of area accordingly. Based on the multi-thread computing, this brief utilizes sliding window to obtain parallelism and uses position-based bit table technique for the enhancement of data accessing and data reusing, which greatly decreases the cost of memory access and power consumption. The proposed hardware architecture is implemented in TSMC 28-nm technology. Experiments show that the power consumption is 6.142 mW and the latency is 12.79 $ {\mu }\text{s}$ to cluster 1000 candidate boxes, whose energy efficiency is higher than those state-of-the-art methods by $3798 {\times }$ and $358 {\times }$ , respectively.

Cooperative scheduling of multi‐core and cloud resources: multi‐thread‐based MCC offloading strategy

Modern multi-core mobile devices are the main application objects of mobile cloud computing (MCC). In previous works, researchers have formulated various heuristic algorithms to solve the NP problem. This work combines MCC with multi-threaded computing (MTC) of multi-core mobile devices to avoid NP problems and proposes an MTC-based MCC offloading strategy. First, the authors design an MTC strategy for the application model of cloud computing. Then, they use the data transmission scheme that is dynamically adjusted according to the fading channel state. Finally, based on the MTC strategy and the optimal data transmission scheme, they obtain the MTC-based MCC offloading strategy through a linear time searching algorithm. Simulation results show that compared with the local MTC strategy and the single-threaded MCC offloading strategy, the MTC-based MCC offloading strategy can significantly reduce energy consumption and improve the computing ability in multi-threaded applications.

IMAge/enGINE: a freely available software for rapid computation of high-dimensional quantification.

High-dimensional image data including diffusion weighted imaging, diffusion tensor imaging and dynamic imaging are important in exploring the connectivity, cellularity, pharmacokinetic and blood supply. IMAge/enGINE is software especially designed for high-dimensional medical image computing. IMAge/enGINE is implemented based on open-source and cross-platform tools such as Qt, ITK and VTK. It processes the high-dimensional image data in a slice-by-slice computation mechanism. For computational efficiency, C++ is used for implementing IMAge/enGINE and multi-thread computing is handled in the scale of voxels. The architecture of IMAge/enGINE is modularized for easier extension. IMAge/enGINE has following features: (I) IMAge/enGINE is free for research use; (II) it has an easy-to-use graphic user interface designed for clinical users without programming or engineering background; (III) its frame work is open-source and extensible. Developers can implement algorithms as modules and integrate them into IMAge/enGINE or generate their own application. The source of IMAge/enGINE is hosted at https://github.com/VusionMed/IMAge-enGINE. Multiple diffusion and perfusion models are implemented and integrated into IMAge/enGINE and its binaries can be downloaded freely at http://www.vusion.com.cn/?page_id=14971.

The Event Buffer Management for MT-SNiPER

SNiPER is a general purpose offline software framework for high energy physics experiment. It provides some features that are attractive to neutrino experiments, such as the event buffer. More than one events are available in the buffer according to a customizable time window, so that it is easy for users to apply events correlation analysis. We also implemented the MT-SNiPER to support multithreading computing based on Intel TBB. In MT-SNiPER, the event loop is split into pieces, and each piece is dispatched to a task. The global buffer, an extension and enhancement to the event buffer, is implemented for MT-SNiPER. The global buffer is available by all threads. It keeps all the events being processed in memory. When there is an available task, a subset of its events is dispatched to that task. There can be overlaps between the subsets in different tasks due to the time window. However, it is ensured that each event is processed only once. In the task side, the subsets of events are locally managed by a normal event buffer. So the global buffer can be transparent to most user algorithms. Within the global buffer, the multithreading computing of MT-SNiPER becomes more practicable.

A cross-platform parallel programming model for fluid-film lubrication optimization

PurposeA cross-platform paradigm (computing model), which combines the graphical user interface of MATLAB and parallel Fortran programming, for fluid-film lubrication analysis is proposed. The purpose of this paper is to take the advantages of effective multithreaded computing of OpenMP and MATLAB’s user-friendly interface and real-time display capability.Design/methodology/approachA validation of computing performance of MATLAB and Fortran coding for solving two simple sliders by iterative solution methods is conducted. The online display of the particles’ search process is incorporated in the MATLAB coding, and the execution of the air foil bearing optimum design is conducted by using OpenMP multithreaded computing in the background. The optimization analysis is conducted by particle swarm optimization method for an air foil bearing design.FindingsIt is found that the MATLAB programs require prolonged execution times than those by using Fortran computing in iterative methods. The execution time of the air foil bearing optimum design is significantly minimized by using the OpenMP computing. As a result, the cross-platform paradigm can provide a useful graphical user interface. And very little code rewritting of the original numerical models is required, which is usually optimized for either serial or parallel computing.Research limitations/implicationsIterative methods are commonly applied in fluid-film lubrication analyses. In this study, iterative methods are used as the solution methods, which may not be an effective way to compute in the MATLAB’s setting.Originality/valueIn this study, a cross-platform paradigm consisting of a standalone MATLAB and Fortran codes is proposed. The approach combines the best of the two paradigms and each coding can be modified or maintained independently for different applications.

Automated test generation for optimizing compilers with OpenMP support

The correctness of the compiler is a necessary requirement for the correct operation of the software compiled by it. Therefore, the most important stage in the development of the compiler is verification. Recent widespread of multi-core processors and graphics core integrated to CPU emphasized the problem of the transition from single-threaded to multi-threaded computing and re-usage of graphics core for general purpose heterogeneous parallel computations in particular. In this paper, we are presenting an approach to automate test creation for the verification of the compiler with OpenMP support, based on a generator that uses grammars to generate syntactically correct executable tests.

Large Scale Document Inversion using a Multi-threaded Computing System.

•Information systems➝Information retrieval • Computing methodologies➝Massively parallel and high-performance simulations.

Protein database search of hybrid alignment algorithm based on GPU parallel acceleration

In biological research, alignment of protein sequences by computer is often needed to find similarities between them. Although results can be computed in a reasonable time for alignment of two sequences, it is still very central processing unit (CPU) time-consuming when solving massive sequences alignment problems such as protein database search. In this paper, an optimized protein database search method is presented and tested with Swiss-Prot database on graphic processing unit (GPU) devices, and further, the power of CPU multi-threaded computing is also involved to realize a GPU-based heterogeneous parallelism. In our proposed method, a hybrid alignment approach is implemented by combining Smith–Waterman local alignment algorithm with Needleman–Wunsch global alignment algorithm, and parallel database search is realized with compute unified device architecture (CUDA) parallel computing framework. In the experiment, the algorithm is tested on a lower-end and a higher-end personal computers equipped with GeForce GTX 750 Ti and GeForce GTX 1070 graphics cards, respectively. The results show that the parallel method proposed in this paper can achieve a speedup up to 138.86 times over the serial counterpart, improving efficiency and convenience of protein database search significantly.