Task Granularity Research Articles

METHOD FOR TASK SCHEDULING WITH GRANULARITY OF TASKS AND HOSTS FOR GRID-SYSTEM

This study aims to increase the productivity of grid systems by an improved scheduling method. A brief overview and analysis of the main scheduling methods in grid systems are presented. A method for increasing efficiency by optimizing the task graph structure considering the grid system node structure is proposed. Depending on the selection of the optimization criterion of the optimal node search problem, a subset of nodes is determined, which provide the start-up of the complement in a minimum time, then, node with minimum cost is selected. Task granularity (the ratio between the amount of computation and transferred data) is considered to increase the efficiency of planning. An analysis of the impact on task scheduling efficiency in a grid system is presented. A correspondence of the task graph structure considering the node structure (in which the task is immersed) to the effectiveness of scheduling in a grid system is shown. The basic scheduling algorithm for consideration and modification is the Maui hierarchical scheduler algorithm. A modified method for scheduling tasks while considering their granularity is proposed. As part of this work, you have developed the GridSim toolbox by adding new entities to simulate planning and workflow processes in the grid-environment. The relevant algorithm for task scheduling in a grid system is developed. Simulation of the proposed algorithm using the modeling system GridSim is conducted. A comparative analysis between the modified algorithm and the algorithm of the hierarchical scheduler Maui is shown. The general advantages and disadvantages of the proposed algorithm are discussed. As a result of program operation, generated diagrams of loading of Grid-system nodes and communication channels. With the help of this program there was performed analysis of load of system nodes at different relations between number of tasks and Grid-system nodes. As the task queue increases, the efficiency of the modified scheduling algorithm increases significantly due to the higher and even loading of nodes and communication channels. With a modified algorithm, scheduling increases scheduler decision time.

MODIFIED HIERARCIAL METHOD FOR TASK SCHEDULING IN GRID SYSTEMS

This study aims to increase the productivity of grid systems by an im­ proved scheduling method. A brief overview and analysis of the main scheduling methods in grid systems are presented. A method for increasing efficiency by opti­ mizing the task graph structure considering the grid system node structure is proposed. Task granularity (the ratio between the amount of computation and trans­ ferred data) is considered to increase the efficiency of planning. An analysis of the impact on task scheduling efficiency in a grid system is presented. A correspondence of the task graph structure considering the node structure (in which the task is immersed) to the effectiveness of scheduling in a grid system is shown. A modified method for schedu­ ling tasks while considering their granularity is proposed. The relevant algorithm for task scheduling in a grid system is developed. Simulation of the proposed algorithm using the modeling system GridSim is conducted. A comparative analysis between the modified algorithm and the algorithm of the hierarchical scheduler Maui is shown. The general advantages and disadvantages of the proposed algorithm are discussed.

Large-scale parallel similarity search with Product Quantization for online multimedia services

The similarity search in high-dimensional spaces is a core operation found in several online multimedia retrieval applications. With the popularity of these applications, they are required to handle very large and increasing datasets, while keeping the response time low. This problem is worsened in the context of online applications, mostly due to the fact that load on these systems vary during the execution according to the users demands. Those variations require the application to adapt during the execution in order to minimize the response times. In this paper, we address these challenges with an efficient parallelization of the Product Quantization Approximate Nearest Neighbor Search (PQANNS) indexing. This method is capable of answering queries with a reduced memory demand and, coupled with a distributed memory parallelization proposed here, can efficiently handle very large datasets. We have also proposed mechanisms to minimize the query response times in online scenarios in which the query rates vary at run-time. For this sake, our strategies tune the parallelism configurations and task granularity during the execution. The parallelism and granularity tuning approaches (ADAPT and ADAPT+G) have shown, for instance, to reduce the query response times by a factor of 6.4× in comparison with the best static configuration of parallelism and task granularity. Further, the distributed memory execution using 128 nodes/3584 CPU cores has attained a parallel efficiency of 0.97 with a dataset of 256 billion SIFT vectors.

DF‐DTM: Dynamic Task Memoization and reuse in dataflow

