Docstoc

Agile Computing in Grid Enterprise- Bharathi Kalmath and Chhaya Patel

Document Sample
Agile Computing in Grid Enterprise- Bharathi Kalmath and Chhaya Patel Powered By Docstoc
					From:
1) Mrs. Chhaya N. Patel
   I/o Principal
   Anand Institute of Information Science
   ANAND.
2) Mrs. Bharathi Kalmath
   Lecturer
   Anand Institute of Information Science
   ANAND.




Agile Computing in Grid Enterprise


Abstract

New distributed computing technologies are emerging with different motivations, such as
Internet computing, mobile & pervasive computing, peer-to-peer computing, and grid
computing. Grid computing targets a service-oriented global computing infrastructure that
enables mass production of computing power and brings opportunities to develop further
distributed computing technologies. However, at some point the law of diminishing returns will
cut in as infrastructure gets older and the needs of business agility stretch the bounds of existing
systems. As a result, companies will start to look for the next wave of technology that will help
them both upgrade their capacity and improve their agility.

Many analysts have identified grid computing and Web Services as the core technologies to
support this wave, variously describing it as organic IT and the real-time enterprise .
However, there is a broader convergence of both these two technologies with the techniques of
business process management that appears to offer even greater benefit.
 It extends this architecture to incorporate both business process management and grid
computing and concludes by deriving a future form for the truly agile enterprise.
Introduction

1. Agile computing

Agile computing may be defined as opportunistically (or on user demand) discovering and taking
advantage of available resources in order to improve capability, performance, efficiency, fault
tolerance, and survivability. The term agile is used to highlight both the need to quickly react to
changes in the environment as well as the need to exploit transient resources only available for
short periods of time. Agile computing builds on current research in grid computing, ad-hoc
networking, and peer-to-peer resource sharing.
Agile computing is a new computing paradigm that enables mass customization of computing
services. AgileGrid is the implementation of agile computing based on the grid infrastructure.

2. Grid Computing

Grid computing originated from a new computing infrastructure and is now becoming a
mainstream technology for large-scale distributed resource sharing and system integration.The
combination of the recent decline in the market, poor utilization of infrastructure capacity and
need for greater reliability has placed greater pressure on enterprises to find ways of reducing
costs and access to an infrastructure that maximizes capacity utilization while providing an
“always on” environment.

Enterprises (and the software vendors that serve them) now realize that grid computing can help
them maximize their return on investment (ROI) in IT investments, reduce costs and improve the
overall quality of services. In addition, by having grid computing available any time, anywhere,
enterprises can quickly support dynamic changes in their business environments.

Grid computing works best in environments that are resilient, flexible and highly integrated.
Today, organizations with such environments are seeing real, substantial benefits from grids, a
technology virtually unheard of just a few years ago.

3. Motivations for Agile Computing
Agile computing will provide several advantages over the current state-of-the-art. The following
four examples illustrate the survivability, cost, and performance advantages and the ability to
opportunistically take advantage of new capabilities

3.1. Improving Survivability
Survivability may be defined as the resiliency of a system under attack. In certain environments
computer systems may be under attack in order to reduce their effectiveness. Such attacks may
be an electronic (information warfare attacks such as denial of service). An agile computing
infrastructure will allow critical functionality to be moved to other available computing
platforms on demand. In case one of the dedicated systems is damaged or the systems is
overloaded, the functionality should be dynamically moved to other available systems (such as
the general purpose workstations).
3.2. Reducing Investment in Duplicate Hardware
Critical systems are often constructed with redundant systems (hot standbys) to takeover when
the primary system fails. The goal of agile computing research is to reduce the need to duplicate
dedicated hardware. Agile computing emphasizes survivability through software and process
migration and redundancy, not hardware redundancy. This is particularly powerful given that
computational hardware is now becoming ubiquitous and interconnected.

3.3. Improving Performance
In any given environment (micro or macro), the utilization of systems is not uniform. This may
be observed in very small groups such as laptops in a meeting room to very large organization
wide (or even nationwide) groups. Using available resources in groups will enhance overall
performance. Note that groups may be transient or stable and even in a stable group, systems
may disconnect and reconnect. The goal of agile computing is to take advantage of not just stable
but transient groups as well.

3.4. Dynamically Discovering and Using Capabilities
Consider an advanced military sensor network (such as the one envisioned for the U.S. Army
Future Combat Systems program) whose goal is to allow soldiers to discover and task available
sensors in any given environment. As opposed to tasking a static set of deployed sensors, agile
computing would allow opportunistic use of available resources.

4. Technical Requirements and Challenges
Several technical requirements must be satisfied before agile computing can be realized. These
requirements are discussed below:

