Task Pool Research Articles

Scheduling ASC and AGV considering direct, buffer, and hybrid modes for transferring containers

At automated container terminals (ACTs), automated stacking cranes (ASCs) and automated guided vehicles (AGVs) perform yard vertical loading/unloading and horizontal transport operations, respectively. The two operating devices transfer containers at the seaside. This paper studies an integrated scheduling problem of ASCs and AGVs considering direct, buffer, and hybrid modes for transferring containers. In direct mode, the two devices are synchronized at the pad to transfer containers from one device to the other. Buffer mode decouples the synchronized operations between ASCs and AGVs, allowing one device to temporarily store the container at buffer sites (i.e., AGV partners) for subsequent operations by the other. Supported by advanced positioning technology, direct mode speeds up the transferring operations and helps to reduce partner overflow. Therefore, the hybrid mode with a combination of pads and partners makes operations more flexible. We formulate the integrated scheduling problem as a multi-layer vehicle routing problem and connect them via precedence relationships and transfer constraints. Three continuous time integer programming models are developed to sequence the handling tasks under the minimization of the makespan. A relaxation model and the cutting-plane approach are proposed to derive a lower bound. To enhance the search capability, a genetic algorithm embedded with several neighborhood generation operators is developed to solve the problem. In addition, a flexible strategy with a task pool and a transfer mode selection mechanism is proposed for decoding individuals in the genetic algorithms into handling sequences. Numerical experiments show that the hybrid mode outperforms the direct and buffer modes by an average of 12.35% and 8.26%, respectively. The makespan gap between the lower bound and the proposed algorithm is 6.5% on average. In addition, AGV utilization is highest in the hybrid mode, and the fluctuations in the container arrival rate have minimal effect on the hybrid mode. Moreover, based on the results, the opportunity and risk of configuring a hybrid mode through technological upgrading are discussed.

MATTE: Multi-task multi-scale attention

In this work, we propose a general method for learning task and scale based attention representations in Multi-Task Learning (MTL) for vision. It relies on learning and maintaining cross-task and cross-scale representations of visual information, whose interaction contributes to a symmetrical improvement across the entire task pool. Apart from learning data representations, we additionally optimize for the most beneficial interaction between tasks and their representations at different scales. Our method adds an attention modulated feature as residual information to the processing of each scale stage within the model, including the final layer of task outputs. We empirically show the effectiveness of our method through experiments with current multi-modal and multi-scale architectures on diverse MTL datasets. We evaluate MATTE on high and low level vision MTL problems, against MTL and single task learning (STL) counterparts. For all experiments we report solid performance improvements in both qualitative and quantitative performance.

Indonesian Bebras Challenge 2021 Exploratory Data Analysis

Indonesia is a full member of International Bebras Community and regularly perform the annual Bebras Challenge since 2016. The tasks for the Indonesian Bebras Challenge are taken and adapted from International Bebras Task pool, and each of the tasks is related to informatics and Computational Thinking (CT). We explore and analyze the Indonesian Bebras Challenge 2021 data to find interesting insight into Indonesian student’s competencies in informatics and computational thinking, the suitability of the selected Bebras Tasks difficulty level for each age group, and the relation between participants’ score and time duration in completing Bebras Challenge. The data exploratory has been done with statistics and data visualizations. We found that Indonesian students need to learn more about informatics and CT. The difficulty level of the Indonesian Bebras Challenge for elementary school students is still in accordance with Indonesian students’ competency. In contrast, the Bebras Challenge difficulty level for junior and senior high school is higher than the students’ competency. By analyzing the time duration of each participant completing the challenge, we also found some dishonest attitude presumptions during the online Bebras Challenge. We discover some suggestions for the improvement of Indonesian Bebras Challenge event as a means to improve Indonesian students’ informatics and CT skills.

Uncertainty‐aware scheduling of real‐time workflows under deadline constraints on multi‐cloud systems