SummaryInstruction Reuse is a technique adopted in Von Neumann architectures that improves performance by avoiding redundant execution of instructions when the result to be produced can be obtained by searching an input/output memoization table for such instruction. Trace reuse can be applied to traces of instructions in a similar fashion. However, those techniques are yet to be studied in the context of the Dataflow model, which has been gaining traction in the high performance computing community due to its inherent parallelism. Dataflow programs are represented by directed graphs where nodes are instructions or tasks and edges denote data dependencies between tasks. This work presents Dataflow Dynamic Task Memoization (DF‐DTM), a technique that allows the reuse of both nodes and subgraphs in dataflow, which are analogous to instructions and traces, respectively. The potential of DF‐DTM is evaluated by a series of experiments that analyze the behavior of redundant tasks in five relevant benchmarks, where up to 99.70% of the instantiated tasks could be reused. Moreover, this paper evaluates how reuse rates can be affected by limiting subgraph size, memoization table size, task granularity, and problem size, showing that DF‐DTM can yield good reuse rates in more realistic environments.

Static Compiler Analyses for Application-specific Optimization of Task-Parallel Runtime Systems

Achieving high performance in task-parallel runtime systems, especially with high degrees of parallelism and fine-grained tasks, requires tuning a large variety of behavioral parameters according to program characteristics. In the current state of the art, this tuning is generally performed in one of two ways: either by a group of experts who derive a single setup which achieves good – but not optimal – performance across a wide variety of use cases, or by monitoring a system’s behavior at runtime and responding to it. The former approach invariably fails to achieve optimal performance for programs with highly distinct execution patterns, while the latter induces overhead and cannot affect parameters which need to be set at compile time. In order to mitigate these drawbacks, we propose a set of novel static compiler analyses specifically designed to determine program features which affect the optimal settings for a task-parallel execution environment. These features include the parallel structure of task spawning, the granularity of individual tasks, the memory size of the closure required for task parameters, and an estimate of the stack size required per task. Based on the result of these analyses, various runtime system parameters are then tuned at compile time. We have implemented this approach in the Insieme compiler and runtime system, and evaluated its effectiveness on a set of 12 task parallel benchmarks running with 1 to 64 hardware threads. Across this entire space of use cases, our implementation achieves a geometric mean performance improvement of 39%. To illustrate the impact of our optimizations, we also provide a comparison to current state-of-the art task-parallel runtime systems, including OpenMP, Cilk, HPX, and Intel TBB.

Flexible home care scheduling

Home care services are in high demand given how they are steadily becoming the primary source of care for the elderly. Powerful decision support tools are indispensable for effectively managing available staff in the context of ever-increasing demand for care and limited caregiver availability. This paper advances home care literature by introducing flexible task durations, thereby enabling tasks to be completed faster and ultimately more care to be scheduled. This new concept, which originates from practice, introduces an additional decision to be made when creating a schedule, thereby greatly increasing the scheduling complexity. Consequently, this paper introduces a new optimization-based decision support model which allows for scheduling with flexible task duration, as well as other types of flexibility. A computational study quantifies the impact of: (i) scheduling with a finer task granularity thereby enabling accurate prioritization of high and low priority care, (ii) flexibility in task duration enabling tasks to be completed faster and more care to be scheduled, and (iii) increasing the number of different locations visited by a caregiver thereby enabling a trade-off between the number of serviced clients and caregiver workload. A new publicly available real-world data set is used, obtained directly from home care organizations operating in Flanders. Analysis of the computational results demonstrates that significant improvements in operational efficiency may be realized with minimal effort required by organizations. Furthermore, the proposed algorithm’s performance is confirmed by comparison against the bounds obtained by solving an integer programming formulation of the problem. Finally, a management policy scheme is proposed which, when gradually implemented in a home care organization, results in a more efficient and therefore cost-effective deployment of its workforce.

WT_DMDA new scheduling strategy for conjugate gradient solver on heterogeneous architecture

Heterogeneous systems which are composed of multiple CPUs and GPUs are more and more attractive as platforms for high performance computing. With the evolution of general purpose computation on GPU (GPGPU) and corresponding programming frameworks (OpenCL and CUDA), more applications are using GPUs as a co-processor to achieve performance that could not be accomplished using just the traditional processors. However, the main problem is identifying which task or job should be allocated to a particular device. The problem is even complicated due to the dissimilar computational power of the CPU and the GPU. In this work we propose a new scheduling strategy WT_DMDA which aims to optimise the performance of the preconditioned conjugate gradient solver, in CPU-GPU heterogeneous environment. We use StarPU runtime system to assess the efficiency of the approach on a computational platform consisting of three NVIDIA Fermi GPUs and 12 Intel CPUs. We show that important speedups (up to 5.13×) may be reached (relatively to default scheduler of StarPU) when processing large matrices and that the performance is advantageous when changing the granularity of tasks. An analysis and evaluation of these results is discussed.

