A New Agent-based Distributed Model of Grid Service

A New Agent-based Distributed Model of Grid Service
Advertisement and Discovery
Dan Ma1, Wei Zhang2, Hong-jun Zhang3
School of Computer Science in HuaZhong University of Science and Technology,
WuHan 430074, China.
E-mail: madan_zw@163.net
Abstract. Grid computing is becoming a research focus in distributed and
parallel systems. The idea of the grid service being a kernel of the whole grid
architecture is accepted by the researchers. The grid service has the
characteristics of high scalability and dynamic. By analyzing the resource
management in heterogeneous environment and agent-based hierarchy model,
this paper presents an agent-based distributed model on grid service
advertisement and discovery. It can’t only satisfy the scalability and dynamic
of grid service, but may also reduce the system overhead comparing to central
management of service advertisement.
Geographically wide-area network and many large-scale distributed high-end
resources managed by various organization or personnel compose a new corporate
computing mode. This new heterogeneous and distributed corporate computing mode
is called grid computing or grid. In grid computing architecture, the resources
provided to the grid users are abstracted as the grid service. According to important
standard proposal-Open Grid Service Architecture (OGSA)[1] presented by
GLOBAL GRID FORUM, the concept of grid service is far-ranging. All various
kinds of computational resource, storage resource, interconnected network,
application program and database etc. is grid service. Advent of the concept of grid
service is helpful to eliminate the existed difference among various heterogeneous
resources in grid system. However, the grid service management isn’t an easy task,
because the grid service in a real grid system should have high dynamic and
scalability. This status often causes the problem of looking for the grid service that
could satisfy to the performance need of the application users. So providing a valid
grid service advertisement and discovery mechanism is necessary. Further, this
mechanism oneself should be simple and consume as little system overhead as
possible. The software agent is a powerful high-level tool for modeling a complex
software system. So it is adapted to implement the advertisement and discovery of
grid service.
As far, some typical distributed and parallel systems implement different resource
management model. They have different characteristics.
Condor[2]: User agent negotiates with the resource agent by the matcher. The user
agent asks the matcher for resource, the resource agent provides resource information
to the matcher. The matcher is responsible for making a match between resource
provider and resource requestor. Obviously, the matcher becomes the system
bottleneck. This brings additional trouble when the system is frequently extended.
Globus[3]: In Globus, Meta computation Directory Service (MDS) is adopted to
manage static and dynamic information of all resources. This mode may satisfy the
need of scalability and dynamics of system resource. Nevertheless, all LDAP servers
must be notified once when the state of any a resource is changed or a new resource
is added into the system. This will increase the system and network overhead.
Agent-based hierarchy model[4]: According to this model, the agents that are
responsible for service advertisement and discovery are organized as a hierarchy.
When a new service is added into an agent, this agent need to distribute the new
service message to its next up-level and down-level agents. When a node in hierarchy
asks for a certain service, its agent query to next up-level agent until to the highest
level. In a high dynamics scene especially when service need to be distributed
frequently the overhead will be greatly increased and the nodes that located in higher
level may become the bottleneck.
2. A new agent-based distributed model
The basic idea of the new agent-based distributed model is that the grid service agent
exists at every grid node in grid system. Different from the hierarchy model, all
agents don’t form the superior or junior level relationship. Every agent has same
position in grid system viz. they all are equal. Each agent only maintains its own
service information, it also keep a remote service address list that records the address
of its neighbor nodes. When the agent needs to look for the service that doesn’t exist
at local node it only interacts with neighbor nodes using some service discovery
algorithm. This kind of organization structure resembles the P2P mode. So this model
is more suited to the scene of highly distributed grid system.
The software agent is a perfect high-level tool for modeling a grid system. All
agents that manage grid service form a multi-agent system. The software agent
provides a coordination platform for service requester and service supplier. Each
agent isn’t only a service supplier, but also a service requester.
The grid service agent works as a kernel component of service advertisement
(register) and discovery management. It composes of a series of functional modules.
In addition to some general function modules for example communication modules
etc. The basic modules that are mainly responsible for service register and discovery
include: the service register and discovery interface, the local service register module,
the remote service address list module, the optimizing strategy module for service
discovery. The elemental function of these modules is described as below and the
sketch map of the agent-based model is omitted.
Service register and discovery interface: Service register and discovery interface is
an I/O of the whole agent structure. It receives local or remote service request and set
up a certain service register/discovery instance. Generally, it first adapts standard
service description language such as Web Service Description Language (WSDL) to
describe request or registered service. Then pass the service request or register
parameters to the local service register module. If the requested service is found in
local register module then the interface return the service address to local node or
remote node. Or return the fail signal.
Local service register module: Local service register module itself is a grid service.
It mainly takes charge of register of local service. When the interface passes a local
service register parameter, this module registers this service. When a service request
parameter from local or remote node is passed, the module calls for service discovery
method that is encapsulated in the register service to deal with the service request. If
the requested service is already registered then return the local address to the
interface. If the requested service is not matched to relevant service then pass this
request to service fast discovery cache.
Remote service address list module: Remote service address list module mainly
maintains an address list of all neighbor nodes. It first receives the service request
from service fast discovery cache. Then selects an appropriate algorithm from service
discovery algorithm sets and a neighbor node address in address list. Finally passes
all these parameters to the interface. The interface begins to look for the requested
service from the remote node by building service discovery instance.
Service discovery optimizing strategy module: Service discovery optimizing
strategy module composes of some optimizing strategy components for instance
service discovery algorithm sets and service fast discovery cache etc. The algorithm
sets collects many service search algorithms such as Depth First Search (DFS)
algorithm and Width First Search (WFS) algorithm. Service fast discovery cache
reserves some last access remote service addresses and some basic service address
which are often accessed. Once the service register module don’t meet the service
request, the service request is transferred to cache and begin to match the relevant
service whose address recorded in the cache. If matching succeeds then return its
service address, otherwise pass this service request to the remote service address list
3. Service advertisement (register) and discovery mechanism
Service register: All grid service only is registered in local node. This mode avoids
the embarrassment that register server easily becomes system bottleneck. The
traditional central service register mode such as Condor or Globus often produces
such problem. At the same time, the data of every grid service are only reserved in the
local node therefore don’t occupy large storage space. The local service needn’t be
registered to any remote node, so save network bandwidth. Grid service register
procedure works as: ①When a local resource want join grid system, it presents
service register request to local agent. ②The service register and discovery interface
in local agent first describes the received service register information in standard
service description language. Then a service register instance is created. ③Call for
register method and relevant data of service register instance and register service to
the local service register module.
Service discovery: Service discovery mechanism has two cases--local service and
remote service discovery. Local service discovery procedure works as: ①The local
node presents service request. ②The interface describes service request in standard
description language and creates a service discovery instance. ③Call for discovery
method and relevant data of instance to query in local service register module. ④If
matching succeeds then return local address, otherwise ⑤ Enter the service fast
discovery catch to look for reserved service . If matching succeeds then return remote
service address, otherwise ⑥Start the remote service discovery procedure. Remote
service discovery procedure works as: ①Local service request activates a service
discovery instance in interface and no relevant service is found at local node or cache.
②Select a appropriate search algorithm from algorithm sets and starting address from
the remote address list. ③ Call for remote service discovery method of service
discovery instance to query remote node one by one. ④If matching succeeds within
life time defined in service discovery instance then return remote node address. Or
return fail signal and stop service discovery.
The kernel of resource management in grid system based on grid service is how to
advertisement and discovery grid service. By analyzing existed resource management
mechanism we present a new agent-based distributed model of service register and
discovery. This model is different from general central management mode and more
suits to the scene of highly distributed grid. It could reduce system overhead and save
network resource comparing to central management.
1. Foster. I, Kesselman. C, Nick. J.M, Tuecke. S. “Grid services for distributed
systemintegration”, Computer , Volume: 35 Issue: 6 , June 2002, Page(s): 37 -46
2. R.Raman, M.Livny, M.Solomon. “Matchmaking: Distributed Resource Management for
High Throughput Computing”, In Proceeding of 7th IEEE International Symposium on High
Performance Distributed Computing, Chicago, Illinois, July 1998.
3. K.Czajkowski, I.Foster, N.Karonis, C.Kesselman, S.Martin, W.Smith, S.Tuecke, “A
Resource Management Architecture for Metacomputing Systems”, In proceeding of
IPPS/SPDP’98 Workshop on Job Scheduling Strategies for Parallel Processing.1998.
4. Junwei.Cao, Darren J. Kerbyson, Graham R. Nudd, “Use of Agent-Based Service Discovery
for Resource Management in Metacomputing Environment” In Proceedings of 7th
International Euro-Par Conference, Manchester, UK, Lecture Notes in Computer Science
2150, Springer Verlag, 882-886, August 2001.
Download PDF