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)  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  Agile Computing Web Site. www.agilecomputing.org.  Agent-based resource management for grid computing, 2002. Available at http://www.dcs.warwick.ac.uk/˜hpsg/html/ downloads/public/docs/CaoJ.ARMGC.pdf.  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.  Agile Computing on Business Grids by Junwei Cao.