Understanding the impact of task granularity in the energy consumption of parallel programs

Recently, there is a concern about reducing the energy consumption of data centers and clusters for economical and environmental reasons. Furthermore, energy consumption on mobile devices is also important to improve battery life. In this work we address the performance-energy trade-off on shared-memory multicore devices in parallel programs. In particular, we assess the impact of task granularity in performance and energy consumption. Our aim is to give programmers the knowledge they need to understand how to maximize performance of parallel programs while minimizing energy spending.Parallel programs typically divide work in subproblems that are solved in parallel. Each subproblem can then be recursively subdivided until it is no longer worthwhile to spawn smaller tasks. Ideally, the number of parallel tasks should match the number of hardware threads in order to maximize performance and reduce scheduling overheads. Cut-off algorithms are used to stop spawning new parallel tasks and, thus, switching to sequential execution. We evaluate cut-off approaches such as MaxTasks, MaxLevel, Surplus, Adaptive Task Control and LoadBased to understand how they influence performance and energy consumption. Additionally, we also introduce and evaluate three novel approaches: MaxTasksInQueue, StackSize and MaxTasksWithStackSize.Our experiments and analysis show how branching, workload, depth and balance influence the execution time and energy spending over a set of synthetic and real world programs. We concluded that MaxLevel was the fastest overall, while MaxTasksInQueue was the most energy efficient algorithm. Also, despite MaxTasks being slower than the prior two, it can be used by a wider range of programs.

Modified Hierarchical Method for Task Scheduling in Grid Systems

This study aims to increase the productivity of grid systems by an improved scheduling method. A brief overview and analysis of the main scheduling methods in grid systems are presented. A method for increasing efficiency by optimizing the task graph structure considering the grid system node structure is proposed. Task granularity (the ratio between the amount of computation and transferred data) is considered to increase the efficiency of planning. An analysis of the impact on task scheduling efficiency in a grid system is presented. A correspondence of the task graph structure considering the node structure (in which the task is immersed) to the effectiveness of scheduling in a grid system is shown. A modified method for scheduling tasks while considering their granularity is proposed. The relevant algorithm for task scheduling in a grid system is developed. Simulation of the proposed algorithm using the modeling system GridSim is conducted. A comparative analysis between the modified algorithm and the algorithm of the hierarchical scheduler Maui is shown. The general advantages and disadvantages of the proposed algorithm are discussed.

Reordering Strategy for Blocking Optimization in Sparse Linear Solvers

Solving sparse linear systems is a problem that arises in many scientific applications, and sparse direct solvers are a time-consuming and key kernel for those applications and for more advanced solvers such as hybrid direct-iterative solvers. For this reason, optimizing their performance on modern architectures is critical. The preprocessing steps of sparse direct solvers---ordering and block-symbolic factorization---are two major steps that lead to a reduced amount of computation and memory and to a better task granularity to reach a good level of performance when using BLAS kernels. With the advent of GPUs, the granularity of the block computation has become more important than ever. In this paper, we present a reordering strategy that increases this block granularity. This strategy relies on block-symbolic factorization to refine the ordering produced by tools such as Metis or Scotch, but it does not impact the number of operations required to solve the problem. We integrate this algorithm in the PaSt...

Performance and Scalability Study of FMM Kernels on Novel Multi- and Many-core Architectures

We provide efficient implementations of common Fast Multipole Method (FMM) tasks for modern multi-core (Intel Xeon Haswell), many-core (Intel Xeon Phi Knights Landing) and Nvidia Pascal GPUs, offering optimization guidelines for each kernel and architecture, and exposing task granularity issues with evaluations on performance and scalability. These results motivate the use of hybrid execution models for FMM in heterogeneous architectures, in which per-kernel execution configurations are set by the kernel adaptability to the processor.

Exploiting Data-Parallelism on Multicore and SMT Systems for Implementing the Fractal Image Compressing Problem

