Parallel Tasks Research Articles

On Composing Asynchronous Operations

Asynchronous operations are very useful for actions that wait for an external event or work for a long time, to avoid blocking the thread that launches them. Unfortunately, whether they report their termination via callbacks or via completing a future, composing several asynchronous calls is difficult and error prone. The continuations mechanism (provided, for example, in C# Task Parallel Library via ContinueWith()) offers limited support for scheduling a sequence of operations. In this paper we try to improve this mechanism with better support for sequencing operations and exceptions, and with support for conditionals and loops, while covering the specifics of a C++ implementation. The most recent version of our source code is at [14]. Keywords and phrases: asynchronous programming.

DAG-Order: An Order-Based Dynamic DAG Scheduling for Real-Time Networks-on-Chip

With the high-performance requirement of safety-critical real-time tasks, the platforms of many-core processors with high parallelism are widely utilized, where network-on-chip (NoC) is generally employed for inter-core communication due to its scalability and high efficiency. Unfortunately, large uncertainties are suffered on NoCs from both the overly parallel architecture and the distributed scheduling strategy (e.g., wormhole flow control), which complicates the response time upper bounds estimation (i.e., either unsafe or pessimistic). For DAG-based real-time parallel tasks, to solve this problem, we propose DAG-Order, an order-based dynamic DAG scheduling approach, which strictly guarantees NoC real-time services. First, rather than build the new analysis to fit the widely used best-effort wormhole NoC, DAG-Order is built upon a kind of advanced low-latency NoC with SLT ( S ingle-cycle L ong-range T raversal) to avoid the unpredictable parallel transmission on the shared source-destination link of wormhole NoCs. Second, DAG-Order is a non-preemptive dynamic scheduling strategy, which jointly considers communication as well as computation workloads, and fits SLT NoC. With such an order-based dynamic scheduling strategy, the provably bound safety is ensured by enforcing certain order constraints among DAG edges/vertices that eliminate the execution-timing anomaly at runtime. Third, the order constraints are further relaxed for higher average-case runtime performance without compromising bound safety. Finally, an effective heuristic algorithm seeking a proper schedule order is developed to tighten the bounds. Experiments on synthetic and realistic benchmarks demonstrate that DAG-Order performs better than the state-of-the-art related scheduling methods.

High-speed parallel processing with photonic feedforward reservoir computing.

High-speed photonic reservoir computing (RC) has garnered significant interest in neuromorphic computing. However, existing reservoir layer (RL) architectures mostly rely on time-delayed feedback loops and use analog-to-digital converters for offline digital processing in the implementation of the readout layer, posing inherent limitations on their speed and capabilities. In this paper, we propose a non-feedback method that utilizes the pulse broadening effect induced by optical dispersion to implement a RL. By combining the multiplication of the modulator with the summation of the pulse temporal integration of the distributed feedback-laser diode, we successfully achieve the linear regression operation of the optoelectronic analog readout layer. Our proposed fully-analog feed-forward photonic RC (FF-PhRC) system is experimentally demonstrated to be effective in chaotic signal prediction, spoken digit recognition, and MNIST classification. Additionally, using wavelength-division multiplexing, our system manages to complete parallel tasks and improve processing capability up to 10 GHz per wavelength. The present work highlights the potential of FF-PhRC as a high-performance, high-speed computing tool for real-time neuromorphic computing.

Scaling the Inference of Digital Pathology Deep Learning Models Using CPU-Based High-Performance Computing

Digital pathology whole-slide images (WSIs) are large-size gigapixel images and image analysis based on deep learning artificial intelligence (AI) technology often involves pixel-wise testing of a trained deep learning neural network (DLNN) on hundreds of WSI images, which is time consuming. We take advantage of High-Performance Computing (HPC) facilities to parallelize this procedure into multiple independent (and hence delightfully parallel) tasks. However, traditional software parallelization techniques and regular file formats can have significant scaling problems on HPC clusters. In this work, a useful computational strategy is designed to localize and extract relevant patches in WSI files and group them in HDF5 files well suited for parallel I/O. HPC's array job facilities are adapted for hierarchical scaling and parallelization of WSI pre-processing and testing of trained algorithms. Applying these techniques to testing a trained DLNN on the CAMELYON datasets with 399 WSIs reduced the theoretical processing time of 18 years on a single CPU or 30 days on a single GPU to less than 45 hours on an HPC cluster of 4,000 CPU cores. The efficiency-accuracy trade-off we demonstrated on this dataset further reinforced the importance of efficient computation techniques, without which the accuracy may be sacrificed. The framework developed here for testing DLNNs does not rely on any specific neural network architecture and HPC cluster setup and can be utilized for any large-scale image processing and big-data analysis.

Multiple object tracking using space-time adaptive correlation tracking

<span>In application of tracking and detecting the suspicious activities, multiple object tracking (MOT) has been given fine attention due to its application as it provides the parallel task of identification and tracking of human. MOT ensures the identification and trajectory for each object frame as they interact, despite the changes in its appearance, occlusion and various other tasks involved. Recent adoption of deep learning has given a new perspective but still achieving high metrics remains a major issue to overcome such issues, this research work presents the integrated architecture of deep convolutional covariance networks (DCCNs) and space-time adaptive correlation tracking (STACT) algorithm with similarity map function (SMF). Moreover, in proposed work, DCCNs is utilized for feature extractions through each frame capturing the distinctive information, STACT is tracking approaches that utilizes the SMF for locating and tracking objects. SMFs are updated for any changes in human appearances and motion, also it deals with occlusion. Here the proposed model is evaluated on MOT17 and MOT20 dataset. Performance analysis is carried out through comparing the existing model and Integrated-DCCN achieves higher metrics.</span>

Towards real-world traffic prediction and data imputation: A multi-task pretraining and fine-tuning approach

Real-world traffic prediction is challenging and requires accuracy, efficiency, and generalizability for applications. Most studies used two-step data imputation-prediction procedures or recurrent networks to perform predictions based on imputed data, resulting in error accumulation. Training the same model independently for different missing rates and missing data patterns requires high computational costs. This strategy cannot be integrated with existing methods, causing low generalizability. We propose a multi-task pretraining and fine-tuning (MTPF) approach to address these issues. Specifically, we pretrain an encoder and decoders with different missing data patterns and missing rates and an adversarial noise to learn the correlations between different scenarios and generate robust hidden representations. The encoder and decoder perform fine-tuning for specific missing data scenarios after pretraining. Multiple parallel tasks, including prediction, data imputation, contrastive learning, and adaptive graph learning, are used for pretraining to enable the model to learn the hidden representation for prediction and data imputation during fine-tuning. The MTPF is compared with nine baseline models for prediction and five baseline models for data imputation using two real-world datasets. The experimental results show that MTPF outperforms many state-of-the-art baseline models, has a shorter training time, and is a model-agnostic off-the-shelf plug-in that improves baseline model performance.

Performance analysis of parallel composite service-based applications in clouds

When processing composite service application jobs containing parallel tasks, service providers can optimize their quality of services (QoS) based on refined parallelism settings and resource allocation schemes by leveraging analytical models. However, building such analytical models is particularly challenging due to the fact that an accurate model is required to capture the dependence among sequential or concurrent services and predict response time of each service with varying degrees of parallelism (DoPs). Faced with these challenges, we propose a novel multiclass multi-pool analytical model for composite service applications deployed in clouds. Specifically, we consider embarrassingly parallel services, which do not require additional overhead to split tasks into multiple independent subtasks. We first establish a multi-pool queue network that takes into account the dependence among services and analyze task parameters of each service. To optimize the QoS of embarrassingly parallel services, we present a differentiated parallel processing mechanism which can set varying DoPs for tasks. We also propose an original modulating partition method to predict important performance indicators of each service. By leveraging the proposed model, service providers can obtain optimal settings for the DoPs, resource allocation, and the number of cloud servers, to achieve specific performance levels. Through extensive experiments based on the rendering service dataset and Alibaba’s open cluster traces, we demonstrate that the proposed model can not only provide accurate prediction results but also significantly reduce jobs’ response time by at least 20%.

Relative Marker Omission in Thai: Evidence from Native Speakers’ Acceptability Judgments and Language Transfer

Relative clauses are a well-studied phenomenon in linguistics, giving rise to discoveries about human language. In this study, we consider thîi-less relative clauses in Thai, in which a relative marker may be omitted under certain circumstances. The objectives of the study are to identify native speakers’ conditions of thîi omission and to explore whether knowledge of the conditions is transferred to their relative marker omission in English. Two parallel acceptability judgment tasks in Thai and English were conducted: 437 students from various faculties at Kasetsart University judged the acceptability of thîi-less relative clauses while 233 non-English major students and 83 English major students at the same university judged the acceptability of English marker-less relative clauses. Results showed the most favorable condition for thîi omission is a subject relative clause that modifies a general head noun and contains a non-eventive predicate. Such a structure of a thîi-less relative clause resembles the basic construc­tion of nominal modification, i.e., a noun modified by a phrase. Results also showed the transfer of the thîi omission pattern into English, particularly among students with lower English proficiency. With L1 and L2 supporting data, the study demonstrated that syntax and semantics are determinants of relative marker omission in Thai.

Performance Evaluation on Parallel Speculation-Based Construction of a Binary Search Tree

Binary search trees (BSTs) are one of the most important data structures in the field of computer science. We may easily write a parallel construction program of a BST by extending the sequential algorithm straightly. However, in such conventional approaches, the order of nodes inserted into a BST is determined dynamically, depending on the occasional state of the parallel thread execution. It results in a BST with a different structure (node position) generated on every execution of the parallel program. On the other hand, we have been developing parallel construction schemes of the BST with the same structure as a BST generated by the sequential algorithm. One is the speculatively parallel construction of a BST. And another is the purely (non-speculatively) parallel construction, but it was derived through the concept of thread-level speculation. This paper evaluates the performances of those construction schemes on several types of shared-memory multiprocessors. For the large enough size of BST, our new parallel programs can construct a BST with always the same structure on a little lower or sometimes higher performance than the program that makes a BST with a different structure on every execution. And in contrast with the general expectation that simply enlarging the size of parallel tasks increases misspeculation and damages the performance, we found that it sometimes enhances the performance of speculatively parallel execution.

Design and Blocking Analysis of Locking Protocols for Real-Time DAG Tasks Under Federated Scheduling

Real-time systems require locking protocols to coordinate access to shared resources. With the booming revolution of parallel processing technology in real-time systems, there has been some work addressing the problem of extending classic locking protocols for sequential real-time tasks to parallel tasks. However, it may not be most effective to trivially follow the progress mechanisms and queue orders designed for sequential tasks since the intra-structure information within a parallel task is not taken into consideration. This paper investigates the design of locking protocols for parallel tasks using a novel mechanism -Longest Normal Section First (LNSF) -to consider the impact of normal sections on blocking behavior in parallel tasks and further improve real-time performance. LNSF is then implemented in a locking protocol for parallel tasks named POMIP, and associated blocking analysis techniques are presented. Empirical evaluations show that our proposed analysis dominated other state-of-the-art analysis-in best cases, the acceptance ratio of the task set can be improved by around 17%.

Research on MapReduce Heuristic Multi Table Join Algorithm Based on Binary Optimization and Pancake Parallel Strategy

Background: With the development of technology, the data amount has increased significantly. In data processing, the multi table query is the most frequent operation. Because the join keys cannot correspond one by one, there will be much redundant data transmission, resulting in a waste of network bandwidth. Objective: In order to solve the problems of network overhead and low efficiency, this paper proposes a heuristic multi table join optimization method. By sharing information, the unconnected tuples are eliminated so as to reduce the amount of data transmitting. This shortens response time and improves execution performance. Method: Firstly, the join key information of one table is compressed by the algorithm to make the filtered information for sharing. Then, the concurrent execution is controlled according to the pancake parallel strategy. Finally, the selection strategy of multi table join order is proposed. Results/Discussion: The experiments show that the proposed algorithm can filter a large amount of useless data and improve query efficiency. At the same time, the proposed algorithm reduces a lot of network overhead, improves the algorithm performance, and better solves the problem of low efficiency of multi table join. Conclusion: This paper introduces the heuristic strategy to optimize the algorithm, so that it can perform the join tasks in parallel, which further improves the performance of multi table join. The algorithm creatively combines heuristic data filtering, which greatly improves the quality of data processing. The algorithm is worth popularizing and applying.

3D Visualization of Asynchronous Many-Task Scheduling Algorithm

The paper is devoted to the issue of visualization of the algorithm for scheduling parallel tasks. Task scheduling is a key part of the online visualization and parallel programming environment developed by the author. When programming a parallel version of one mathematical application, a suspicion arose that the scheduling algorithm does not optimally distribute the load between the workers. In this connection, it was decided to visualize its work in order to see the overall picture and possible problem areas of the algorithm. The constructed view successfully coped with the problem, and the scheduling algorithm was improved.

A Streamlined Framework of Metamorphic Malware Classification via Sampling and Parallel Processing

Nowadays, malware remains a significant threat to the current cyberspace. More seriously, malware authors frequently use metamorphic techniques to create numerous variants, which throws malware researchers a heavy burden. Being able to classify these metamorphic malware samples into their corresponding families could accelerate the malware analysis task efficiently. Based on our comprehensive analysis, these variants are usually implemented by making changes to their assembly instruction sequences to a certain extent. Motivated by this finding, we present a streamlined and efficient framework of malware family classification named MalSEF, which leverages sampling and parallel processing to efficiently and effectively classify the vast number of metamorphic malware variants. At first, it attenuates the complexity of feature engineering by extracting a small portion of representative samples from the entire dataset and establishing a simple feature vector based on the Opcode sequences; then, it generates the feature matrix and conducts the classification task in parallel with collaboration utilizing multiple cores and a proactive recommendation scheme. At last, its practicality is strengthened to cope with the large volume of diversified malware variants based on common computing platforms. Our comprehensive experiments conducted on the Kaggle malware dataset demonstrate that MalSEF achieves a classification accuracy of up to 98.53% and reduces time overhead by 37.60% compared to the serial processing procedure.

Bidynamical all-optical reservoir computing for parallel task processing.

A bidynamical all-optical reservoir computing (RC) system for parallel task processing is proposed based on a unidirectional semiconductor optical amplifier optical fiber loop. The polarization dynamics and intensity dynamics are excited by the input signals injected into the reservoir via phase modulation and intensity modulation, respectively. Simultaneous computation of two independent tasks is implemented based on the dynamical responses in polarization and intensity of the optical fiber loop. To our knowledge, this is the first time that two kinds of dynamical responses of an all-optical RC system are used as independent task processing channels to implement parallel task processing. The proposed RC system can achieve good parallel task processing performance with low system cost.

Deep Q-Learning-Based Dynamic Management of a Robotic Cluster

The ever-increasing demands for autonomy and precision have led to the development of heavily computational multi-robot system (MRS). However, numerous missions exclude the use of robotic cloud. Another solution is to use the robotic cluster to locally distribute the computational load. This complex distribution requires adaptability to come up with a dynamic and uncertain environment. Classical approaches are too limited to solve this problem, but recent advances in reinforcement learning and deep learning offer new opportunities. In this paper we propose a new Deep Q-Network (DQN) based approaches where the MRS learns to distribute tasks directly from experience. Since the problem complexity leads to a curse of dimensionality, we use two specific methods, a new branching architecture, called Branching Dueling Q-Network (BDQ), and our own optimized multi-agent solution and we compare them with classical Market-based approaches as well as with non-distributed and purely local solutions. Our study shows the relevancy of learning-based methods for task mapping and also highlight the BDQ architecture capacity to solve high dimensional state space problems. <italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Note to Practitioners</i> —A lot of applications in industry like area exploration and monitoring can be efficiently delegated to a group of small-size robots or autonomous vehicles with advantages like reliability and cost in respect of single-robot solutions. But autonomy requires high and increasing compute-intensive tasks such as computer-vision. On the other hand small robots have energy constraints, limited embedded computing capacities and usually restricted and/or unreliable communications that limit the use of cloud resources. An alternative solution to cope with this problem consists in sharing the computing resources of the group of robots. Previous work was a proof of concept limited to the parallelisation of a single specific task. In this paper we formalize a general method that allows the group of robots to learn on the field how to efficiently distribute tasks in order to optimize the execution time of a mission under energy constraint. We demonstrate the relevancy of our solution over market-based and non-distributed approaches by means of intensive simulations. This successful study is a necessary first step towards distribution and parallelisation of computation tasks over a robotic cluster. The next steps, not tested yet, will address hardware in the loop simulation and finally a real-life mission with a group of robots.

Novel Coil Array Design and Modeling for Independent Control of Multiple Magnetic Microrobots

The independent control of microrobot swarms is a major challenge in the field of micro/nano manipulation. In this paper, a new localized magnetic field generating system is presented that can be used for the independent control of multiple magnetic microrobots. Such a system will allow for cooperative or parallel microassembly tasks with teams of magnetic microrobots. Firstly, the performance of the novel circular microcoil is modeled by analyzing the effect of input current to study the magnetic field distribution characteristics in the workspace, which is validated by finite element analysis and simulation; then, an actuation and control strategy of microrobots for microcoil array is proposed. Meanwhile, the independent closed-loop control of the microrobot is realized based on visual feedback; finally, an experimental platform for the microcoil actuation system is built to validate the newly designed structure. The results show that the microrobot can move flexibly and accurately with the tracking error within 0.444mm. At the same time, the system is capable of independently controlling multiple microrobots and holds great potential in performing micromanipulation tasks.

Defining Semantically Close Words of Kazakh Language with Distributed System Apache Spark

This work focuses on determining semantically close words and using semantic similarity in general in order to improve performance in information retrieval tasks. The semantic similarity of words is an important task with many applications from information retrieval to spell checking or even document clustering and classification. Although, in languages with rich linguistic resources, the methods and tools for this task are well established, some languages do not have such tools. The first step in our experiment is to represent the words in a collection in a vector form and then define the semantic similarity of the terms using a vector similarity method. In order to tame the complexity of the task, which relies on the number of word (and, consequently, of the vector) pairs that have to be combined in order to define the semantically closest word pairs, A distributed method that runs on Apache Spark is designed to reduce the calculation time by running comparison tasks in parallel. Three alternative implementations are proposed and tested using a list of target words and seeking the most semantically similar words from a lexicon for each one of them. In a second step, we employ pre-trained multilingual sentence transformers to capture the content semantics at a sentence level and a vector-based semantic index to accelerate the searches. The code is written in MapReduce, and the experiments and results show that the proposed methods can provide an interesting solution for finding similar words or texts in the Kazakh language.

Python-based social science applications’ profiling and optimization on HPC systems using task and data parallelism

This research addresses the pressing need to optimize Python-based social science applications for high-performance computing (HPC)systems, emphasizing the combined use of task and data parallelism techniques. The paper delves into a substantial body of research,recognizing Python’s interpreted nature as a challenge for efficient social science data processing. The paper introduces a Pythonprogram that exemplifies the proposed methodology. This program uses task parallelism with multi-processing and data parallelismwith dask to optimize data processing workflows. It showcases how researchers can effectively manage large datasets and intricatecomputations on HPC systems. The research offers a comprehensive framework for optimizing Python-based social science applicationson HPC systems. It addresses the challenges of Python’s performance limitations, data-intensive processing, and memory efficiency.Incorporating insights from a rich literature survey, it equips researchers with valuable tools and strategies for enhancing the efficiencyof their social science applications in HPC environments.

A Low-Level Virtual Machine Just-In-Time Prototype for Running an Energy-Saving Hardware-Aware Mapping Algorithm on C/C++ Applications That Use Pthreads

Low-Level Virtual Machine (LLVM) compiler infrastructure is a useful tool for building just-in-time (JIT) compilers, besides its reliable front end represented by a clang compiler and its elaborated middle end containing different optimizations that improve the runtime performance. This paper specifically addresses the part of building a JIT compiler using an LLVM with the scope of obtaining the hardware architecture details of the underlying machine such as the number of cores and the number of logical cores per processing unit and providing them to the NUMA-BTLP static thread classification algorithm and to the NUMA-BTDM static thread mapping algorithm. Afterwards, the hardware-aware algorithms are run using the JIT compiler within an optimization pass. The JIT compiler in this paper is designed to run on a parallel C/C++ application (which creates threads using Pthreads), before the first time the application is executed on a machine. To achieve this, the JIT compiler takes the native code of the application, obtains the corresponding LLVM IR (Intermediate Representation) for the native code and executes the hardware-aware thread classification and the thread mapping algorithms on the IR. The NUMA-Balanced Task and Loop Parallelism (NUMA-BTLP) and NUMA-Balanced Thread and Data Mapping (NUMA-BTDM) are expected to optimize the energy consumption by up to 15% on the NUMA systems.

Incremental-concurrent fusion checking for efficient context consistency

Smart applications can adapt their behaviors based on their understanding to environments (a.k.a. contexts). This capability can, however, incur unexpected misbehavior or even crash, when application contexts are inaccurate or conflicting with each other due to environmental noises. In the recent decade, various constraint checking techniques have been proposed to help validate contexts against consistency constraints, in order to guard context consistency in time. However, with growing environmental dynamics and context volume, it is getting increasingly challenging to ensure context consistency. In this article, we propose a novel approach, INFuse, to fuse together two lines of techniques, namely, incremental checking and concurrent checking, for sound and efficient constraint checking. Realizing such check fusion has to address the challenges rising from the gap between the micro analysis for reusable elements in incremental checking and the macro collection of parallel tasks in concurrent checking. INFuse solves them by automatically deciding maximal concurrent boundaries in a sequence of context changes, and soundly fusing incremental and concurrent checking together for context consistency, with theoretical guarantees. Our experimental evaluation with real-world context data shows that INFuse could improve constraint checking efficiency by 3.0x–120.3x, as compared with existing state-of-the-art techniques, with better checking quality.