SummaryThe elasticity and pay‐as‐you‐go features of cloud computing are popular with customers, and more and more workflow applications are migrating to cloud platforms. Many workflow scheduling algorithms aim to obtain minimal rental costs. However, most of the existing research assumes that task execution time is deterministic. In fact, due to the performance fluctuations of VMs, the task execution time is uncertain before scheduling. Furthermore, many works ignore the cost savings given by multi‐cloud systems. To this end, this paper provides a scheduling framework for real‐time workflows. The framework includes four main components: the workflow analyzer, task pool, task allocation controller, and resource manager. Then based on the framework, we propose the RWSMC heuristic algorithm. The algorithm's goal is to minimize the total rental cost while satisfying the deadline constraints and ensuring the reliability of task execution. The RWSMC algorithm reduces the cost by selecting the appropriate billing mechanism based on the task's execution time and mitigates the impact of uncertain execution time by scheduling the task to the VM with the shortest predicted start time. Simulation experiments demonstrate that our proposed algorithm outperforms three recent state‐of‐the‐art scheduling algorithms in the total rental cost, deadline violation rate, and VM resource utilization.

Learning to Solve Task-Optimized Group Search for Social Internet of Things

With the maturity and popularity of Internet of Things (IoT), the notion of Social Internet of Things (SIoT) has been proposed to support novel applications and networking services for the IoT in more effective and efficient ways. Although there are many works for SIoT, they focus on designing the architectures and protocols for SIoT under the specific schemes. How to efficiently utilize the collaboration capability of SIoT to complete complex tasks remains unexplored. Therefore, we propose a new problem family, namely, <italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Task-Optimized SIoT Selection (TOSS)</i> , to find the best group of IoT objects for a given set of tasks in the task pool. TOSS aims to select the target SIoT group such that the target SIoT group is able to easily communicate with each other while maximizing the accuracy of performing the given tasks. We propose two problem formulations, named <italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Bounded Communication-loss TOSS (BC-TOSS)</i> and <italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Robustness Guaranteed TOSS (RG-TOSS)</i> , for different scenarios and prove that they are both NP-hard and inapproximable. We propose a polynomial-time algorithm with a performance guarantee for BC-TOSS, and an efficient polynomial-time algorithm to obtain good solutions for RG-TOSS. Moreover, as RG-TOSS is NP-hard and inapproximable within any factor, we further propose <italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Structure-Aware Reinforcement Learning (SARL)</i> to leverage the Graph Convolutional Networks (GCN) and Deep Reinforcement Learning (DRL) to effectively solve RG-TOSS. Further, since we use graph models to simulate the problem instance for DRL, which is different from the real ones, we propose <italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Structure-Aware Meta Reinforcement Learning (SAMRL)</i> for fast adapting to new domains. Experimental results on multiple real datasets indicate that our proposed algorithms outperform the other deterministic and learning-based baseline approaches.

B-Morpher: Automated Learning of Morphological Language Characteristics for Inflection and Morphological Analysis

Abstract The automated induction of inflection rules is an important research area for computational linguistics. In this paper, we present a novel morphological rule induction model called B-Morpher that can be used for both inflection analysis and morphological analysis. The core element of the engine is a modified Bayes classifier in which class categories correspond to general string transformation rules. Beside the core classification module, the engine contains a neural network module and verification unit to improve classification accuracy. For the evaluation, beside the large Hungarian dataset the tests include smaller non-Hungarian datasets from the SIGMORPHON shared task pools. Our evaluation shows that the efficiency of B-Morpher is comparable with the best results, and it outperforms the state-of-theart base models for some languages. The proposed system can be characterized by not only high accuracy, but also short training time and small knowledge base size.

Multirobot Adaptive Task Allocation of Intelligent Warehouse Based on Evolutionary Strategy