4.1. Group Formation
A group is defined as a set of systems that specify the scope for resource sharing. Therefore,
formation and regulation of groups is central to agile computing. Groups may be formed through
static configuration or through ad-hoc discovery. For example, all of the workstations in a
department may be configured to be part of a group. On the other extreme, a group may be
formed when four laptop computers in a meeting room discover each other through a protocol
such as Bluetooth. Group formation needs to be controllable through policies for security reasons
so that the systems that are allowed to share resources can be regulated.

4.2. Architecture Independence
Agile computing implies that computations must be able to take advantage of any available
resources independent of the underlying hardware architecture. If the system fails unexpectedly,
the infrastructure should be able to compensate by running those computations on another
system, independent of architecture. Similarly, if an ad-hoc group consists of laptops of different
architectures (say, Apple PowerBooks running MacOS X and PC laptops running Windows and
Linux), any one of the laptops should still be able to take advantage of any available resources in
the other laptops.

4.3. Environmental Independence
Architecture independence alone is not sufficient to support migration of computations between
systems. If the environment on each system is different, the computation will fail after migration
due to the sudden change. Environmental factors include the data resident on a system,
configuration of the software on the system as well as any specialized hardware in the system.

4.4. Mobility of Code, State, and Data
One of the key enhancements provided agile computing over existing approaches is the
exploitation of mobility of code, computational state, and data. Mobility of code is needed to
support dynamically pushing or pulling code to a system in order to change its configuration or
download a new capability. Mobility of computational state is needed to allow computations to
move from one system to another within a group. Such movement may be triggered for
survivability, performance, or to accommodate changes in-group membership. Finally, mobility
of data with the computation and/or the code is necessary to handle potential network
disconnections as well as to optimize network bandwidth usage.

4.5. Security
Security is of paramount importance for agile computing to be used in a practical environment. A
system that joins a group and contributes resources should be protected from abuse. If
computations are pushed onto a system, the computations must be executed in a restricted
environment to guarantee that they do not access private areas of the host system or abuse the
resources available on the host. Similarly, the computations themselves need to be protected
from a possibly malicious host that joins a group. In addition to satisfying the above
requirements the following two challenges must be addressed to make agile computing
successful.

4.6. Overcoming Dedicated Roles / Owners for Systems
One of the problems with current systems is that they are often dedicated to certain tasks or
assigned to particular users. Such a priori classification of systems prevents exploitation of
available resources. Agile computing relies on the notion that any available resource should be
utilizable. In order to make this a reality, hardware should be generic and ubiquitous with the
specialization being derived through software. If this were the case, then one system can easily
be substituted for another by means of moving the software functionality as needed. Similarly, if
systems are assigned to individual owners who are protective about their systems, then resource
sharing will be ineffective.
One solution to this problem lies in resource accounting, which will allow the owner to a system
to contribute resources but then to quantify the contribution in order to receive compensation in
some manner.


4.7. Achieving a High Degree of Agility
The degree of agility may be defined as the length of time for which a system needs to be part of
a group in order for its resources to be effectively exploited. The shorter the length of time, the
higher the degree of agility. The degree of agility that can be realized is a direct function of the
overhead involved. When a system joins a group, there is overhead in the group reformation
process, in setting up communication channels, and in moving computations, code, and data to
the system. Before a system leaves a group, there is potentially more overhead in moving active
computations off of the system.
The degree of agility may also be defined in terms of the minimum time required in order to
reconfigure when one or more systems are under threat. A system that has a higher the degree of
agility will be more survivable.

5. Designs and Implementation
The realization of an agile computing framework involves the design and implementation of a
platform independent way to coordinate the communication, distribution, and execution of
processes on heterogeneous networks. As part of requirements, the framework must be capable,
amongst other things, to provide local resource control, accounting and redirection, as well as
high-level services such as lookup, discovery, and policy enforcement.
A dynamically formed group is a fundamental structural notion in agile computing. A group is
essentially defined as a set of hosts that have joined Proceedings together to share resources.
That could be, for instance, a set of laptops in a conference room during a meeting.




                                Figure 1: Runtime Grouping of Hosts

Figure 1 shows one possible arrangement for a set of hosts. Note that groups may be disjoint or
overlapping. An overlapping group is created by the existence of one or more shared hosts. A
host may join multiple groups. Various grouping principles are possible but likely candidates are
physical proximity, network reachability, and ownership.
Hosts in a group might belong to different administrative domains, which create another type of
grouping. Domains are used to express common policies to hosts and to conveniently administer
them. Domains tend to be more static compared to runtime groups. Figure 2 shows a
configuration with two domains and one group.
              Figure 2: Relationship between Domains and Groups
Each participating node runs a specialized Java compatible kernel (the Agile Computing Kernel)
that provides a platform-independent execution environment and a set of local services such as
policy enforcement and resource control. The kernels from different hosts also interact amongst
themselves to provide a lower level group-wide set of services such as global directory and
coordination services. The Agile Computing Kernel contains a uniform execution environment, a
policy manager, a resource manager, a group manager and a local coordinator. Figure 2 shows
the main components of the Agile Computing Kernel.




