Available grid technologies like the Globus Toolkit make possible for one to run a parallel application on resources distributed across several administrative domains. Most grid computing users, however, don't have access to more than a handful of resources onto which they can use this technologies. This happens mainly because gaining access to resources still depends on personal negotiations between the user and each resource owner. To address this problem, we are developing the OurGrid resources sharing system, a peer-to-peer network of sites that share resources equitably in order to form a grid to which they all have access. The resources are shared accordingly to a network of favors model, in which each peer prioritizes those who have credit in their past history of bilateral interactions. The emergent behavior in the system is that peers that contribute more to the community are prioritized when they request resources. We expect, with OurGrid, to solve the access gaining problem for users of bag-of-tasks applications (those parallel applications whose tasks are independent).

Data-intensive applications executing over a computational grid demand large data transfers. These are costly operations. Therefore, taking them into account is mandatory to achieve efficient scheduling of data-intensive applications on grids. Further, within a heterogeneous and ever changing environment such as a grid, better schedules are typically attained by heuristics that use dynamic information about the grid and the applications. However, these information are often difficult to be accurately obtained. On the other hand, although there are schedulers that attain good performance without requiring dynamic information, they were not designed to take data transfer into account. This paper presents Storage Affinity, a novel scheduling heuristic for bag-of-tasks data-intensive applications running on grid environments. Storage Affinity...

Currently, most computational grids (systems allowing transparent sharing of processing resources across organizational boundaries) are assembled using human negotiation. This procedure does not scale well, and is too inflexible to allow for large open grids. Peer-to-peer grids present an alternative way to build grid infrastructures with a large number of sites. However, to actually assemble a large grid, peers must have an incentive to collaborate by providing resources to the system. In this paper we propose an incentive mechanism called the Network of Favors, which is designed to make it in the best interest of each participating peer to make as much as possible of its spare processing resources available to the system. We show through analysis, simulations, and experiments with an implementation that the Network of Favors promotes collaboration in a simple and robust fashion. We also describe OurGrid, a peer-to-peer grid based on the Network of Favors that is in production since December 2004.

This paper is a performance study of a distributed fault-tolerant asynchronous algorithm for performing a job consisting of N independent and idempotent tasks on P processors. The algorithm tolerates up to P 1 processor failures. That is, at least one processor must survive for the lifetime of the application. Processors communicate only through asynchronous message passing. A parameter called Periodicity controls how often progress information is distributed to the rest of the processors. The major design goals are: to eliminate the requirement of a master processor; to optimize the scheduling of tasks such that in the presence of failures and communication time-outs, the number of tasks redone is minimized; to minimize the allocation of resources.

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.

In scientific environments such as High Energy Physics (HEP), hundreds of end-users may individually or collectively submit thousands of jobs that access subsets of the petabytes of HEP data distributed over the world. Given the large number of jobs that can result from the splitting process and the amount of data being used by these jobs, it is possible to submit the job clusters (batch of similar jobs) to some scheduler as a unique entity, with subsequent optimization in the handling of the input datasets. In this process, known as bulk scheduling, jobs compete for scarce compute and storage resources and this can distribute the load disproportionately among available Grid nodes. Moreover, the Grid scheduling decisions are often made on the basis of jobs being either data or computation intensive: in data intensive situations jobs may be pushed to the data and in computation intensive situations data may be pulled to the jobs. This kind of scheduling, in which there is no consideration of network characteristics, can lead to performance degradation in a Grid environment and may result in large processing queues and job execution delays due to site overloads. Furthermore, previous approaches have been based on so-called greedy algorithms where a job is

This paper proposes GRIDTS, a grid infrastructure in which the resources select the tasks they execute, on the contrary to traditional infrastructures where schedulers find resources for the tasks. This solution allows scheduling decisions to be made with up-to-date information about the resources, which is difficult in the traditional infrastructures. Moreover, GRIDTS provides fault-tolerant scheduling by combining a set of fault tolerance techniques to cope with crash faults in components of the system. The solution is mainly based a tuple space, which supports the scheduling and also provides support for the fault tolerance mechanisms. 1.

Scheduling tasks on large-scale computational grids is difficult due to the heterogeneous computational capabilities of the resources, node unavailability and unreliable network connectivity. This work proposes GRIDTS, a grid infrastructure in which the resources select the tasks they execute, instead of a scheduler finding resources for the tasks. This solution allows scheduling decisions to be made with up-to-date information about the resources. Moreover, GRIDTS provides fault-tolerant scheduling by combining a set of fault tolerance techniques to tolerate crash faults in components of the system. The core of the solution is a tuple space, which supports the communication, but also provides support for the fault tolerance mechanisms. 1.

Scheduling independent tasks on heterogeneous environments, like grids, is not trivial. To make a good scheduling plan on this kind of environments, the scheduler usually needs some information such as host speed, host load, and task size. This kind of information is not always available and is often difficult to obtain. In this paper we propose a scheduling approach that does not use any kind of information but still delivers good performance. Our approach uses task replication to cope with the dynamic and heterogeneous nature of grids without depending on any information about machines or tasks. Our results show that task replication can deliver good and stable performance at the expense of additional resource consumption. By limiting replication, however, additional resource consumption can be controlled with little effect on performance.