Task Dispatch Research Articles

Colored Petri Net model with automatic parallelization on real-time multicore architectures

This paper proposes a novel Colored Petri Net (CPN) based dynamic scheduling scheme, which aims at scheduling real-time tasks on multiprocessor system-on-chip (MPSoC) platforms. Our CPN based scheme addresses two key issues on task scheduling problems, dependence detecting and task dispatching. We model inter-task dependences using CPN, including true-dependences, output-dependences, anti-dependences and structural dependences. The dependences can be detected automatically during model execution. Additionally, the proposed model takes the checking of real-time constraints into consideration. We evaluated the scheduling scheme on the state-of-art FPGA based multiprocessor hardware system and modeled the system behavior using CPN tools. Simulations and state space analyses are conducted on the model. Experimental results demonstrate that our scheme can achieve 98.9% of the ideal speedup on a real FPGA based hardware prototype.

JETS: Language and System Support for Many-Parallel-Task Workflows

Many-task computing is a well-established paradigm for implementing loosely coupled applications (tasks) on large-scale computing systems. However, few of the model’s existing implementations provide efficient, low-latency support for executing tasks that are tightly coupled multiprocessing applications. Thus, a vast array of parallel applications cannot readily be used effectively within many-task workloads. In this work, we present JETS, a middleware component that provides high performance support for many-parallel-task computing (MPTC). JETS is based on a highly concurrent approach to parallel task dispatch and on new capabilities now available in the MPICH2 MPI implementation and the ZeptoOS Linux operating system. JETS represents an advance over the few known examples of multilevel many-parallel-task scheduling systems: it more efficiently schedules and launches many short-duration parallel application invocations; it overcomes the challenges of coupling the user processes of each multiprocessing application invocation via the messaging fabric; and it concurrently manages many application executions in various stages. We report here on the JETS architecture and its performance on both synthetic benchmarks and an MPTC application in molecular dynamics.

Parallel programming patterns for multi-processor SoC

Efficient, scalable and productive parallel programming is a major challenge for exploiting the future multi-processor SoC platforms. This article presents the MultiFlex programming environment which has been developed to address this challenge. It is targeted for use on Platform 2012 , a scalable multi-processor fabric. The MultiFlex environment supports high-level simulation, iterative platform mapping, and includes tools for programming model aware debug, trace, visualization and analysis. This article focuses on the two classes of programming abstractions supported in MultiFlex. The first is a set of Parallel Programming Patterns (PPP) which offer a rich set of programming abstractions for implementing efficient data- and task-level parallel applications. The second is a Reactive Task Management (RTM) abstraction, which offers a lightweight C-based API to support dynamic dispatching of small grain tasks on tightly coupled parallel processing resources. The use of the MultiFlex native programming model is illustrated through the capture and mapping of two representative video applications. The first is a high-quality rescaling (HQR) application on a multi-processor platform. We present the details of the optimization process which was required for mapping the HQR application, for which the reference code requires 350 GIPS (giga instructions per second), onto a 16 processor cluster. Our results show that the parallel implementation using the PPP model offers almost linear acceleration with respect to the number of processing elements. The second application is a high-definition VC-1 decoder. For this application, we illustrate two different parallel programming model variants, one using PPPs, the other based on RTM. These two versions are mapped onto two variants of a homogeneous version of the Platform 2012 multi-core fabric.

Formal analysis of a hardware dynamic task dispatcher with CADP

The complexity of multiprocessor architectures for mobile multimedia applications renders their validation challenging. In addition, to provide the necessary flexibility, a part of the functionality is realized by software. Thus, a formal model has to take into account both hardware and software. In this article we report on the use of the CADP toolbox for the formal modeling and analysis of the DTD (Dynamic Task Dispatcher), a complex hardware block of an industrial hardware architecture developed by STMicroelectronics. The formal LNT model developed by an industry engineer was appropriate to discuss implementation details with the architect and enabled model-checking temporal properties expressed in MCL, which discovered a possible problem. We investigated the existence of the problem in the architect’s C++ model using co-simulation of the C++ and the formal LNT models.

Executor Framework for DIRAC

DIRAC framework for distributed computing has been designed as a group of collaborating components, agents and servers, with persistent database back-end. Components communicate with each other using DISET, an in-house protocol that provides Remote Procedure Call (RPC) and file transfer capabilities. This approach has provided DIRAC with a modular and stable design by enforcing stable interfaces across releases. But it made complicated to scale further with commodity hardware.To further scale DIRAC, components needed to send more queries between them. Using RPC to do so requires a lot of processing power just to handle the secure handshake required to establish the connection. DISET now provides a way to keep stable connections and send and receive queries between components. Only one handshake is required to send and receive any number of queries. Using this new communication mechanism DIRAC now provides a new type of component called Executor. Executors process any task (such as resolving the input data of a job) sent to them by a task dispatcher. This task dispatcher takes care of persisting the state of the tasks to the storage backend and distributing them among all the Executors based on the requirements of each task.In case of a high load, several Executors can be started to process the extra load and stop them once the tasks have been processed. This new approach of handling tasks in DIRAC makes Executors easy to replace and replicate, thus enabling DIRAC to further scale beyond the current approach based on polling agents.

