In this paper, we consider the problem of scheduling distributed biological sequence comparison applications. This problem lies in the divisible load framework with negligible communication costs. Thus far, very few results have been proposed for this model. We discuss and select relevant metrics for this framework: namely max-stretch and sum-stretch. We explain the relationship between our model and the preemptive single processor case, and we show how to extend algorithms that have been proposed in the literature for the single processor model to the divisible multi-processor problem domain. We recall known results on closely related problems, we show how to minimize the max-stretch on unrelated machines either in the divisible load model or with preemption, we derive new lower bounds on the competitive ratio of any online algorithm, we present new competitiveness results for existing algorithms, and we develop several new online heuristics. We also address the Pareto optimization of max-stretch. Then, we extensively study the performance of these algorithms and heuristics under realistic scenarios. Our study shows that all previously proposed guaranteed heuristics for max-stretch for the single processor model are inefficient in practice. In contrast, we show that our online algorithms based on linear programming are in practice near-optimal solutions for max-stretch. Our study also clearly suggests heuristics that are efficient for both metrics, although a combined optimization is in theory not possible in the general case.

In this paper, we consider the problem of scheduling comparisons of motifs against biological databanks. We experimentally show that this problem lies in the divisible load framework with negligible communication costs. In this framework, we propose a polynomial-time algorithm to optimally solve the maximum weighted flow offline scheduling problem on unrelated machines. We also show how to optimally solve the maximum weighted flow off-line scheduling problem with preemption on unrelated machines.

Scientists have long relied on abstract models to study phenomena that are too complex for direct observation and experimentation. As new scientific modeling methodologies emerge, new computing technologies must be developed. In this paper, we focus on entity-level modeling, a modeling approach that is gaining prevalence in many scientific fields. Although the principles of entity-level modeling are straightforward, entity-level simulations require a large amount of compute resource and grid platforms can meet such resource needs. Unfortunately, efficient large-scale distributed entity-level simulations have proven elusive, typically due to nondeterminism that renders classical distributed application deployment strategies ineffective. In this work, we propose a method for dynamically remapping application tasks to cope with this inherent nondeterminism. We evaluate the efficacy of this method in a simulated grid computing environment and discuss the feasibility of executing entity-level applications on grids.

Ensembles of distributed, heterogeneous resources, also known as computational grids, have emerged as critical platforms for high-performance and resource-intensive applications. Such platforms provide the potential for applications to aggregate enormous bandwidth, computational power, memory, secondary storage, and other resources during a single execution. However, achieving this performance potential in dynamic, heterogeneous environments is challenging. Recent experience with distributed applications indicates that adaptivity is fundamental to achieving application performance in dynamic grid environments. The AppLeS (Application Level Scheduling) project provides a methodology, application software, and software environments for adaptively scheduling and deploying applications in heterogeneous, multiuser grid environments. We discuss the AppLeS project and outline our findings.

The continuing deployment of high-performance network technology enables the development of computing platforms that aggregate widely distribute hardware resources. The vision for such a Computational Gridpromises computational platforms of unprecedented power for scientific applications. However, application developers need to rethink implementation paradigms in order to realize this potential. In this paper, we identify a class of increasingly important applications, entity-level simulations , which currently cannot use largescale computing platforms effectively. We will show how careful application-aware scheduling can enable such applications to utilize large distributed heterogeneous platforms. Our initial approach is to exploit the structure of entity-level applications and leverage existing Directed Acyclic Graph (DAG) scheduling techniques. We validate our approach by simulating a realistic application scenario on several synthetic platforms, including a representative Computational Grid testbed.

The Computational Grid [10] has recently been proposed for the implementation of high-performance applications using widely dispersed computational resources. The goal of a Computational Grid is to aggregate ensembles of shared, heterogeneous, and distributed resources (potentially controlled by separate organizations) to provide computational "power" to an application program. In this paper, we provide a toolkit for the development of Grid applications. The toolkit, called EveryWare, enables an application to draw computational power transparently from the Grid. The toolkit consists of a portable set of processes and libraries that can be incorporated into an application so that a wide variety of dynamically changing distributed infrastructures and resources can be used together to achieve supercomputer-like performance. We provide our experiences gained while building the EveryWare toolkit prototype and the first true Grid application.

The Computational Grid [10] has recently been proposed for the implementation of high-performance applications using widely dispersed computational resources. The goal of a Computational Grid is to aggregate ensembles of shared, heterogeneous, and distributed resources (potentially controlled by separate organizations) to provide computational “power” to an application program. In this paper, we provide a toolkit for the development of Grid applications. The toolkit, called EveryWare, enables an application to draw computational power transparently from the Grid. The toolkit consists of a portable set of processes and libraries that can be incorporated into an application so that a wide variety of dynamically changing distributed infrastructures and resources can be used together to achieve supercomputer-like performance. We provide our experiences gained while building the EveryWare toolkit prototype and the first true Grid application.

