Multi-threaded Algorithm Research Articles

AI for Cloud Cost Management: Predictive and Prescriptive Analytics

With reference to the previous information and literature review, the purpose of this research paper is to evaluate the impact of multithreading concerning computer resource utilization and performance by undertaking and comparing various crucial multithreading techniques, including work stealing, fork join, and the use of the thread pool control. In an experimental context, benchmark applications that can be characteristic of several domains were evaluated in a controlled multicore computing platform. Time, CPU occupation, memory usage and throughputs were determined systematically and compared according to the various workloads. The results highlight the superiority of the work-steing algorithm in keeping the execution time and CPU usage low compared to the rest as a sign of its efficiency in managing work loads. Further, the memory usage and the throughput statistics showed the degree of inefficiency of each algorithm and performance penalty. Interviews with developers elaborated on more practical issues of multithreading as the generally rigid nature of the problems suggested that optimal solutions called for adaptive measures in practice. Based on the results achieved in this research, developers and researchers can increase their knowledge about available multithreading algorithms and make suggestions to choose and apply them with high efficiency and low resource consumption.

Multithreading-Based Algorithm for High-Performance Tchebichef Polynomials with Higher Orders

Tchebichef polynomials (TPs) play a crucial role in various fields of mathematics and applied sciences, including numerical analysis, image and signal processing, and computer vision. This is due to the unique properties of the TPs and their remarkable performance. Nowadays, the demand for high-quality images (2D signals) is increasing and is expected to continue growing. The processing of these signals requires the generation of accurate and fast polynomials. The existing algorithms generate the TPs sequentially, and this is considered as computationally costly for high-order and larger-sized polynomials. To this end, we present a new efficient solution to overcome the limitation of sequential algorithms. The presented algorithm uses the parallel processing paradigm to leverage the computation cost. This is performed by utilizing the multicore and multithreading features of a CPU. The implementation of multithreaded algorithms for computing TP coefficients segments the computations into sub-tasks. These sub-tasks are executed concurrently on several threads across the available cores. The performance of the multithreaded algorithm is evaluated on various TP sizes, which demonstrates a significant improvement in computation time. Furthermore, a selection for the appropriate number of threads for the proposed algorithm is introduced. The results reveal that the proposed algorithm enhances the computation performance to provide a quick, steady, and accurate computation of the TP coefficients, making it a practical solution for different applications.

Дослідження проблем синхронізації та захисту даних при реалізації багатопоточних програм

The issue of shared data usage by threads is especially relevant in modern multi-core and multiprocessor systems. The main problems of implementing multithreaded programs are race conditions, deadlocks, and thread starvation. The aim of the work is to solve the problem of thread racing in multithreaded calculations of resource-intensive tasks with parallel access to shared data using appropriate synchronization mechanisms, such as mutexes. A multithreaded algorithm for implementing a typical task of processing large data arrays with protection of the critical area in concurrent programs running on multiprocessor and multi-core systems has been developed and researched.

Parallel multithreaded deduplication of data sequences in nuclear structure calculations

High performance computing (HPC) applications that work with redundant sequences of data can benefit from their deduplication. We study this problem on the symmetry-adapted no-core shell model (SA-NCSM), where redundant sequences of different kinds naturally emerge in the data of the basis of the Hilbert space physically relevant to a modeled nucleus. For a fast solution of this problem on multicore architectures, we propose and present three multithreaded algorithms, which employ either concurrent hash tables or parallel sorting methods. Furthermore, we present evaluation and comparison of these algorithms based on experiments performed with real-world SA-NCSM calculations. The results indicate that the fastest option is to use a concurrent hash table, provided that it supports sequences of data as a type of table keys. If such a hash table is not available, the algorithm based on parallel sorting is a viable alternative.

Single Lead EMG signal to Control an Upper Limb Exoskeleton Using Embedded Machine Learning on Raspberry Pi

