Scheduling Algorithms for Multiple Bag-of-Task Applications on Desktop Grids: a Knowledge-Free Approach

Transcription

1 Scheduling Algorithms for Multiple Bag-of-Task Applications on Desktop Grids: a Knowledge-Free Approach Cosimo Anglano, Massimo Canonico Dipartimento di Informatica, Università del Piemonte Orientale (Italy), {cosimo.anglano,massimo.canonico}@unipmn.it Abstract Desktop Grids are being increasingly used as the execution platform for a variety of applications that can be structured as Bag-of-Tasks (BoT). Scheduling BoT applications on Desktop Grids has thus attracted the attention of the scientific community, and various schedulers tailored towards them have been proposed in the literature. However, previous work has focused on scheduling a single BoT application at a time, thus neglecting other scenarios in which several users submit multiple BoT applications at the same time. This paper aims at filling this gap by proposing a set of scheduling algorithms able to deal with multiple BoT applications. The performance of these algorithm has been evaluated, by means of simulation, for a large set of operational scenarios obtained by varying both the workload submitted to the Desktop Grid and the characteristics of the involved resources. Our results show that, although there is no a clear winner among the proposed solutions, knowledge-free strategies (that is, strategies that do not require any information concerning the applications or the resources) can provide good performance. 1. Introduction The exploding popularity of the Internet has created a new much large scale opportunity for Grid computing. As a matter of fact, millions of desktop PCs, whose idle cycles can be exploited to run Grid applications, are connected to wide-area networks both in the enterprise and in the home. These new platforms for high throughput applications are called Desktop Grids [6, 14], and provide an amount of raw computing power far exceeding that provided by more traditional Grid platforms that include a lower number of more powerful resources (e.g., high-performance clusters). The inherent wide distribution, heterogeneity, and dynamism of Desktop Grids makes them better suited to the execution of loosely-coupled parallel applications rather than tightlycoupled ones. Bag-of-Tasks applications (BoT) [8, 19] (parallel applications whose tasks are completely independent from one another) have been shown [11] to be particularly able to exploit the computing power provided by Desktop Grids and, despite their simplicity, are used in a variety of domains, such as parameter sweeps, simulations, fractal calculations, computational biology, and computer imaging. In order to take advantage of Desktop Grid environments, suitable scheduling strategies, tailored to BoT applications, must be adopted. More specifically, these strategies must be able to deal with the heterogeneity of resources, the fluctuations in the performance they deliver because of the simultaneous execution of competing applications, and their failures due to crashes/reboots or unplanned departures from the Grid. In response to this need, various scheduling algorithms have been proposed in the literature [2, 3, 11, 15, 16, 23], that typically attempt to minimize the makespan of BoT applications (that is, the time taken to execute all the tasks in a bag) in spite of resource heterogeneity, performance fluctuation, and failures. Although these algorithms employ different techniques to achieve their goal, they are based on the assumption that at any time there is a single bag to schedule, that is all the tasks that must be scheduled belong to one bag. Therefore, they focus on choosing which task to execute next (task selection), and the machine on which it will be executed (machine selection), but not on how to select the bag from which the tasks has to be picked (bag selection). While this assumption can be considered reasonable in situations where there is a single application that exclusively uses the resources of the Desktop Grid (e.g., like in volunteer-computing projects [1, 10] where a stream of identical tasks belonging to the same application is run on the Desktop Grid), in more general cases where the same computing infrastructure is shared by many competing applications it clearly does not hold. For instance, generalpurpose Desktop Grid computing platforms (such as Our- Grid [7] or the commercial solutions proposed by various vendors like Entropia [5], United Devices [21], Platform Computing [18], and Data Synapse [20]) are able to run various applications at the same time. However, in spite of