AN EFFICIENT FAULT TOLERANT SCHEDULING APPROACH FOR COMPUTATIONAL GRID

Grid computing serves as an important technology to facilitate distributed computation computational grids solve large scale scientific problems using heterogeneous geographically distributed resources. Problems like dispatching and scheduling of tasks are considered as major issues in computational grid environment. The Grid Scheduler must select proper resources for executing the tasks with less response time. There are various reasons such as network failure, overloaded resource conditions, or non-availability of required software components for execution failure. Thus, fault-tolerant systems should be able to identify and handle failures and support reliable execution in the presence of failures. Hence the integration of fault tolerance measures and communication time with scheduling gains much importance. In this study, a new fault tolerance based scheduling approach Fault Tolerant Min-Min (FTMM) for scheduling statically available meta tasks is proposed wherein failure rate and the fitness value are calculated. The performance of the fault tolerant scheduling policy is compared with min-min scheduling policy using GridSim and the results shows that the proposed policy performs better with less makespan in the presence of failures. The number of tasks successfully completed is also more when compared to the non-fault tolerant min-min scheduling policy. Thus the proposed FTMM algorithm not only achieves better hit rate but also improved makespan.

Efficient real-time divisible load scheduling

Providing QoS and performance guarantees to arbitrarily divisible loads has become a significant problem for many cluster-based research computing facilities. While progress is being made in scheduling arbitrarily divisible loads, current approaches are not efficient and do not scale well. In this paper, we propose a linear algorithm for real-time divisible load scheduling. Unlike existing approaches, the new algorithm relaxes the tight coupling between the task admission controller and the task dispatcher. By eliminating the need to generate exact schedules in the admission controller, the algorithm avoids high overheads. We also proposed a hybrid algorithm that combines the best of our efficient algorithm and a previously best-known approach. We experimentally evaluate the new algorithm. Simulation results demonstrate that the algorithm scales well, can schedule large numbers of tasks efficiently, and performs similarly to existing approaches in terms of providing real-time guarantees.

Dynamic parallelization of hydrological model simulations

This paper introduces the development of a dynamic parallel algorithm for conducting hydrological model simulations. This new algorithm consists of a river network decomposition method and an enhanced master–slave paradigm. The decomposition method is used to divide a basin river network into a large number of subbasins, and the enhanced master–slave paradigm is adopted to realize the function of this new dynamic basin decomposition method through using the Message-Passing Interface (MPI) and C++ language. This new algorithm aims to balance computation load and then to achieve a higher speedup and efficiency of parallel computing in hydrological simulation for the river basins which are delineated by high-resolution drainage networks. This paper uses a modified binary-tree codification method developed by Li et al. (2010) to code drainage networks, and the basin width function to estimate the possible maximum parallel speedup and the associated efficiency. As a case study, with a hydrological model, the Digital Yellow River Model, this new dynamic parallel algorithm is applied to the Chabagou basin in northern China. The application results reveal that the new algorithm is efficient in the dynamic dispatching of simulation tasks to computing processes, and that the parallel speedup and efficiency are comparable with the estimations made by using the basin width function.

MoneyBee: Towards enabling a ubiquitous, efficient, and easy-to-use mobile crowdsourcing service in the emerging market

We present a mobile crowdsourcing platform called MoneyBee that is accessible to mobile phone users in emerging markets through their mobile operators. The operator has a large subscriber base and the ability to pay task workers using prepaid airtime minutes. These advantages allow MoneyBee to reach far more people than conventional Internet crowdsourcing approaches. The mobile operator already has access to information on user demographics, location and presence, and monthly spending patterns. In addition, the MoneyBee platform gathers user information (such as preferences, skills, and reliability) from a user's interaction with the crowdsourcing service. Using this data to intelligently assign crowd-sourcing tasks to relevant workers is a challenging problem. Similarly, efficient dispatching of tasks to minimize the network load on the operator network is equally important. Further, simple interfaces (including speech) are needed to submit as well as execute crowdsourcing tasks on the mobile device. We describe initial solutions to some of these challenges in this paper.

Middleware support for many-task computing