To solve the dynamic and real-time problem of multirobot task allocation in intelligent warehouse system under parts-to-picker mode, this paper presents a combined solution based on adaptive task pool strategy and Covariance Matrix Adaptation Evolutionary Strategy (CMA-ES) algorithm. In the first stage of the solution, a variable task pool is used to store dynamically added tasks, which can dynamically divide continuous and large-scale task allocation problems into small-scale subproblems to solve them to meet dynamic requirements. And an adaptive control strategy is used to automatically adjust the total number of tasks in the task pool to achieve a trade-off among throughput, energy consumption, and waiting time, which has better adaptability than manually adjusting the size of the task pool. In the second stage of the solution, when the task pool is full, tasks in the task pool will be assigned to robots. For the task allocation problem, this paper regards it as an optimization problem and uses the CMA-ES algorithm to find the optimal task assignment solution for all the robots. By comparing with fixed threshold method under 56 different task pool sizes, the experimental results show that the throughput can be close to reaching the optimal level, and the average distance traveled by robots to handle each unit is lower using adaptive threshold method; so, adaptive task pool solution has better adaptability and can find the optimal task pool size by itself. This method can satisfy the dynamic and real-time requirements and can be effectively applied to the intelligent warehouse system.

Integrated Production and Transportation Scheduling Method in Hybrid Flow Shop

The connection between production scheduling and transportation scheduling is getting closer in smart manufacturing system, and both of those problems are summarized as NP-hard problems. However, only a few studies have considered them simultaneously. This paper solves the integrated production and transportation scheduling problem (IPTSP) in hybrid flow shops, which is an extension of the hybrid flow shop scheduling problem (HFSP). In addition to the production scheduling on machines, the transportation scheduling process on automated guided vehicles (AGVs) is considered as another optimization process. In this problem, the transfer tasks of jobs are performed by a certain number of AGVs. To solve it, we make some preparation (including the establishment of task pool, the new solution representation and the new solution evaluation), which can ensure that satisfactory solutions can be found efficiently while appropriately reducing the scale of search space. Then, an effective genetic tabu search algorithm is used to minimize the makespan. Finally, two groups of instances are designed and three types of experiments are conducted to evaluate the performance of the proposed method. The results show that the proposed method is effective to solve the integrated production and transportation scheduling problem.

Design-time performance modeling of compositional parallel programs

Performance models are powerful instruments for understanding the performance of parallel systems and uncovering their bottlenecks. Already during system design, performance models can help ponder alternative development options. However, creating a performance model – whether theoretically or empirically – for an entire application that does not exist yet is challenging. In this paper, we propose to generate performance models of full programs from performance models of their components using formal composition operators derived from parallel design patterns. As long as the design of the overall system follows such a pattern, its performance model can be predicted with reasonable accuracy without an actual implementation. We demonstrate our approach with design patterns of varying complexity, including pipeline, task pool, and eventually MapReduce, which is representative of a broad class of data-analytics applications.

Memory-Aware Scheduling Parallel Real-Time Tasks for Multicore Systems

Shared resources on the multicore chip, such as main memory, are increasingly becoming a point of contention. Traditional real-time task scheduling policies focus on solely on the CPU, and do not take in account memory access and cache effects. In this paper, we propose parallel real-time tasks scheduling (PRTTS) policy on multicore platforms. Each set of tasks is represented as a directed acyclic graph (DAG). The priorities of tasks are assigned according to task periods Rate Monotonic (RM). Each task is composed of three phases. The first phase is read memory stage, the second phase is execution phase and the third phase is write memory phase. The tasks use locks and critical sections to protect data access. The global scheduler maintains the task pool in which tasks are ready to be executed which can run on any core. PRTTS scheduling policy consists of two levels: the first level scheduling schedules ready real-time tasks in the task pool to cores, and the second level scheduling schedules real-time tasks on cores. Tasks can preempt the core on running tasks of low priority. The priorities of tasks which want to access memory are dynamically increased above all tasks that do not access memory. When the data accessed by a task is in the cache, the priority of the task is raised to the highest priority, and the task is scheduled immediately to preempt the core on running the task not accessing memory. After accessing memory, the priority of these tasks is restored to the original priority and these tasks are pended, the preempted task continues to run on the core. This paper analyzes the schedulability of PRTTS scheduling policy. We derive an upper-bound on the worst-case response-time for parallel real-time tasks. A series of extensive simulation experiments have been performed to evaluate the performance of proposed PRTTS scheduling policy. The results of simulation experiment show that PRTTS scheduling policy offers better performance in terms of core utilization and schedulability rate of tasks.