Computational Grids, composed of distributed and often heterogeneous computing resources, have become the platform of choice for many performance-challenged applications. Proof-of-concept implementations have demonstrated that both Grids and clustered environments have the potential to provide great performance benefits to distributed resource-intensive applications. However, at the present time, careful staging, scheduling, and/or reservation of resources is essential in order for applications to achieve performance in Grid environments. If Computational Grids and shared computational clusters are to achieve their full potential, it must be possible for users to achieve application performance at any given time, and when other users are present in the system. In this paper, we describe the initial development of an AppLeS (application-level scheduler) for the resource selection portion of the Synthetic Aperture Radar Atlas (SARA) application, developed at the Jet Propulsion Laboratory (JPL) and the San Diego Supercomputer Center (SDSC). We demonstrate the effectiveness of application scheduling for distributed data applications such as SARA by providing a performance-efficient strategy for retrieving SARA data files in everyday, multiple-user Grid environments.

The computational grid is becoming the platform of choice for large-scale distributed data-intensive applications. Accurately predicting the transfer times of remote data files, a fundamental component of such applications, is critical to achieving application performance. In this paper, we introduce a performance prediction method, AdRM (Adaptive Regression Modeling), to determine file transfer times for network-bound distributed data-intensive applications. We demonstrate the effectiveness of the AdRM method on two distributed data applications, SARA (Synthetic Aperture Radar Atlas) and SRB (Storage Resource Broker), and discuss how it can be used for application scheduling. Our experiments use the Network Weather Service [36, 37], a resource performance measurement and forecasting facility, as a basis for the performance prediction model. Our initial findings indicate that the AdRM method can be effective in accurately predicting data transfer times in wide-area multi-user grid environments.

In high level synthesis, resource sharing may result in a circuit containing false loops that pose great difficulty in timing validation during design sign-off phase. It is hence desirable to avoid generating any false loops in a synthesized circuit. Previous work considered mainly data path sharing for false loop elimination. However, for a complete circuit with both data path and control path, false loops can be created due to control logic sharing, even though the loops caused by data path sharing have all been removed. In this paper we present a novel approach to detect and eliminate the false loops caused by control logic sharing. An effective filter is devised to reduce the computation complexity of false loop detection, which is based on checking the level numbers that are propagated from data path operators to inputs/outputs of the control path. Only the input/output pairs of the control path identified by the filter are further investigated by traversing into the data path for false loop detection. A removal algorithm is then applied to eliminate the detected false loops, followed by logic minimization to further optimize the circuit. Experimental results show that for nine example circuits we tested, the final designs after false loop removal and logic minimization give only slightly larger area than the original ones that contain false loops.

The Computational Grid [10] has recently been proposed for the implementation of high-performance applications using widely dispersed computational resources. The goal of a Computational Grid is to aggregate ensembles of shared, heterogeneous, and distributed resources (potentially controlled by separate organizations) to provide computational “power” to an application program. In this paper, we provide a toolkit for the development of Grid applications. The toolkit, called EveryWare, enables an application to draw computational power transparently from the Grid. The toolkit consists of a portable set of processes and libraries that can be incorporated into an application so that a wide variety of dynamically changing distributed infrastructures and resources can be used together to achieve supercomputer-like performance. We provide our experiences gained while building the EveryWare toolkit prototype and the first true Grid application.

The Computational Grid (10) has recently been proposed for t he implementation of high-performance applications using widely dispersed computational resources. The goal o f a Computational Grid is to aggregate ensembles of shared, heterogeneous, and distributed resources (potentially co ntrolled by separate organizations) to provide computatio nal "power" to an application program. In this paper, we provide a toolkit for the development of Gri d applications. The toolkit, called EveryWare, enables an application to draw computational power transparently f rom the Grid. The toolkit consists of a portable set of processes and libraries that can be incorporated into an app lication so that a wide variety of dynamically changing distributed infrastructures and resources can be used toge ther to achieve supercomputer-like performance. We provid e our experiences gained while building the EveryWare toolki t prototype and the first true Grid application.

The continuing deployment of high-performance network technology enables the development of computing platforms that aggregate widely distribute hardware resources. The vi- sion for such a Computational Gridpromises computational platforms of unprecedented power for scientific applications. However, application developers need to rethink implemen- tation paradigms in order to realize this potential. In this pa- per, we identify a class of increasingly important applications, entity-level simulations, which currently cannot use large- scale computing platforms effectively. We will show how careful application-aware scheduling can enable such appli- cations to utilize large distributed heterogeneous platforms. Our initial approach is to exploit the structure of entity-level applications and leverage existing Directed Acyclic Graph (DAG) scheduling techniques. We validate our approach by simulating a realistic application scenario on several syn- thetic platforms, including a representative Computational Grid testbed.