Many-task computing aims to bridge the gap between two computing paradigms, high throughput computing and high performance computing. Many-task computing denotes high-performance computations comprising multiple distinct activities, coupled via file system operations. The aggregate number of tasks, quantity of computing, and volumes of data may be extremely large. Traditional techniques found in production systems in the scientific community to support many-task computing do not scale to today's largest systems, due to issues in local resource manager scalability and granularity, efficient utilization of the raw hardware, long wait queue times, and shared/parallel file system contention and scalability. To address these limitations, we adopted a "top-down" approach to building a middleware called Falkon, to support the most demanding many-task computing applications at the largest scales. Falkon (Fast and Light-weight tasK executiON framework) integrates (1) multi-level scheduling to enable dynamic resource provisioning and minimize wait queue times, (2) a streamlined task dispatcher able to achieve orders-of-magnitude higher task dispatch rates than conventional schedulers, and (3) data diffusion which performs data caching and uses a data-aware scheduler to co-locate computational and storage resources. Micro-benchmarks have shown Falkon to achieve over 15K+ tasks/s throughputs, scale to hundreds of thousands of processors and to millions of queued tasks, and execute billions of tasks per day. Data diffusion has also shown to improve applications scalability and performance, with its ability to achieve hundreds of Gb/s I/O rates on modest sized clusters, with Tb/s I/O rates on the horizon. Falkon has shown orders of magnitude improvements in performance and scalability than traditional approaches to resource management across many diverse workloads and applications at scales of billions of tasks on hundreds of thousands of processors across clusters, specialized systems, Grids, and supercomputers. Falkon's performance and scalability have enabled a new class of applications called Many-Task Computing to operate at previously so-believed impossible scales with high efficiency.

A multi-core based parallel streaming mechanism for concurrent video-on-demand applications

In this paper, we design a novel Multi-Core based Parallel Streaming Mechanism for concurrently streaming the scalable extension of H.264/AVC videos, which is called MCPSM. MC-PSM is able to serve lots of heterogeneous users who may utilize distinct terminals through distinct network interfaces to get on-demand videos from an ISP streaming server at meanwhile. With the concept of CPU scheduling- SJF (Shortest- Job-First) and multi-core based parallel programming, multiple streaming tasks can be executed in parallel using a proposed task dispatcher based on network connection speeds, video bit-rate and users' waiting time. Comparing with a normal-threading streaming approach, the average execution time can decrease effectively and CPU resources can be utilized more fully.

A dependable Peer-to-Peer computing platform

This paper discusses a dependable and widely applicable Peer-to-Peer (P2P) computing platform. As the existing P2P computing platforms are limited due to the lack of support for various computational models, this paper proposes a workflow management mechanism to support task dependency in parallel programs while increasing computing efficiency. In general, task dependency leads to a serious performance degradation for failed task re-execution because of volatile peers. Therefore, it results in low dependability. Here, dependability is defined as a comparison of the actual performance with task failures to the theoretical one without failure on a P2P computing platform. Redundant task dispatch and a runtime optimization method are proposed to guarantee high dependability even with highly volatile peers. Large-scale simulation results indicate that the computing platform efficiently solves the problem of P2P computing due to volatile peers.

Two-stage scheduling algorithm based on priority table for clusters with inaccurate system parameters

A new two-stage soft real-time scheduling algorithm based on priority table was proposed for task dispatch and selection in cluster systems with inaccurate parameters. The inaccurate characteristics of the system were modeled through probability analysis. By taking into account the multiple important system parameters, including task deadline, priority, session integrity and memory access locality, the algorithm is expected to achieve high quality of service. Lots of simulation results collected under different load conditions demonstrate that the algorithm can not only effectively overcome the inaccuracy of the system state, but also optimize the task rejected ratio, value realized ratio, differentiated service guaranteed ratio, and session integrity ensured ratio with the average improvement of 3.5%, 5.8%, 7.6% and 5.5%, respectively. Compared with many existing schemes that cannot deal with the inaccurate parameters of the system, the proposed scheme can achieve the best system performance by carefully adjusting scheduling probability. The algorithm is expected to be promising in systems with soft real-time scheduling requirement such as E-commerce applications.

An improved rate-monotonic admission control and its applications

Rate-monotonic scheduling (RMS) is a widely used real-time scheduling technique. This paper proposes RBound, a new admission control for RMS. RBound has two interesting properties. First, it achieves high processor utilization under certain conditions. We show how to obtain these conditions in a multiprocessor environment and propose a multiprocessor scheduling algorithm that achieves a near optimal processor utilization. Second, the framework developed for RBound remains close to the original RMS framework (that is, task dispatching is still done via a fixed-priority scheme based on the task periods). In particular, we show how RBound can be used to guarantee a timely recovery in the presence of faults and still achieve high processor utilization. We also show how RBound can be used to increase the processor utilization when aperiodic tasks are serviced by a priority exchange server or a deferrable server.