Figure 3: The Agile Computing Kernel
These components provide the set of capabilities that the running processes rely upon to take
advantage of the agile computing framework. They constitute a middleware through which
processes communicate and migrate between nodes.
The following subsections provide a brief explanation of each of the components


5.1. Uniform Execution Environment
The Uniform Execution Environment provides a common abstraction layer for code execution
that hides underlying architectural differences such as CPU type and operating system. The
execution environment will also support dynamic migration of computations between kernels,
secure execution of incoming computations, resource redirection, resource accounting, and
policy enforcement.
5.2. Policy Manager
The policy manager is responsible for the specification, conflict resolution, and distribution of
policies. This component provides a facility for other components in the kernel to query and
determine policies and restrictions that apply to local and remote processes and nodes.
5.3. Group Manager
The Group Manager is the component responsible for identifying all the nodes that participate in
a group. The framework is designed to handle highly dynamic environments, where nodes join
and leave the framework at any arbitrary rate. Therefore, a fundamental requirement is to
efficiently and accurately identify other available nodes and services.
 The role of the group manager is to coordinate with the Policy Manager to ensure proper
advertisement of services and to identify and locate services required by local processes. Service
lookup implies the notion of a registry that accepts service registration and deregistration
requests as well as queries for clients looking for specific providers or capabilities. In general,
lookup registries provide no guarantees about service availability. Clients or service providers
initiate both queries and registration/deregistration requests. The registry is usually a passive
entity in the framework.

5.4 Coordinator
The Coordinator is the entity responsible for determining, establishing, and maintaining the
overall goals of the framework. Coordination can be done through a centralized or a distributed
process. In the first case, the coordinator component of the kernel acts essentially as an interface
between the kernel and the central coordinator, which has a model of the framework and
calculates the process distribution and ensures policy enforcement. In the second case, the
distributed scenario, the local coordinator actually has an internal model of the whole framework
and relies on its immediate neighbors to maintain and update such information. All decisions
about process distribution are made locally at the kernel and negotiated between kernels before
actual deployment.

6. Role of Mobility in Achieving Agility
Our approach to realizing the goal of agile computing is based on mobility – of code, data, and
computation. Mobility of code is important in order to be opportunistic. If an idle host is found,
the likelihood that the host already has the code for a particular computation or service could be
small.
Mobility of computation (i.e., movement of execution state) is important in order to achieve a
high degree of agility. Without computational mobility, it would be difficult to quickly and
dynamically move computations to and away from hosts. For example, if a laptop is being
suspended because the owner closed the lid, any computations running on that node should
immediately move to other hosts within the group without any loss of work.

7. Metrics Relevant to Agile Computing
Different approaches to implementing the notion of agile computing may be optimized to
emphasize different goals (performance, efficiency, fault-tolerance, or survivability). Measuring
the effectiveness of an agile computing implementation requires a new set of metrics. These
metrics can be used to determine the “degree of agility” of an approach or an implementation.
One promising metric is to measure the length of time required for a resource to be discovered
and utilized effectively. This measures the performance of the discovery mechanisms, group
formation, coordination, and mobility mechanisms to push code, data, and computations. A
second promising metric is to measure the minimum length of time for which a resource needs to
be available in order for the system to have achieved some benefit from the resources.


8. Related Work
The notion of Agile Computing is relatively new and very little research has been accomplished
in this area. A4 (Agile Architecture and Autonomous Agents) [25] is an approach to building
large-scale distributed systems based on autonomous agents. The goal of the approach is to
construct grid-computing oriented applications that have the ability to quickly adapt to a
dynamic environment. Agility in this approach is realized by allowing agents in a multi-agent
system to rapidly discover other agents and services. An A4 simulator was built in order to
evaluate the performance of service discovery in large-scale agent systems.


9. Conclusion

Agile computing is an approach to opportunistic sharing of resources in order to improve
capability, performance, efficiency, fault-tolerance, and survivability. Agile computing is more
dynamic than current grid computing approaches.

10. References

[1] Agile Computing Web Site. www.agilecomputing.org.

[2] Agent-based resource management for grid computing, 2002. Available at
  http://www.dcs.warwick.ac.uk/˜hpsg/html/ downloads/public/docs/CaoJ.ARMGC.pdf.

[3] J. Cao, S. A. Jarvis, S. Saini, and G. R. Nudd, “GridFlow: Workflow Management for Grid
Computing”, in Proc. 3rd IEEE/ACM Int. Symp. On Cluster Computing and the Grid, Tokyo,
Japan, pp. 198-205, 2003.

[4] Agile Computing on Business Grids by Junwei Cao.

				
DOCUMENT INFO
Shared By:
Tags:
Stats:
views:7
posted:3/21/2010
language:
pages:8