Post-stroke can cause partial or complete paralysis of the human limb. Delayed rehabilitation steps in post-stroke patients can cause muscle atrophy and limb stiffness. Post-stroke patients require an upper limb exoskeleton device for the rehabilitation process. Several previous studies used more than one electrode lead to control the exoskeleton. The use of many electrode leads can lead to an increase in complexity in terms of hardware and software. Therefore, this research aims to develop single lead EMG pattern recognition to control an upper limb exoskeleton. The main contribution of this research is that the robotic upper limb exoskeleton device can be controlled using a single lead EMG. EMG signals were tapped at the biceps point with a sampling frequency of 2000 Hz. A Raspberry Pi 3B+ was used to embed the data acquisition, feature extraction, classification and motor control by using multithread algorithm. The exoskeleton arm frame is made using 3D printing technology using a high torque servo motor drive. The control process is carried out by extracting EMG signals using EMG features (mean absolute value, root mean square, variance) further extraction results will be trained on machine learning (decision tree (DT), linear regression (LR), polynomial regression (PR), and random forest (RF)). The results show that machine learning decision tree and random forest produce the highest accuracy compared to other classifiers. The accuracy of DT and RF are of 96.36±0.54% and 95.67±0.76%, respectively. Combining the EMG features, shows that there is no significant difference in accuracy (p-value 0.05). A single lead EMG electrode can control the upper limb exoskeleton robot device well.

Multi-Threaded Sound Propagation Algorithm to Improve Performance on Mobile Devices

We propose a multi-threaded algorithm that can improve the performance of geometric acoustic (GA)-based sound propagation algorithms in mobile devices. In general, sound propagation algorithms require high computational cost because they perform based on ray tracing algorithms. For this reason, it is difficult to operate sound propagation algorithms in mobile environments. To solve this problem, we processed the early reflection and late reverberation steps in parallel and verified the performance in four scenes based on eight sound sources. The experimental results showed that the performance of the proposed method was on average 1.77 times better than that of the single-threaded method, demonstrating that our algorithm can improve the performance of mobile devices.

Movement Optimization for a Cyborg Cockroach in a Bounded Space Incorporating Machine Learning

Cockroaches can traverse unknown obstacle-terrain, self-right on the ground and climb above the obstacle. However, they have limited motion, such as less activity in light/bright areas and lower temperatures. Therefore, the movement of the cyborg cockroaches needs to be optimized for the utilization of the cockroach as a cyborg insect. This study aims to increase the search rate and distance traveled by cockroaches and reduce the stop time by utilizing automatic stimulation from machine learning. Multiple machine learning classifiers were applied to classify the offline binary classification of the cockroach movement based on the inertial measuring unit input signals. Ten time-domain features were chosen and applied as the classifier inputs. The highest performance of the classifiers was implemented for the online motion recognition and automatic stimulation provided to the cerci to trigger the free walking motion of the cockroach. A user interface was developed to run multiple computational processes simultaneously in real time such as computer vision, data acquisition, feature extraction, automatic stimulation, and machine learning using a multithreading algorithm. On the basis of the experiment results, we successfully demonstrated that the movement performance of cockroaches was importantly improved by applying machine learning classification and automatic stimulation. This system increased the search rate and traveled distance by 68% and 70%, respectively, while the stop time was reduced by 78%.

Teleoperated Locomotion for Biobot between Japan and Bangladesh

Biobot-based insects have been investigated so far for various applications such as search and rescue operations, environmental monitoring, and discovering the environment. These applications need a strong international collaboration to complete the tasks. However, during the COVID-19 pandemic, most people could not easily move from one country to another because of the travel ban. In addition, controlling biobots is challenging because only experts can operate the cockroach behavior with and without stimulated response. In order to solve this issue, we proposed a user-friendly teleoperation user interface (UI) to monitor and control the biobot between Japan and Bangladesh without onsite operation by experts. This study applied Madagascar hissing cockroaches (MHC) as a biobot hybrid robot. A multithreading algorithm was implemented to run multiple parallel computations concurrently on the UI. Virtual network computing (VNC) was implemented on the teleoperation UI as remote communication for streaming real-time video from Japan to Bangladesh and sending remote commands from Bangladesh to Japan. In the experiments, a remote operator successfully steered the biobot to follow a predetermined path through a developed teleoperation UI with a time delay of 275 ms. The proposed interactive and intuitive UI enables a promising and reliable system for teleoperated biobots between two remote countries.

Embedded Machine Learning Using a Multi-Thread Algorithm on a Raspberry Pi Platform to Improve Prosthetic Hand Performance.