2 the above consideration, the problem of scheduling multiple BoT applications simultaneously executed on the same Desktop Grid has not been studied yet in a systematic way. The purpose of this paper is thus to fill this gap by proposing several scheduling algorithms, and by comparing their performance by means of a thorough simulation study in order to identify the scenarios in which each strategy performs best. We follow a knowledge-free approach, that is we assume that no information concerning the resources (e.g., the computing power they deliver to Grid applications or their availability) or the applications (e.g., the execution time of tasks) is available to the scheduler. This approach founds its motivation in the observation that especially in highlyvolatile distributed systems this information can be hard to collect and is often inaccurate. As shown in various papers [3, 9, 11], knowledge-free strategies can provide performance comparable to knowledge-based alternatives (that instead rely on various types and amounts of information) at the price of using more resources than strictly necessary. We evaluate the performance of the resulting algorithms, by means of simulation, for a large set of operational scenarios obtained by combining four different Desktop Grid configurations with various BoT workloads. Our results show that (a) naive bag selection policies (e.g., FCFS) often result in unacceptably low performance, thus motivating our quest for more sophisticated alternatives, and (b) effective scheduling of multiple BoT applications is possible by using relatively simple knowledge-free bag selection policies. The rest of the paper is organized as follows. Section 2 discussed related work, while in Section 3 we precisely define the scheduling problem for multiple BoT applications, and we present our scheduling algorithms. In Section 4 we describe the results we obtained in our evaluation experiments. Finally, Section 5 concludes the paper and outlines future research work. 2. Related work In the recent past, the problem of scheduling individual BoT applications on Desktop Grid has been actively studied. The scheduling algorithms proposed in the literature can be classified either as knowledge-free or knowledgebased. Knowledge-based algorithms [15, 2, 16] assume that some information concerning the resources (e.g., the computing power they deliver to applications, their availability, etc.), the applications (e.g., the execution times of the tasks), or both is available to the scheduler, that can use it to make informed decisions. Various algorithms have been proposed in the literature, that differ in the type and the amount of information they require. Conversely, knowledge-free algorithms [23, 3, 11] do not rely on any information concerning applications and resources, and typically trade resource cycles for information by wasting some computing power in order to mitigate the effects due to poor scheduling decisions caused by the lack of information. Knowledge-free algorithms have been indeed shown [9] to be able to obtain performance comparable to knowledge-based ones at the price of using more resources than strictly necessary. For scenarios in which plenty of computing resources are assumed to be available, they thus represent a viable solution since are very simple to implement, but at the same time yield performance comparable to those attained by knowledge-based schedulers. Although the above scheduling algorithms are able to effectively schedule BoT applications in the hypothesis that they arrive one at a time (that is, at any single time only one BoT is present in the system), they do not consider scenarios in which multiple BoT applications must be scheduled. Multiple BoT scheduling requires indeed the adoption of a bag selection policy in charge of choosing, among a set of BoTs waiting to be scheduled, from which one the next task to be dispatched will be chosen. As anticipated in the Introduction, however, the bag selection problem has not been systematically studied in the literature, where in general simple solutions like FCFS [13, 5] or random selection [9] are used. Unfortunately, as shown later in this paper, these simple solutions fail to provide adequate performance. The only different solution that considers multiple BoTs we are aware of [4] is not knowledge-free, as it requires a relatively high amount of information, and does not apply to Desktop Grids, since it focuses on distributed computing platforms that exhibit a tree-like communication topology and include only resources that do not fail. 3. Scheduling algorithms for multiple Bag-of- Task applications In this paper we deal with the problem of scheduling a set of competing BoT applications that are submitted for execution on a Desktop Grid by a community of potentially distinct users. The execution of different BoT applications can thus overlap in time, so at any given instant multiple applications may be waiting to be scheduled. The goal of the scheduler consists in minimizing the turnaround time of BoTs, that is given by the sum of the waiting time (that is, the total amount of time that the tasks of a BoT wait in the queue before being scheduled) and of the makespan (that is, the time elapsing from the beginning of the execution of its first task to the completion of the last one). This problem can be further decomposed in two independent subproblems: (a) bag selection, that consists in deciding from which BoT the next task to be dispatched will be chosen, and (b) individual bag scheduling, that consists in choosing which task from the chosen BoT will be actually executed next. This problem decomposition naturally leads to a two-steps scheduling approach in which bag selection is