A Comparison of Application-Level Fault Tolerance Schemes for Task Pools

Fault tolerance is an important requirement for successful program execution on exascale systems. The common approach, checkpointing, regularly saves a program’s state, such that the execution can be restarted after permanent node failures. Checkpointing is often performed on system level, but its deployment on application level can reduce the running time overhead.The drawback of application-level checkpointing is a higher programming expense. It pays off if the checkpointing is applied to reusable patterns. We consider task pools, which exist in many variants. The paper supposes that tasks are generated dynamically and are free of side effects. Further, the final result must be computed from individual task results by reduction. Moreover, the pools must be distributed with private queues, and adopt work stealing.The paper describes and evaluates three application-level fault tolerance schemes for task pools. All use uncoordinated checkpointing and regularly save information in a resilient store. The first scheme (called AllFT) saves descriptors of all open tasks; the second scheme (called IncFT) selectively and incrementally saves only part of them; and the third scheme (called LogFT) logs stealing events and writes checkpoints in parallel to task processing.All schemes have been implemented by extending the Global Load Balancing (GLB) library of the “APGAS for Java” programming system. In experiments with the UTS, NQueens, and BC benchmarks with up to 672 workers, the running time overhead during failure-free execution, compared to a non-resilient version of GLB, was typically below 6%. The recovery cost was negligible, and there was no clear winner among the three schemes. A more detailed performance analysis with synthetic benchmarks revealed that IncFT and LogFT are superior in scenarios with large task descriptors.

Self-Optimizing and Self-Programming Computing Systems: A Combined Compiler, Complex Networks, and Machine Learning Approach

There exists an urgent need for determining the right amount and type of specialization while making a heterogeneous system as programmable and flexible as possible. Therefore, in this paper, we pioneer a self-optimizing and self-programming computing system (SOSPCS) design framework that achieves both programmability and flexibility and exploits computing heterogeneity [e.g., CPUs, GPUs, and hardware accelerators (HWAs)]. First, at compile time, we form a task pool consisting of hybrid tasks with different processing element (PE) affinities according to target applications. Tasks preferred to be executed on GPUs or accelerators are detected from target applications by neural networks. Tasks suitable to run on CPUs are formed by community detection to minimize data movement overhead. Next, a distributed reinforcement learning-based approach is used at runtime to allow agents to map the tasks onto the network-on-chip-based heterogeneous PEs by learning an optimal policy based on $Q$ values in the environment. We have conducted experiments on a heterogeneous platform consisting of CPUs, GPUs, and HWAs with deep learning algorithms such as matrix multiplication, ReLU, and sigmoid functions. We concluded that SOSPCS provides performance improvement up to $4.12\times $ and energy reduction up to $3.24\times $ compared to the state-of-the-art approaches.

THE MODIFIED INFORMATION TECHNOLOGY FOR THE DISTRIBUTION OF RESOURCE TASKS FOR CLOUD COMPUTING SYSTEMS