This paper presents a parallel modeling of a lossy image compression method based on the fractal theory and its evaluation over two versions of dual-core processors: with and without simultaneous multithreading (SMT) support. The idea is to observe the speedup on both configurations when changing application parameters and the number of threads at operating system level. Our target application is particularly relevant in the Big Data era. Huge amounts of data often need to be sent over low/medium bandwidth networks, and/or to be saved on devices with limited store capacity, motivating efficient image compression. Especially, the fractal compression presents a CPU-bound coding method known for offering higher indexes of file reduction through highly time-consuming calculus. The structure of the problem allowed us to explore data-parallelism by implementing an embarrassingly parallel version of the algorithm. Despite its simplicity, our modeling is useful for fully exploiting and evaluating the considered architectures. When comparing performance in both processors, the results demonstrated that the SMT-based one presented gains up to 29%. Moreover, they emphasized that a large number of threads does not always represent a reduction in application time. In average, the results showed a curve in which a strong time reduction is achieved when working with 4 and 8 threads when evaluating pure and SMT dual-core processors, respectively. The trend concerns a slow growing of the execution time when enlarging the number of threads due to both task granularity and threads management.

Evaluating Multiple Streams on Heterogeneous Platforms

Using multiple streams can improve the overall system performance by mitigating the data transfer overhead on heterogeneous systems. Prior work focuses a lot on GPUs but little is known about the performance impact on (Intel Xeon) Phi. In this work, we apply multiple streams into six real-world applications on Phi. We then systematically evaluate the performance benefits of using multiple streams. The evaluation work is performed at two levels: the microbenchmarking level and the real-world application level. Our experimental results at the microbenchmark level show that data transfers and kernel execution can be overlapped on Phi, while data transfers in both directions are performed in a serial manner. At the real-world application level, we show that both overlappable and non-overlappable applications can benefit from using multiple streams (with an performance improvement of up to 24%). We also quantify how task granularity and resource granularity impact the overall performance. Finally, we present a set of heuristics to reduce the search space when determining a proper task granularity and resource granularity. To conclude, our evaluation work provides lots of insights for runtime and architecture designers when using multiple streams on Phi.

Chain: tasks and channels for reliable intermittent programs

Energy harvesting computers enable general-purpose computing using energy collected from their environment. Energy-autonomy of such devices has great potential, but their intermittent power supply poses a challenge. Intermittent program execution compromises progress and leaves state inconsistent. This work describes Chain: a new model for programming intermittent devices. A Chain program is a set of programmer-defined tasks that compute and exchange data through channels. Chain guarantees forward progress at task granularity. A task is restartable and never sees inconsistent state, because its input and output channels are separated. Our system supports language features for expressing advanced data exchange patterns and for encapsulating reusable functionality. Chain fundamentally differs from state-of-the-art checkpointing approaches and does not incur the associated overhead. We implement Chain as C language extensions and a runtime library. We used Chain to implement four applications: machine learning, encryption, compression, and sensing. In experiments, Chain ensured consistency where prior approaches failed and improved throughput by 2-7x over the leading state-of-the-art system.

Porting HPC applications to the cloud: A multi-frontal solver case study

In this paper we argue that scientific applications traditionally considered as representing typical HPC workloads can be successfully and efficiently ported to a cloud infrastructure. We propose a porting methodology that enables parallelization of communication – and memory-intensive applications while achieving a good communication to computation ratio and a satisfactory performance in a cloud infrastructure. This methodology comprises several aspects: (1) task agglomeration heuristic enabling increasing granularity of tasks while ensuring they will fit in memory; (2) task scheduling heuristic increasing data locality; and (3) two-level storage architecture enabling in-memory storage of intermediate data. We implement this methodology in a scientific workflow system and use it to parallelize a multi-frontal solver for finite-element meshes, deploy it in a cloud, and execute it as a workflow. The results obtained from the experiments confirm that the proposed porting methodology leads to a significant reduction of communication costs and achievement of a satisfactory performance. We believe that these results constitute a valuable step toward a wider adoption of cloud infrastructures for computational science applications.

Workflow-and-Platform Aware task clustering for scientific workflow execution in Cloud environment