3 performed first, and then an individual bag scheduling step follows. In this paper we focus on bag selection since, as discussed in Section 2, the individual bag scheduling problem has been thoroughly studied and various solutions that can be readily adopted already exist in the literature. We propose five different bag selection policies that, when combined with an individual BoT scheduler, give rise to five different scheduling algorithms. As anticipated in the Introduction, we adopt a knowledge-free approach to bag selection, that is our policies do not rely on any information concerning the resources of the Desktop Grid or the characteristics of the applications. Coherently with this choice, we adopt a knowledge-free scheduling algorithm also for individual bag scheduling, namely the WQR-FT [3] algorithm System model In our work we consider a Desktop Grid composed by a set of independently-owned machines, connected by a public production network (e.g., the Internet). We assume that these resources may fail, or may be reclaimed by the respective owner, at any time and without any advance notice. We also assume that scheduling is performed by a centralized scheduler, that receives all the BoT submissions and uses a separate queue to held the tasks of a particular BoT that still have to be completed (pending tasks). More specifically, each time a new BoT enters the system, the scheduler creates a new queue, in which it places all its tasks, that is removed when the BoT is completed Individual BoT scheduling As already mentioned, the scheduling algorithms proposed in this paper use WQR-FT as the scheduler for individual BoTs since, as shown [3], it provides performance better than its knowledge-free alternatives. WQR-FT is a knowledge-free scheduler that extends the WQR algorithm [11] by adding to it checkpointing and automatic resubmission of failed tasks. WQR in turn extends the classical WorkQueue algorithm, that chooses the tasks in a BoT in an arbitrary order and dispatches them on the resources as soon as they become available, by adding replication. More specifically, after the last task has been scheduler, WQR creates replicas of already-running tasks and assigns them to the resources that become free until a predefined replication threshold is reached 1. WQR-FT works as WQR when there are no faults, but when a task fails a new replica is automatically created from the latest checkpoint. A careful task selection policy is used in order to coordinate the scheduling 1 We assume that the Desktop Grid encompassed one or more Checkpoint Server, in charge of storing and providing access to checkpoints, and that for each application the checkpoint frequency is set according to the classical Young s formula [22]. of faulty and non-faulty task replicas, so that fault-tolerance and good application performance can be simultaneously achieved. In this paper, unless otherwise noted, we set the replication threshold of WQR-FT to 2, that is the scheduler attempts to always have two running replicas per task. This choice is motivated by the fact that, as discussed in [3], using higher replication threshold values brings negligible performance benefits at the price of a much higher overhead due to the larger number of replicas per task. The complete discussion of WQR-FT is outside the scope of this paper. The interested reader may refer to [3] for more details Bag selection policies When a running task completes it execution, and thus frees the machine on which it was running, the scheduler activates and performs bag selection. In this paper we consider the following five knowledge-free bag selection policies: 1. First Come First Served - Exclusive (FCFS-Excl): BoT applications are scheduled in order of arrival. All the resources of the Desktop Grid are exclusively allocated to the currently running BoT, that is no task of any other BoT is executed until the current BoT is completed. In order to fully exploit all the resources, we raise the replication threshold of WQR-FT to a potentially unlimited value. This corresponds to say that when there are no longer pending tasks for the current BoT the machines that become free are kept busy by starting additional replicas of the tasks that are still running (in the worst case, the last running task will have as many replicas as the number of machines in the Desktop Grid); 2. First Come First Served - Shared (FCFS-Share): variant of FCFS-Excl in which the Desktop Grid is not exclusively allocated to a single BoT. As FCFS-Excl, BoTs are scheduled according to FCFS but a machine that completes its task is allocated to the BoT that comes next in the FCFS order if the currently first BoT has no longer pending tasks. It should be noted that if a replica of a failed task of the first BoT must be scheduled, this replica will have priority over tasks belonging to the second BoT; 3. Round Robin (RR): in this policy, the queues corresponding to the BoTs are inspected in a fixed circular order; this policy corresponds to the random bag selection strategy described in [9], where all BoTs are chosen with equal probability; 4. Round Robin - No Replica First (RR-NRF): as RR, but gives priority to BoTs that do not have any task instance running. That is, when the scheduler is trig-