The object of the research is the process of distribution a pool of input tasks for computing resources in hybrid cluster systems. The subject of the research is information technology of distribution tasks for computing resources of hybrid cluster systems. The goal is to develop and to implement a simulation stage in a modified information technology for distributing the incoming task pool to the computing power of hybrid cluster systems. Tasks: to modify the existing information technology of task distribution on the basis of mathematical models of tasks, computing resources and distribution methods; to develop an information system that will perform an automated process of collecting and processing the data; to form a series of experiments on the distribution of the input task pool, based on the distribution methods implemented in the simulation environment. Research methods are based on the use of the theory of sets, the general theory of systems and the theory of simulation modeling. The results received. The modified information technology of distribution of program tasks of big dimension for computing resources for the systems of cloud computing with the use of the simulation environment of modeling with the subsequent choice of the best dispersion plan on each pool of input tasks is offered. The proposed information technology has been introduced into a simulation environment that allows reproducing the process of functioning of elementary events occurring in the real hybrid cluster systems while preserving the logic of their interaction in a real time. Conclusions: The proposed information technology combines the processes of collecting, storing, processing and transmitting data using the offered distribution methods, means for further analyzing the results of modeling and deciding whether to perform a specific action (choosing the best distribution plan). The use of a set of distribution methods in the simulation environment allows to conduct a series of experiments and, based on the results obtained, select the best distribution plan for a particular input task pool (on the basis of the selected strategy of distribution).

Blaze-Tasks

Compared to threads, tasks are a more fine-grained alternative. The task parallel programming model offers benefits in terms of better performance portability and better load-balancing for problems that exhibit nonuniform workloads. A common scenario of task parallel programming is that a task is recursively decomposed into smaller sub-tasks. Depending on the problem domain, the number of created sub-tasks may be nonuniform, thereby creating potential for significant load imbalances in the system. Dynamic load-balancing mechanisms will distribute the tasks across available threads. The final result of a computation may be modeled as a reduction over the results of all sub-tasks. This article describes a simple, yet effective prototype framework, Blaze-Tasks, for task scheduling and task reductions on shared memory architectures. The framework has been designed with lock-free techniques and generic programming principles in mind. Blaze-Tasks is implemented entirely in C++17 and is thus portable. To load-balance the computation, Blaze-Tasks uses task stealing. To manage contention on a task pool, the number of lock-free attempts to steal a task depends on the distance between thief and pool owner and the estimated number of tasks in a victim’s pool. This article evaluates the Blaze framework on Intel and IBM dual-socket systems using nine benchmarks and compares its performance with other task parallel frameworks. While Cilk outperforms Blaze on Intel on most benchmarks, the evaluation shows that Blaze is competitive with OpenMP and other library-based implementations. On IBM, the experiments show that Blaze outperforms other approaches on most benchmarks.

Five ways to insert concurrency to a program written in C#

Nowadays processors working in personal computers and mobile devices allow for more and more effective parallel computing. Developers have at their disposal many different methods of implementing concurrency, but usually use the one, that they now best. It is beneficial to know, when a particular technique is good and when it is better to find an alternative. This paper presents different ways of implementing parallel mathematical calculations using threads, tasks, thread pool, task pool and parallel for loop. Each method was used in a C# application running on Windows Presentation Foundation engine on .NET platform. Implemented operation is calculation value of Pi using Leibnitz’s formula.

Hybrid work stealing of locality-flexible and cancelable tasks for the APGAS library

Since large parallel machines are typically clusters of multicore nodes, parallel programs should be able to deal with both shared memory and distributed memory. This paper proposes a hybrid work stealing scheme, which combines the lifeline-based variant of distributed task pools with the node-internal load balancing of Java’s Fork/Join framework. We implemented our scheme by extending the APGAS library for Java, which is a branch of the X10 project. APGAS programmers can now spawn locality-flexible tasks with a new asyncAny construct. These tasks are transparently mapped to any resource in the overall system, so that the load is balanced over both nodes and cores. Unprocessed asyncAny-tasks can also be cancelled. In performance measurements with up to 144 workers on up to 12 nodes, we observed near linear speedups for four benchmarks and a low overhead for cancellation-related bookkeeping.

Load Balancing Scheduling Algorithm for Concurrent Workflow