A scientific workflow, usually consists of a good mix of fine and coarse computational granularity tasks displaying varied runtime requirements. It has been observed that fine grained tasks incur more scheduling overhead than their execution time, when executed on widely distributed platforms. Task clustering is extensively used, in such situations, as a runtime optimization method which involves combining multiple short duration tasks into a cluster, to be scheduled on a single resource. This helps in minimizing the scheduling overheads of the fine grained tasks. However, tasks grouping curtails the degree of parallelism and hence needs to be done optimally. Though a number of task clustering techniques have been developed to reduce the impact of system overheads, they fail to identify the appropriate number of clusters at each level of workflow in order to achieve maximum possible parallelism. This work proposes a level based autonomic Workflow-and-Platform Aware (WPA) task clustering technique which takes into consideration both; the workflow structure and the underlying resource set size for task clustering. It aims to achieve maximum possible parallelism among the tasks at a level of a workflow while minimizing the system overheads and resource wastage. A comparative study with current state of the art task clustering approaches on four well-known scientific workflows show that the proposed method significantly reduces the overall workflow execution time and at the same time is able to consolidate the load onto minimum possible resources.

Scheduling optimization of task allocation in integrated manufacturing system based on task decomposition

How to deal with the collaboration between task decomposition and task scheduling is the key problem of the integrated manufacturing system for complex products. With the development of manufacturing technology, we can probe a new way to solve this problem. Firstly, a new method for task granularity quantitative analysis is put forward, which can precisely evaluate the task granularity of complex product cooperation workflow in the integrated manufacturing system, on the above basis; this method is used to guide the coarse-grained task decomposition and recombine the subtasks with low cohesion coefficient. Then, a multi-objective optimieation model and an algorithm are set up for the scheduling optimization of task scheduling. Finally, the application feasibility of the model and algorithm is ultimately validated through an application case study.

Dynamic and Fault-Tolerant Clustering for Scientific Workflows

Task clustering has proven to be an effective method to reduce execution overhead and to improve the computational granularity of scientific workflow tasks executing on distributed resources. However, a job composed of multiple tasks may have a higher risk of suffering from failures than a single task job. In this paper, we conduct a theoretical analysis of the impact of transient failures on the runtime performance of scientific workflow executions. We propose a general task failure modeling framework that uses a maximum likelihood estimation-based parameter estimation process to model workflow performance. We further propose three fault-tolerant clustering strategies to improve the runtime performance of workflow executions in faulty execution environments. Experimental results show that failures can have significant impact on executions where task clustering policies are not fault-tolerant, and that our solutions yield makespan improvements in such scenarios. In addition, we propose a dynamic task clustering strategy to optimize the workflow's makespan by dynamically adjusting the clustering granularity when failures arise. A trace-based simulation of five real workflows shows that our dynamic method is able to adapt to unexpected behaviors, and yields better makespans when compared to static methods.

A Performance Characterization of Streaming Computing on Supercomputers

Streaming computing models allow for on-the-fly processing of large data sets. With the in-creased demand for processing large amount of data in a reasonable period of time, streaming models are more and more used on supercomputers to solve data-intensive problems. Because supercomputers have been mainly used for compute-intensive workload, supercomputer performance metrics focus on the number of floating point operations in time and cannot fully characterize a streaming application performance on supercomputers. We introduce the injection and processing rates as the main metrics to characterize the performance of streaming computing on supercomputers. We analyze the dynamics of these quantities in a modified STREAM benchmark developed atop of an MPI streaming library in a series of different configurations. We show that after a brief transient the injection and processing rates converge to sustained rates. We also demonstrate that streaming computing performance strongly depends on the number of connections between data producers and consumers and on the processing task granularity.

Optimization Strategies Oriented to Loop Characteristics in Software Thread Level Speculation Systems

Thread level speculation provides not only a simple parallel programming model, but also an effective mechanism for thread-level parallelism exploitation. The performance of software speculative parallel models is limited by high global overheads caused by different types of loops. These loops usually have different characteristics of dependencies and different requirements of optimization strategies. In this paper, we propose three comprehensive optimization techniques to reduce different factors of global overheads, aiming at requirements from different types of loops. Inter-thread fetching can reduce the high mis-speculation rate of the loops with frequent dependencies and out-of-order committing can reduce the control overhead of the loops with infrequent dependencies, while enhanced dynamic task granularity resizing can reduce the control overhead and optimize the global overhead of the loops with changing characteristics of dependencies. All these three optimization techniques have been implemented in HEUSPEC, a software TLS system. Experimental results indicate that they can satisfy the demands from different groups of benchmarks. The combination of these techniques can improve the performance of all benchmarks and reach a higher average speedup.