4 gered, the circular order of BoT selection is temporarily suspended, and is restarted later when all the BoTs have at least a task running; 5. Longest Idle (LongIdle): this policy is motivated by the consideration that the turnaround time is often dominated by the waiting time, especially for high workload intensities. This policy attempts to reduce waiting time by giving preference to the BoT hosting the task that exhibits the largest waiting time. The waiting time of a task is defined as the total amount of time in which the task has no running replicas. It is worth to point out that this policy behaves like FCFS-Share when the currently running bag has still pending tasks without replicas. As a matter of fact, in this case the pending tasks of a given BoT will always exhibit a larger amount of idle time with respect to tasks belonging to BoT submitted later. In contrast, LongIdle will start choosing BoTs different from the oldest one only when all its tasks have at least a replica running. 4. Experimental evaluation In order to asses the effectiveness of the proposed scheduling policies, we performed an exhaustive study, carried out by means a discrete-event simulator, in which we compared their performance for a large set of operational scenarios, obtained by combining a set of Desktop Grid configurations with a set of application workloads. Scheduling strategies were compared in terms of the average turnaround time experienced by BoT applications, defined at the average time elapsing from the arrival of the BoT application to the scheduler to the completion of its last task. In the rest of this section we describe the Desktop Grid configurations first (Section 4.1), we continue with the description of the workloads (Section 4.2), and then we conclude with the results obtained in our simulation experiments (Section 4.3) Desktop Grid configurations For our study, we considered six Desktop Grid configurations, differing from each other in the availability of the resources composing the Grid and in their heterogeneity, that have been obtained by combining two levels of machine heterogeneity (named Hom and Het, respectively), with three levels of machine availability (named HighAvail, MedAvail, andlowavail, respectively). The six scenarios corresponding to the above combinations have been named Hom-HighAvail, Hom-MedAvail, Hom-LowAvail, Het-HighAvail, Het-MedAvail, Het-LowAvail, respectively. An analysis of the relevant literature revealed that there is no common agreement on the definition of the typical characteristics of Desktop Grid configurations. Therefore, we adopted an approach similar to that followed in [9], where a constant value of the total computing power for all the Desktop Grid configurations has been set first, and then the number of machines included in each configuration has been determined according to a particular distribution of computing power of individual machines. The total computing power P of a configuration is defined as the sum of the computing powers P i of the individual machines, that are expressed as a real number whose value is directly proportional to the speed of the machine (i.e., a machine i with P i =10is twice faster than a machine j with P j =5). In this paper, we set P = 1000 for all the configurations, but for each configuration we generated the actual computing powers of individual machines according to a specific distribution of computing power. More specifically, we considered two different distributions, corresponding to two distinct resource heterogeneity levels: in the first one (corresponding to the Hom heterogeneity level) the power of all machines was set to the constant value P i =10(so their are homogeneous), while in the second one (corresponding to the Het heterogeneity level) the computing power was uniformly distributed in the interval [2.3,17.7] (the same values used in [9]). Each configuration has been then generated by repeatedly adding machines until the sum of their computing power reached the total computing power value (1000). Therefore, in the Hom case, the resulting Desktop Grid includes 100 machines (they all have P i =10), while in the Het case the number of machines was about 100 (since the average machine power is 10). As mentioned before, in addition to various heterogeneity levels, we considered also three distinct resource availability levels (that is, the percentage of time that a given resource is available for computation in spite of preceding faults and repairs). More precisely, we considered availability values of roughly 98% (HighAvail), 75% (MedAvail), and 50% (LowAvail). These values have been computed by properly setting the mean time between failures and the mean repair time for the various machines in the Desktop Grid. Fault times are assumed to be distributed according to the Weibull function (see [12]), while repair times are assumed to be random variables normally distributed with mean 1800 sec. and standard deviation 300 (these values result in a distribution that 99% of the values fall in the [900,2700] interval). The three availability levels have been obtained by properly setting the shape parameter of the fault time distribution and the mean value of the repair time distribution. Finally, for all the system configurations, we assumed that the time taken to transfer (retrieve) a checkpoint file to (from) the server was uniformly distributed in the interval [240,720] seconds.