High accuracy and a real-time system are priorities in the development of a prosthetic hand. This study aimed to develop and evaluate a real-time embedded time-domain feature extraction and machine learning on a system on chip (SoC) Raspberry platform using a multi-thread algorithm to operate a prosthetic hand device. The contribution of this study is that the implementation of the multi-thread in the pattern recognition improves the accuracy and decreases the computation time in the SoC. In this study, ten healthy volunteers were involved. The EMG signal was collected by using two dry electrodes placed on the wrist flexor and wrist extensor muscles. To reduce the complexity, four time-domain features were applied to extract the EMG signal. Furthermore, these features were used as the input of the machine learning. The machine learning evaluated in this study were k-nearest neighbor (k-NN), Naive Bayes (NB), decision tree (DT), and support vector machine (SVM). In the SoC implementation, the data acquisition, feature extraction, machine learning, and motor control process were implemented using a multi-thread algorithm. After the evaluation, the result showed that the pairing of the MAV feature and machine learning DT resulted in higher accuracy among other combinations (98.41%) with a computation time of ~1 ms. The implementation of the multi-thread algorithm in the pattern recognition system resulted in significant impact on the time processing.

Optimizing weighted gene co-expression network analysis with a multi-threaded calculation of the topological overlap matrix.

Biomolecular networks are often assumed to be scale-free hierarchical networks. The weighted gene co-expression network analysis (WGCNA) treats gene co-expression networks as undirected scale-free hierarchical weighted networks. The WGCNA R software package uses an Adjacency Matrix to store a network, next calculates the topological overlap matrix (TOM), and then identifies the modules (sub-networks), where each module is assumed to be associated with a certain biological function. The most time-consuming step of WGCNA is to calculate TOM from the Adjacency Matrix in a single thread. In this paper, the single-threaded algorithm of the TOM has been changed into a multi-threaded algorithm (the parameters are the default values of WGCNA). In the multi-threaded algorithm, Rcpp was used to make R call a C++ function, and then C++ used OpenMP to start multiple threads to calculate TOM from the Adjacency Matrix. On shared-memory MultiProcessor systems, the calculation time decreases as the number of CPU cores increases. The algorithm of this paper can promote the application of WGCNA on large data sets, and help other research fields to identify sub-networks in undirected scale-free hierarchical weighted networks. The source codes and usage are available at https://github.com/do-somethings-haha/multi-threaded_calculate_unsigned_TOM_from_unsigned_or_signed_Adjacency_Matrix_of_WGCNA.

Performance evaluation of GPU- and cluster-computing for parallelization of compute-intensive tasks

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

Parallel algorithm development and testing using Petri-object simulation

Parallel algorithms are problematic to develop because of the negative influence of synchronisation, complicated behaviour of threads’ capturing computing resources. Experimental results show performance time’s strong dependence on algorithm parameters, such as the number of subtasks and the complexity of each task. The optimal value of subtask complexity is revealed for the particular algorithm. It is the same for different complexity of the parallelised task (with the same computing resource). To guarantee algorithm speed-up it is important to have a method for investigating the efficiency of parallel algorithm before its implementation on specified computing resources. Stochastic Petri net potentially could be a high accuracy tool for investigating the efficiency of a parallel algorithm. However, a huge number of elements are needed to compose a model of non-trivial algorithm that limits the application of this tool in practice. Petri-object simulation method allows replication of Petri nets with specified parameters and model creation of a list of linked Petri-objects. Basic templates for the model creation of a multithreaded algorithm are developed. Applying these templates, the model of the parallel discrete event simulation algorithm is developed and investigated. By the model results, the algorithm parameters providing the least performance time can be determined.

SparkDQ: Efficient generic big data quality management on distributed data-parallel computation