Concurrent workflow scheduling algorithm works in three phases, namely rank computation, tasks selection, and resource selection. In this paper, we introduce a new ranking algorithm that computes the rank of a task, based on its successor rank and its predecessors average communication time, instead of its successors rank. The advantage of this ranking algorithm is that two dependent tasks are assigned to the same machine and as a result the scheduled length is reduced. The task selection phase selects a ready task from each workflow and creates a task pool. The resource selection phase initially assigns tasks using min-min heuristic, after initial assignment, tasks are moved from the highly loaded machines to the lightly loaded machines. Our resource selection algorithm increases the load balance among the resources due to tasks assignment heuristic and reassignment of tasks from the highly loaded machines. The simulation results show that our proposed scheduling algorithm performs better over existing approaches in terms of load balance, makespan and turnaround time.

A Java Task Pool Framework providing Fault-Tolerant Global Load Balancing

Fault tolerance is gaining importance in parallel computing, especially on large clusters. Traditional approaches handle the issue on system-level. Application-level approaches are becoming increasingly popular, since they may be more efficient. This paper presents a fault-tolerant work stealing technique on application level, and describes its implementation in a generic reusable task pool framework for Java. When using this framework, programmers can focus on writing sequential code to solve their actual problem. The framework is written in Java and utilizes the APGAS library for parallel programming. It implements a comparatively simple algorithm that relies on a resilient data structure for storing backups of local pools and other information. Our implementation uses Hazelcast's IMap for this purpose, which is an automatically distributed and fault-tolerant key-value store.?The number of backup copies is configurable and determines how many simultaneous failures can be tolerated. Our algorithm is shown to be correct in the sense that failures are either tolerated and the computed result is the same as in non-failure case, or the program aborts with an error message. Experiments were conducted with the UTS, NQueens and BC benchmarks on up to 144 workers. First, we compared the performance of our framework with that of a non-fault-tolerant variant during failure-free operation. Depending on the parameter settings, the overhead was at most 46.06%. The particular value tended to increase with the number of steals. Second, we compared our framework's performance with that of a related, but less flexible fault-tolerant X10 framework. Here, we did not observe a clear winner. Finally, we measured the overheads for restoring a failed worker and for raising the number of backup copies from one to six, and found both to be negligible.

Fault Tolerance for Lifeline-Based Global Load Balancing

Fault tolerance has become an important issue in parallel computing. It is often addressed at system level, but application-level approaches receive increasing attention. We consider a parallel programming pattern, the task pool, and provide a fault-tolerant implementation in a library. Specifically, our work refers to lifeline-based global load balancing, which is an advanced task pool variant that is implemented in the GLB framework of the parallel programming language X10. The variant considers side effect-free tasks whose results are combined into a final result by reduction. Our algorithm is able to recover from multiple fail-stop failures. If recovery is not possible, it halts with an error message. In the algorithm, each worker regularly saves its local task pool contents in the main memory of a backup partner. Backups are updated for steals. After failures, the backup partner takes over saved copies and collects others. In case of multiple failures, invocations of the restore protocol are nested. We have implemented the algorithm by extending the source code of the GLB library. In performance measurements on up to 256 places, we observed an overhead between 0.5% and 30%. The particular value depends on the application’s steal rate and task pool size. Sources of performance overhead have been further analyzed with a logging component.1

Parallel On-Demand Hierarchy Construction on Contemporary GPUs

We present the first parallel on-demand spatial hierarchy construction algorithm targeting ray tracing on many-core processors such as GPUs. The method performs simultaneous ray traversal and spatial hierarchy construction focused on the parts of the data structure being traversed. The method is based on a versatile framework built around a task pool and runs entirely on the GPU. We show that the on-demand construction can improve rendering times compared to full hierarchy construction. We evaluate our method on both object (BVH) and space (kd-tree) subdivision data structures and compare them mutually. The on-demand method is particularly beneficial for rendering large scenes with high occlusion. We also present SAH kd-tree builder that outperforms previous state-of-the-art builders running on the GPU.