The computational grid provides a promising platform for the efficient execution of parameter sweep applications over very large parameter spaces. Scheduling such applications is challenging because target resources are heterogeneous, because their load and availability varies dynamically, and because independent tasks may share common data files. We propose an adaptive scheduling algorithm for parameter sweep applications on the grid. We modify standard heuristics for task/host assignment in perfectly predictable environments (max-min, min-min, Sufferage), and we propose an extension of Sufferage called XSufferage. Using simulation, we demonstrate that XSufferage can take advantage of file sharing to achieve better performance than the other heuristics. We also study the impact of inaccurate performance prediction on scheduling. Our study shows that: different heuristics behave differently when predictions are inaccurate; and an increased adaptivity leads to better performance.
RsdEditor is a graphical user interface which produces specifications of computational resources. It is used in the RSD (Resource and Service Description) environment for specifying, registering, requesting and accessing resources and services in a metacomputer. RsdEditor was designed to be used by the administrators and users of metacomputing environments. At the administrator level, the GUI is used to describe the available computing and networking components of a metacomputer. At the user level, RsdEditor can be used to specify which characteristics of the computational resources are needed to execute a meta-application. This paper is organized as follows: it first introduces RsdEditor. It then briefly describes the RSD environment, and finally, it highlights various features and implementation issues of RsdEditor.
The min-min algorithm is a simple algorithm. It runs fast and delivers good performance. However, the min-min algorithm schedules small tasks first, resulting in some load imbalance. We present an algorithm which improves the min-min algorithm by scheduling large tasks first. The new algorithm, segmented min-min, balances the load well and demonstrates even better performance in both makespan and running time.
We propose to use a duplication based approach in scheduling tasks for a heterogeneous cluster of PCs. In duplication based scheduling, critical tasks are redundantly scheduled to more than one machine in order to reduce the number of inter-task communication operations. The start times of the succeeding tasks are also reduced. The task duplication process is guided given the system heterogeneity in that the critical tasks are scheduled or replicated in faster machines. The algorithm has been implemented in our prototype program parallelization tool for generating MPI code executable on a cluster of Pentium PCs. Our experiments using three applications have indicated that the heterogeneity of a PC cluster, being an inevitable feature, is indeed useful for optimizing the execution of parallel programs.
Metacomputing frameworks have received renewed attention of late, fueled both by advances in hardware and networking, and by novel concepts such as computational grids. HARNESS is an experimental metacomputing system based upon the principle of dynamic reconfigurability, not only in terms of the computers and networks that comprise the virtual machine (VM), but also in the capabilities of the VM itself. These characteristics may be modified under user control via a “plug-in” mechanism that is the central feature of the system. The system's capabilities have been used to develop a PVM compatibility suite, i.e. a set of plug-ins that allow users to run PVM applications of top of HARNESS. In this paper, we describe the PVM-Proxy plug-in, which is capable of gluing PVM applications to distributed object environments
Computational Grids have become an important and popular computing platform for both scientific and commercial distributed computing communities. However, users of such systems typically find achievement of application execution performance remains challenging. Although Grid infrastructures such as Legion and Globus provide basic resource selection functionality, work allocation functionality, and scheduling mechanisms, applications must interpret system performance information in terms of their own requirements in order to develop performance-efficient schedules.We describe a new high-performance scheduler that incorporates dynamic system information, application requirements, and a detailed performance model in order to create performance efficient schedules. While the scheduler is designed to provide improved performance for a magneto hydrodynamics simulation in the Legion Computational Grid infrastructure, the design is generalizable to other systems and other data-parallel, iterative codes. We describe the adaptive performance model, resource selection strategies, and scheduling policies employed by the scheduler. We demonstrate the improvement in application performance achieved by the scheduler in dedicated and shared Legion environments.
An emerging model for computational grids interconnects similar multi-resource servers from distributed sites. A job submitted to the grid can be executed by any of the servers; however, resource size or balance may be different across servers. One approach to resource management for this grid is to layer a global load distribution system on top of the local job management systems at each site. Unfortunately, classical load distribution policies fail on two aspects when applied to a multi-resource server grid First, simple load indices may not recognize that a resource imbalance exists at a server. Second, classical job selection policies do not actively correct such a resource-imbalanced state. We show through simulation that new policies based on resource balancing perform consistently better than the classical load distribution strategies
Recently (Proc. ACM Int. Conf. on Supercomput., 1999), we presented two very low-cost approaches to compile-time list scheduling where the tasks' priorities are computed statically or dynamically. For homogeneous systems, these two algorithms, called FCP (Fast Critical Path) and FLB (Fast Load Balancing), respectively, have been shown to yield a performance equivalent to other much more costly algorithms, such as MCP and ETF (Earliest Task First). In this paper, we present modified versions of FCP and FLB targeted at heterogeneous systems. We show that the modified versions yield a good overall performance, which is generally comparable to algorithms specifically designed for heterogeneous systems, such as HEFT (Heterogeneous Earliest Finish Time) or ERT (which are versions of MCP and ETF, respectively, using the task's completion time as the task priority). There are a few cases, mainly for irregular problems and large processor speed variance, where FCP's and FLB's performances drop to 32% and 63%, respectively. Considering the good overall performance and their very low cost, however, FCP and FLB are interesting options for scheduling very large problems on heterogeneous systems.
It is often the case in Heterogeneous Computing (HC) systems that an application requires multiple resources of different types to be allocated simultaneously. In general, this problem is the resource co-allocation problem. In this paper, we develop a general framework for mapping a collection of applications with resource co-allocation requirements. In our framework, application tasks have two types of constraints to be satisfied: precedence constraints and resource sharing constraints. We use a graph theoretic framework to capture these constraints. A Directed Acyclic Graph is used to represent precedence constraints of tasks within an application and a Compatibility Graph is used to represent resource sharing constraints among tasks of applications. Both these graphs are used to find maximal independent sets of tasks that can be executed concurrently.The objective of the mapping is to minimize the overall schedule length for a given set of applications. We develop heuristic algorithms to solve the mapping problem with resource co-allocation constraints. We also provide a two-phase algorithm that can be used for run-time adaptation. We conducted extensive simulation experiments to evaluate the performance of our heuristic algorithms. Simulation results for our algorithms show a performance improvement of 10% to 30% over a baseline algorithm of list scheduling which considers only the precedence constraints and allocates tasks from the resulting order. This paper demonstrates the importance of considering the co-allocation requirements when mapping applications in heterogeneous computing environments including grid environments.
Presents the results of the NRW-Metacomputing Taskforce, which has been working on the development of a (German) country-wide metacomputer since 1996. The resulting installation is among the very few that are already operational, have full support for heterogeneous resources, contain a decent security model and feature an advanced scheduling subsystem for the metacomputing environment. The NRW-Metacomputer has been implemented using a modular software architecture. Hence, its concepts and components can be re-used by others without the need to obtain the metacomputing software as a whole. Furthermore, the NRW-Metacomputer already provides well-defined interfaces for linking the system with other metacomputing environments to form a truly global computational grid. Distinctive features of this system are its highly scalable and fault-tolerant software architecture, its advanced resource planning mechanisms, as well as an integration into a DCE (Distributed Computing Environment)/DFS (Distributed File System) environment
Resource selection is fundamental to the performance of master/slave applications. In this paper, we address the problem of promoting performance for distributed master/slave applications targeted to distributed, heterogeneous "Grid" resources. We present a work-rate-based model of master/slave application performance which utilizes both system and application characteristics to select potentially performance-efficient hosts for both the master and slave processes. Using a Grid allocation strategy based on this performance model, we demonstrate a performance improvement over other selection options for a representative set of master/slave applications in both simulated and actual Grid environments.
In a serverless cluster of PCs or workstations, the cluster must allow remote file accesses or parallel I/O directly performed over disks distributed to all client nodes. We introduce a new distributed disk array, called the RAID-x, for use in serverless clusters. The RAID-x architecture is based on an orthogonal striping and mirroring (OSM) scheme, which exploits full-bandwidth and protects the system from all single disk failures.The performance of the RAID-x is experimentally proven superior to RAID-1 and NFS in the Linux cluster environment. We propose a new striped checkpointing scheme, leveraging on striped parallelism and pipelined writing of successive disk stripes. This RAID-x architecture greatly enhances the throughput, reliability, and availability of scalable clusters. It appeals especially to I/O-centric cluster applications.
Providing up-to-date input to users' applications is an important data management problem for a heterogeneous distributed computing environment, where each data storage location and intermediate node may have different data available, different storage limitations and different communication links available. Sites in the heterogeneous network request data items, and each request has an associated deadline and priority. In a military situation, the data staging problem involves positioning data for facilitating a faster access time when it is needed by programs that will aid in decision making. This work concentrates on solving a basic version of the data-staging problem in which all parameter values for the communication system and the data-request information represent the best-known information collected so far, and they stay fixed throughout the scheduling process. The heterogeneous network is assumed to be over-subscribed, and not all requests for data items can be satisfied. Three multiple-source, shortest-path algorithm-based procedures for finding a near-optimal schedule of the communication steps for staging the data are described. Each procedure can be used with each of three cost criteria developed in this paper (based on results from earlier experiments). A subset of the possible procedure/cost criterion combinations are evaluated in simulation studies considering different priority weighting schemes, different average numbers of links used to satisfy each data request, and different network loadings. The proposed heuristics are shown to perform well with respect to upper and lower bounds.
Gardens is an integrated programming language and system designed to support parallel computing across nondedicated cluster computers, in particular networks of PCs. To utilise non-dedicated machines a program must adapt to those currently available. In Gardens this is realised by over decomposing a program into more tasks than processors, and migrating tasks to implement adaptation. To be effective this requires efficient task migration. Furthermore, typically non-dedicated clusters contain different machines hence heterogeneous task migration is required. Gardens supports efficient task migration between heterogeneous machines via meta-information which completely describes a task's state. By identifying different degrees of heterogeneity and different kinds of tasks, we are able to optimise task migration. The main contribution is to show how heterogeneous task migration may be optimised.
A distributed heterogeneous computing (HC) system consists of diversely capable machines harnessed together to execute a set of tasks that vary in their computational requirements. Heuristics are needed to map (match and schedule) tasks onto machines in an HC system so as to optimize some figure of merit. This paper characterizes a simulated HC environment by using the expected execution times of the tasks that arrive in the system onto the different machines present in the system. This information is arranged in an “expected time to compute” (ETC) matrix as a model of the given HC system, where the entry (i, j) is the expected execution time of task i on machine j. This model is needed to simulate different HC environments to allow testing of relative performance of different mapping heuristics under different circumstances. In particular the ETC model is used to express the heterogeneity among the runtimes of the tasks to be executed, and among the machines in the HC system. An existing range-based technique to generate ETC matrices is described. A coefficient-of-variation based technique to generate ETC matrices is proposed, and compared with the range-based technique. The coefficient-of-variation-based ETC generation method provides a greater control over the spread of values (i.e., heterogeneity) in any given row or column of the ETC matrix than the range-based method
Presents the results of a project aimed at assembling a hybrid massively parallel machine, the PQE1 prototype, which is devoted to the simulation of complex physical models. The analysis of some existing parallel architectures has revealed that general-purpose machines are largely over-dimensioned and often perform inefficiently in grand-challenge scientific applications. We have thus developed a heterogeneous parallel system which matches task heterogeneity with architecture heterogeneity: in fact, special-purpose massively parallel architectures, when coupled to general-purpose machines, are able to satisfy the requirements of complex scientific computing efficiently. We present the hardware structure and the software tools that have been developed for the PQE1 prototype. Starting from the concepts of machine granularity and task granularity, we show the necessity to exploit both high- and low-granularity parallelism in order to use the PQE1 system efficiently. Some examples showing application fields in which the PQE1 prototype has been successfully used are briefly described.
The Portable Parallel/Distributed Debugger project at the NASA Ames Research Center has built a debugger for applications running on heterogeneous computational grids. It employs client-server architecture to simplify the implementation, and its user interface has been designed to provide process control and state examination functions on computations with a large number of processes. The debugger can find processes participating in distributed computations even when those processes were not created under debugger control. In addition to working in a computational grid environment, these techniques also work on other distributed memory jobs such as those initiated by mpirun.
Enforcement of a high-level statement of security policy may be difficult to discern when mapped through functional requirements to a myriad of possible security services and mechanisms in a highly complex, networked environment. A method for articulating network security functional requirements, and their fulfillment, is presented. Using this method, security in a quality of service framework is discussed in terms of variant security mechanisms and dynamic security policies. For illustration, it is shown how this method can be used to represent Quality of Security Service (QoSS) in a network scheduler benefit function.
Computational grids are becoming an increasingly important and powerful platform for the execution of large-scale, resource-intensive applications. However, it remains a challenge for applications to tap into the potential of grid resources in order to achieve performance. In this paper, we illustrate how work queue applications can leverage grids to achieve performance through coallocation. We describe our experiences in developing a scheduling strategy for a production tomography application targeted at grids that contain both workstations and parallel supercomputers. Our strategy uses dynamic information exported by a supercomputer's batch scheduler to simultaneously schedule tasks on workstations and immediately-available supercomputer nodes. This strategy is of great practical interest because it combines resources that are available in a typical research laboratory: time-shared workstations and CPU time in remote space-shared supercomputers. We show that this strategy improves the performance of the tomography application compared to traditional scheduling strategies, which target the application to either type of resource alone