5 4.2. Workloads For our study, we considered various workloads consisting in a set of BoT applications, arriving to the scheduler at a certain rate. Each workload is defined in terms of the type of the BoT applications (expressed as the number and execution times of tasks) and of their arrival rate (i.e., the number of different BoTs submitted per unit of time). In this paper we considered 12 different workloads, obtained by combining four different types of BoT applications with three different arrival rates. BoT types have been defined as follows. Each BoT type corresponds to a particular value of the task granularity, expressed as the mean execution time of individual tasks on a reference machine having computing power P =1. The four BoT types used in this work correspond to granularity values of 1000, 5000, and seconds, respectively. The actual execution times of individual tasks in a given BoT were assumed to be uniformly distributed in the interval [X 50% X, X+50% X], where X is the granularity of the tasks in the BoT, and we fixed to to sec. the application size (i.e., the total amount of computation work globally required by the tasks of a BoT) for all the BoTs in any workload. The number of tasks in a given BoT was then determined by adding tasks to the BoT until their execution times reached the above application size. It is worth to point out that the actual execution time of a task depends on the computing power of the machine on which it will be executed. In our case, being the average computing power of machines equal to 10, a task whose granularity is sec. will be executed on average in sec. BoT arrivals have been assumed to be exponentially distributed with rate λ, that in our experiments took three different values, that have been computed as follows. Denoting with U the utilization of the Desktop Grid (i.e., the fraction of time in which its resources are busy doing useful work), and with D the total computing demand of BoT (i.e. the ratio of the sum of the task execution time over the computing power of the Grid), it is possible to show [17] that: U = λ D from which λ = U (1) D By computing the value of D, that depends on the application size ( sec.), the total computing power of the Grid (1000) scaled down to take into account the availability of resources, and the cost and frequency of each checkpoint, and by varying the values of U from Eq. 1 we can compute the value of λ. In our study we used the utilization values of 50%, 75% and 90% to represent workloads of low, medium, and high intensity, respectively Results Let us discuss now the results we obtained by running simulation experiments for all the combinations of the scenarios and workloads described before. In our experiments, we used the average turnaround time (for which we computed 95% confidence intervals with a relative error of 2.5% or less) as the comparison metric for the various scheduling algorithms. Because of space constraints, however, in this paper we report only the results corresponding to a subset of experiments that includes only the scenarios featuring the Low and the High workload intensities, and the LowAvail and HighAvail Desktop Grid configurations. The results for the other workloads and configurations, however, do not significantly differ from those reported here. High availability configurations. High-availability configurations can be assimilated to Enterprise Desktop Grids, where the set of hosts is characterized by a relatively high stability. Thus, the benefits of replications can be considered marginal, as resources do not fail very often. The results obtained for these configurations are reported in Fig. 1, for both low-intensity (Fig. 1(a) and (b)) and high-intensity (Fig. 1(c) and (d)) workloads. In the case of homogeneous resources and low intensity workloads (Fig. 1(a)), for low granularity values (up to 5000 sec.) all the strategies exhibit approximately similar performance, although RRbased strategies perform slightly worse than the other ones. This is due to the fact that in this case the average number of tasks per bag far exceeds the number of available machines, so there is practically no room for replication. However, as already discussed, replication has little importance in this case, as machine availability is high and their heterogeneity is low. This in turn means that FCFS-based strategies (as well as LongIdle, that in this case degenerates to FCFS- Share) start an instance for each pending task before considering the option of replicating already-running ones. Consequently, no compute cycles are wasted to run replicas, so all the resources are effectively used to reduce as much as possible the makespan. While in general (as discussed later) this may result in a growth of the average waiting time, the small size of individual tasks implies that tasks are completed quickly, thus effectively keeping the waiting time to an acceptable value. Conversely, RR-based strategies that tend to reduce waiting time at the (possible) detriment of the makespan result in higher turnaround times since the marginal reduction of the waiting time (due to the short duration of individual tasks) is not sufficient to compensate the increase in the makespan caused by the fact that individual BoTs get chosen not often enough. For higher granularity values, however, we observe that