In the big data era, large amounts of data are under generation and accumulation in various industries. However, users usually feel hindered by the data quality issues when extracting values from the big data. Thus, data quality issues are gaining more and more attention from data quality management analysts. Cutting-edge solutions like data ETL, data cleaning, and data quality monitoring systems have many deficiencies in capability and efficiency, making it difficult to cope with complicated situations on big data. These problems inspire us to build SparkDQ, a generic distributed data quality management model and framework that provides a series of data quality detection and repair interfaces. Users can quickly build custom tasks of data quality computing for various needs by utilizing these interfaces. In addition, SparkDQ implements a set of algorithms that in a parallel manner with optimizations. These algorithms aim at various data quality goals. We also propose several system-level optimizations, including the job-level optimization with multi-task execution scheduling and the data-level optimization with data state caching. The experimental evaluation shows that the proposed distributed algorithms in SparkDQ run up to 12 times faster compared to the corresponding stand-alone serial and multi-thread algorithms. Compared with the cutting-edge distributed data quality solution Apache Griffin, SparkDQ has more features, and its execution time is only around half of Apache Griffin on average. SparkDQ achieves near-linear data and node scalability.

Multi-threaded parallel projection tetrahedral algorithm for unstructured volume rendering

Volume rendering methods have been extensively studied in recent years due to their effectiveness and expressiveness for unstructured grid data visualization. Although existing volume rendering methods have demonstrated great success, we observe that these methods have extensive interpolation and integral operations, which may adversely affect their efficiency and further prevent them being applied in interactive visualization. To boost efficiency and achieve interactive rendering rates, we propose a novel multi-threaded parallel projection tetrahedral algorithm based on multi-core architecture. By analyzing the parallelism of volume rendering methods, we find that the visibility sorting and classification/decomposition of projection polygons are the most time-consuming parts. To reduce the execution time of these two parts, we design corresponding parallel methods. In this manner, our method can dramatically improve efficiency and further enable user interactions for progressive unstructured grid analysis. The visibility sorting part includes partial sorting and global sorting: In partial sorting, we partition disordered tetrahedral depth array and obtain several loosely coupled subarrays, and in global sorting, we sort each subarray with multi-threads technique. In the classification/decomposition of projection polygons part, we normalize tetrahedral projection to ensure arbitrary tetrahedral produces the same number of triangles, and then store the produced vertex data into vertex array with offset computation that ensures correct order for the multi-threads runtime. The experimental results show that the proposed multi-threaded projection tetrahedral algorithm can achieve a speedup of 3.4X on a 20 cores CPU and outperforms the fastest VTK implementation at a speedup of 2.5X, which verifies the efficiency of our algorithm.

A new contact detection method for arbitrary dilated polyhedra with potential function in discrete element method

SummaryContact detection significantly affects the computational efficiency of discrete element simulations, especially for irregularly shaped elements. The dilated polyhedron is constructed by the Minkowski sum of a dilated sphere and a core convex polyhedron. One of the greatest advantages of using the dilated polyhedron in contact detection lies in its ability to be solved by calculating the nearest distance between corresponding core polyhedra. The approximate envelope function (AEF) of a dilated polyhedron is formed by the weighted summation of the second‐order dilated function of the polyhedral and spherical functions. The AEF can be used to represent the element in the optimization model for the contact center. Geometric calculations are then employed for the contact points on the core polyhedron, whereupon the contact detection is solved. The accuracy and stability of the proposed method by a 3‐D Voronoi tessellation are validated using analytical solutions and previously published simulation results. The efficiency tests show that the speedup of the CPU‐based multithread algorithm can reach 14 on a desktop. The direct shear test of the Voronoi shaped ballast is analyzed by this method. The shear stress under different vertical pressure is compared with previously published experimental and simulated results.

μ𝜃-EGF: A New Multi-Thread and Nature-Inspired Algorithm for the Packing Problem

In this paper, the authors present a new algorithm efficient solution to the packing problem in two dimensions. The authors propose a new heuristic using the value of the electromagnetic field to determine the best position to place a circular object in a configuration of other circular objects previously packed. Also, this algorithm simulates two processes to compact objects already placed, inspired by gravitational forces, to minimize the empty space in the container and maximizing the number of objects in the container. To determine the efficacy of this algorithm, the authors carried out experiments with twenty-four instances. Parallel computing can contribute to making decision processes such as optimization and prediction more agile and faster. Real-time decision making involves the use of solution methodologies and algorithms. For this reason the present manuscript shows an alternative for the solution of a classic industry problem that must be solved quickly. Packaging optimization can help reduce waste of container material. The material used to transport the products can reduce its environmental impact due to an efficient packaging process. Light-weighting can also be accomplished by reducing the amount of packaging material used.

A multi-skilled workforce optimisation in maintenance logistics networks by multi-thread simulated annealing algorithms