Dynamic Dispatching of Cyclic Real-Time Tasks with RelativeTiming Constraints

In some hard real-time systems, relative timing constraints may be imposed on task executions, in addition to the release time and deadline constraints. Relative timing constraints such as separation or relative deadline constraints may be given between start or finish times of tasks (Gerber et al., 1995; Han and Lin, 1989; Han et al., 1992; Han and Lin, 1992; Han et al., 1996). One approach in real-time scheduling is to find a total order on a set of N tasks in a scheduling window, and cyclically use this order at run time to execute tasks. However, in the presence of relative timing constraints, if the task execution times are nondeterministic with defined lower and upper bounds, it is not always possible to statically assign task start times at pre-runtime for a given task ordering (Gerber et al., 1995). We develop a technique called dynamic cyclic dispatching as an extension of a parametric dispatching mechanism in (Gerber et al., 1995). An ordered set of N tasks is assumed to be given in a scheduling window and this schedule(ordering) is cyclically repeated at runtime in consecutive scheduling windows. Relative timing constraints between tasks may be defined across scheduling window boundaries as well as within one scheduling window. A task set is defined to be dispatchable if there exists any way in which the tasks can be dispatched with all their timing constraints satisfied. An off-line algorithm is presented to check the dispatchability of a task set and to obtain parametric lower and upper bound functions for task start times if the task set is dispatchable. These parametric bound functions are evaluated at runtime to obtain a valid time interval during which a task can be started. The complexity of this off-line component is shown to be O(n^2N^3) where n is the number of tasks in a scheduling window that have relative timing constraints with tasks in the next scheduling window. An online algorithm can evaluate these bounds in O(N) time. Unlike static approaches which assign fixed start times to tasks in the scheduling window, our approach allows us to flexibly manage the slack times at runtime without sacrificing the dispatchability of tasks. Also, a wider class of relative timing constraints can be imposed to the task set compared to the traditional approaches.

Parametric dispatching of hard real-time tasks

In many real-time systems relative timing constraints are imposed on a set of tasks. Generating a correct ordering for the tasks and deriving their proper start-time assignments is an NP-hard problem; it subsumes the non-preemptive scheduling problem. Even when the application imposes a total order on the tasks, generating proper start-times is still nontrivial if execution times may range between upper and lower bounds. We present the technique of parametric dispatching to enforce such timing constraints. During an off-line component, we check if the constraints can be guaranteed. If so, a calendar is produced that allows our on-line algorithm to generate upper and lower bounds on the start time of each task, based on the start times and execution times of previous tasks. A suitable start time for the task may then be selected taking into account the presence of other non-critical tasks in the system.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Inherently stable real-time priority list dispatchers

This paper concerns the problem of scheduling instability, where reducing the duration of one or more tasks delays the starting time of another task. This can make it difficult or impossible to guarantee real-time deadlines. Unfortunately, simulating schedules with all possible variations in the durations of all tasks is in most cases an intractable problem. Therefore, task dispatching must be provably stable for all permissible variations in durations. To alleviate scheduling instability, we have developed a new class of provably stable runtime dispatchers that are less restrictive than known stabilization algorithms. Extensive simulations show that even the simple, low-overhead dispatchers perform remarkably well. These results suggest that is better. Developers of hard real-time systems can implement fast, simple low-overhead runtime task dispatchers that guarantee stability but still deliver near-optimal performance. >

Computer Modelling - A Complete Case Study For The Mvs Computer System

Coumpter models are now being used for computer system evaluation as well as computer tuning. In this respect, the model must be responsive to the hardware/software characteristics and the operating system under control. This paper addresses the problem of developing a model for virtual memory computer systems which fulfills these requirements.A brief description of the 0S/VS2 MVS is presented, discussing in detail, the features which impact the behavior of the model in question. For each class of transactions, three different times are considered: thinking, waiting, and active time. The computer model has two major components or sub-models: the scheduler sub-model and the queueing sub-model. The scheduler submodel involves the mathematical description of the SRM (System Resources Manager) and the task dispatcher. To obtain a simplified version of it (closed-form solution), GPSS has been used as an intermediate tool. The queueing sub-model involves the CPU and peripheral equipment., These components are treated as a network of processors in which a transaction goes from one processor to another, receiving service at each one of them until completion. The network is considered to be closed.To thoroughly validate such a model, an application to evaluate the performance of an IBM/3032 operating under MVS is included. This application is analyzed step by step and comparisons between model results and computer system measurements are discussed. This analysis leads to a systematic approach for computer model development.