6 Figure 1. Results for high availability configurations the relative ranking among the various strategies is reversed, as RR-based strategies perform better (for sec.) or much better (for sec.) than the other ones. Furthermore, for the highest granularity value FCFS-Excl performed so poorly that the average turnaround time grew beyond any reasonable limit (denoted by the fact that the corresponding histogram bar went over the frame of the graph), meaning that the system was operating under extremely high saturation levels. This depends on the fact that, for these granularity values, the average number of tasks per BoT is similar to or smaller than that of the machines in the Desktop Grid. FCFS-based strategies use the exceeding machines to create many replicas for the tasks of the same BoT (the oldest one). However, these replicas are useless in most cases as the machines do not fail often enough and are not heterogeneous enough to profitably exploit replication, but the exclusive use of all the machines for a single BoT makes the waiting time of the other BoTs grow excessively, since the average task execution time is now from 25 to 125 times larger than in the low granularity scenarios. Conversely, RR-based strategies exploit the fact that each BoT requires less machines than the available ones to concurrently run more BoTs, thus significantly reducing their waiting times, with the consequent beneficial effects on the turnaround time that can be appreciated from Fig. 1(a). This performance gap is somehow reduced for the Het configuration (Fig. 1(b)), since as observed in [3] replication is useful when resources are heterogeneous because a task assigned to a slow machine may get a second change of getting a faster one if it is replicated. The results for the high workload intensity (Fig. 1(c) and (d)) are similar to those obtained for the low intensity case, with the (expected) difference that the turnaround times exhibited by all strategies for all the granularity values are higher. Particularly evident is the fact that FCFS-based strategies saturate the system for granularity values smaller than in the low intensity case. Low availability configurations. Low-availability configurations can be assimilated to volunteer-computing Desktop Grids, where the participating hosts come and go unpredictably with a relatively high-frequency. The results obtained for these configurations are reported in Fig. 2, for both low-intensity (Fig. 2(a) and (b)) and high-intensity (Fig. 2(c) and (d)) workloads. As can be observed by comparing each one of the above figure with the correspond-

7 Figure 2. Results for low availability configurations ing one shown for the HighAvail case, the relative ranking of the various scheduling algorithm does not change (i.e., FCFS-based strategies and LongIdle perform better that RR-based ones for low granularity values, while the ranking is reversed for higher granularity values). However, there are significant differences in the absolute values of the turnaround times and in the granularity values after which saturation occurs. For instance, for the homogeneous resources and low intensity workload case (Fig. 2(a)), the average turnaround time is doubled with respect to the corresponding high availability case (Fig. 1(a)), and a similar effect characterizes the other cases as well. Another difference that emerges from the comparison with the high availability scenarios is that now replication has a much stronger impact on performance, as consequence of the higher failure rates characterizing resources. This explains why the strategies that give priority to replica creation (FCFS-based and LongIdle) exhibit performance better than the RR-based policies for task granularity up to sec. (while in the HighAvail scenarios this was true for granularity values up to 5000 sec.). The results obtained for high intensity workloads (Fig. 2(c) and (d)) show again the same ranking among the various strategies, but now no strategy is able to avoid system saturation for the highest granularity value. This is due to the fact that the failure rate of resources, that is significantly higher than in the high availability scenarios, strongly reduces the effective computing power that the Desktop Grid can deliver in a given time interval, thus making the waiting time of BoT grow exponentially. Different, more sophisticated strategies must thus be devised in order to deal with these situations. 5. Conclusions and future work In this paper we proposed a set of knowledge-free scheduling algorithms for BoT applications on Desktop Grids that, unlike previous approaches published in the literature, are able to deal with multiple BoTs. We performed an extensive simulation study in which we compared the performance attained by these strategies for a large set of Desktop Grid configurations and application workloads. Our results indicate that there is not a clear winner among the proposed strategies. As a matter of fact, FCFS-based strategies performed better than the other one for workloads characterized by a small task granularity, while the reverse