The sustainability of service and manufacturing operations rely heavily on the availability of equipment and assets. High availability of assets can be achieved with effective maintenance strategies. In this direction, we study a multi-skilled workforce planning problem to establish a resilient maintenance service network for high-value assets. We improve the efficiency of the maintenance network by optimising the workforce capacity in repair shops and achieving workforce heterogeneity by cross-training. As a solution strategy, we develop a two-stage iterative heuristic algorithm. At the first stage, the set of all feasible cross-training policies is effectively and systematically searched via a state-of-art multi-thread simulated annealing (MTSA) metaheuristic to find a policy(ies) that achieves the minimum cost. Further, the developed MTSA algorithm is enhanced with the multi-neighbourhood feature to escape from local optimality and implemented via parallel programming techniques. In the second stage, workforce capacity and spare parts inventory levels are optimised for the cross-training policy found at the first stage by a queuing approximation and a greedy heuristic. The MTSA obtains the lowest cost in 91 cases out of 128 compared to genetic algorithm (GA), variable neighbourhood search (VNS), an improved single-thread simulated annealing algorithm (SA) and integer programming-based clustering (IPBC) algorithms.

Sthread: In-Vivo Model Checking of Multithreaded Programs

This work strives to make formal verification of POSIX multithreaded programs easily accessible to general programmers. Sthread operates directly on multithreaded C/C++ programs, without the need for an intermediate formal model. Sthread is in-vivo in that it provides a drop-in replacement for the pthread library, and operates directly on the compiled target executable and application libraries. There is no compiler-generated intermediate representation. The system calls in the application remain unaltered. Optionally, the programmer can add a small amount of additional native C code to include assertions based on the user's algorithm, declarations of shared memory regions, and progress/liveness conditions. The work has two important motivations: (i) It can be used to verify correctness of a concurrent algorithm being implemented with multithreading; and (ii) it can also be used pedagogically to provide immediate feedback to students learning either to employ POSIX threads system calls or to implement multithreaded algorithms. This work represents the first example of in-vivo model checking operating directly on the standard multithreaded executable and its libraries, without the aid of a compiler-generated intermediate representation. Sthread leverages the open-source SimGrid libraries, and will eventually be integrated into SimGrid. Sthread employs a non-preemptive model in which thread context switches occur only at multithreaded system calls (e.g., mutex, semaphore) or before accesses to shared memory regions. The emphasis is on finding "algorithmic bugs" (bugs in an original algorithm, implemented as POSIX threads and shared memory regions. This work is in contrast to Context-Bounded Analysis (CBA), which assumes a preemptive model for threads, and emphasizes implementation bugs such as buffer overruns and write-after-free for memory allocation. In particular, the Sthread in-vivo approach has strong future potential for pedagogy, by providing immediate feedback to students who are first learning the correct use of Pthreads system calls in implementation of concurrent algorithms based on multithreading.

Implementation of Probability Table Generation Using Ladder Method in Ruler

Probability table is one of the most important and natural methods used to simulate the neutron transport in unresolved resonance range in reactor physics. A new module for generating probability tables in the unresolved-resonance region has been developed for the nuclear data processing code Ruler, using ladder method. In order to validate and verify the accuracy of this module, Probability tables have been calculated and compared with NJOY2016. Agreement is observed in the comparisons of the probability tables and corresponding cross-section values that are calculated by Ruler and NJOY2016. Ruler has improved computational efficiency greatly comparing with NJOY2016 as multi-thread parallel algorithm is applied.

Resource Optimisation using Multithreading in Support Vector Machine

Image processing is one of the most important features for vision-based robotic and being used in various applications to increase productivity. Various researchers reported issues computation problem to detect objects in low cost device such as vision-based robotic car. In the fast-paced development of technology, a system that runs automatically with the right results is essential to the completion of a job. This study aims to propose an effective multithreading for road sign recognition. We implemented multithreading algorithm for train and detector processes in SVM to utilise the multicore CPU and evaluate in various condition on by a Raspberry Pi platform. It aims to solve the real-time computation issue using Pi camera. Experimental results show significant improvement of performance to the detection accuracy. In conclusion multithreading significantly improve the detection performance using Raspberry Pi processors with various image resolution and number of SVM model.