8 was true for larger granularity values. Thus, further research is required in order to devise a single scheduling strategy able to properly work for all task granularities. However, in spite of this, we can certainly conclude that knowledge-free strategies, in spite of their simplicity and ease of implementation, can provide a suitable basis for the development of effective scheduling policies able to deal with multiple BoT scheduling. Future avenues of research will concern two directions. The first one consists in widening our study by considering workloads in which BoT of different types (i.e., characterized by different task granularities) will simultaneously be submitted to the scheduler. The second direction consists in extending our scheduling algorithms by considering (a) scheduling algorithms for individual bags that adopt a dynamic replication strategy (rather than the static one used in this paper), and (b) coupling the bag selection policies with knowledge-based scheduling algorithms (e.g., those proposed in [2]) for individual BoTs. References [1] D. P. Anderson, J. Cobb, E. Korpela, M. Lebofsky, and D. Werthimer. Seti@home: an experiment in public-resource computing. Commun. ACM, 45(11):56 61, [2] C. Anglano, J. Brevik, M. Canonico, D. Nurmi, and R. Wolski. Fault-aware scheduling for Bag-of-Tasks applications on Desktop Grids. In Proc. of 7th IEEE/ACM International Conference on Grid Computing, Barcelona, Spain, Sept IEEE Press. [3] C. Anglano and M. Canonico. Fault-Tolerant Scheduling for Bag-of-Tasks Grid Applications. In Proc. of the 2005 European Grid Conference, number 3470 in Lecture Notes in Computer Science, Amsterdam, The Netherlands, Feb Springer, Berlin. [4] O. Beaumont, L. Carter, J. Ferrante, A. Legrand, L. Marchal, and Y. Robert. Centralized versus distributed schedulers for multiple bag-of-task applications. In International Parallel and Distributed Processing Symposium IPDPS2006. IEEE, [5] A. Chien, B. Calder, S. Elbert, and K. Bhatia. Entropia: architecture and performance of an enterprise desktop grid system. Journal of Parallel and Distributed Computing, 63(5): , [6] S. Choi, H. Kim, E. Byun, M. Baik, S. Kim, C. Park, and C. Hwang. Characterizing and Classifying Desktop Grid. In CCGRID 07: Proceedings of the Seventh IEEE International Symposium on Cluster Computing and the Grid, pages , Washington, DC, USA, IEEE Computer Society. [7] W. Cirne, F. Brasileiro, N. Andrade, L. Costa, A. Andrade, R. Novaes,, and M. Mowbray. Labs of the world, unite!!! Journal of Grid Computing, [8] W. Cirne and et al. Grid computing for bag of tasks applications. In Proc. of 3 rd IFIP Conf. on E-Commerce, E-Business and E-Government, [9] W. Cirne, D. Paranhos, F. Brasileiro, and F. Goes. On The Efficacy, Efficiency and Emergent Behavior of Task Replication in Large Distributed Systems. Parallel Computing, 33(3): , April [10] The Compute Against Cancer Project. Visited on Sept. 7th, [11] D. da Silva, W. Cirne, and F. Brasileiro. Trading Cycles fro Information: Using Replication to Schedule Bag-of-Tasks Applications on Computational Grids. In Proc. of EuroPar 2003, volume 2790 of Lecture Notes in Computer Science, [12] J. B. Daniel Nurmi and R. Wolski. Modeling machine availability in enterprise and wide-area distributed computing environments. Technical Report 37, Department of Computer Science, University of California, Santa Barbara, [13] G. Fedak, C. Germain, V. Neri, and F. Cappello. Xtremweb: A generic global computing system. In CCGRID 01: Proceedings of the 1st International Symposium on Cluster Computing and the Grid, page 582, [14] D. Kondo, A. Chien, and H. Casanova. Resource management for rapid application turnaround on enterprise desktop grids. In Proc. of Super Computing Conference, [15] D. Kondo, A. Chien, and H. Casanova. Scheduling Task Parallel Applications for Rapid Application Turnardound on Enterprise Desktop Grids. Journal of Grid Computing, To appear. [16] Y. C. Lee and A. Y. Zomaya. Practical scheduling of bagof-tasks applications on grids with dynamic resilience. IEEE Trans. Comput., 56(6): , [17] D. A. Menasce, L. W. Dowdy, and V. A. F. Almeida. Performance by Design: Computer Capacity Planning By Example. Prentice Hall PTR, [18] Platform Computing Home Page. Visited on Sept. 5th, [19] J. Smith and S. Srivastava. A System for Fault-Tolerant Execution of Data and Compute Intensive Programs over a Network of Workstations. In Proc. of EuroPar 96, volume 1123 of Lecture Notes in Computer Science, [20] Data Synapse Corp. Home Page. Visited on Sept. 5th, [21] United Devices Home Page. Visited on Sept. 5th, [22] J. Young. A First-order Approximation to the Optimum Checkpoint. Communications of the ACM, 17, [23] D. Zhou and V. Lo. Wave Scheduler: Scheduling for Faster Turnaround Time in Peer-Based Desktop Grid Systems. In Proc. of 11th Workshop on Job Scheduling Strategies for Parallel Processing, number 3834 in Lecture Notes in Computer Science, Boston, MA, USA, June Springer, Berlin.