A Method of Agent Task Representation and Processing in PervasiveComputing Environment

Liu Bo, Luo Junzhou, Cao JiuxinSchool ofComputer Science and Engineering, Southeast University, Nanjing,China 210096

tbliu, jluo, jx. cao}@seu. edu. cn

Abstract

It is an effective approach to adopt software agent inpervasive computing environment. The tasks of agentsin pervasive computing environment is dynamic andcontinuing changeful, so that the task representationshould be changeable and agent-oriented. But most ofthe existing methods of task representation can notpresent task relationship clearly and lack unifiedformat. In this paper an agent based pervasivecomputing platform is presented which endows agentswith various roles. Based on analysis of taskrelationship, an agent's role based task relationshiptree (TRT) model and TRT based task processingmethods are proposed. Furthermore, an xml-basedmethod of task representation is presented. Finally, aprototype of an application on traffic monitoring ispresented and the results ofevaluation indicate that theplatform is feasible and the proposed method has betterperformance than other methods.

Keywords: Task representation, Pervasive computing,Agent, Task relationship tree.

1. Introduction

Pervasive computing is a method of enhancingcomputer use by making many computers availablethroughout the physical environment, but making themeffectively invisible to the user [1]. In pervasivecomputing, the tasks are performed in distributedmanner in heterogeneous computing devices. What theusers mainly concern is not the context of task processbut the results of the task. The need of an autonomous,active, self-organized computing has increased in orderto make the users free from computing details. It isagent technology, such as autonomous agent, mobileagent, collaborating agent and etc, which makes itpossible to solve these problems. Agent is able totrigger adaptation of applications inside the network onbehalf of users. This allows for an immediate responseto resource shortages, decreases the amount of uselessdata transported, and reduces signaling overhead.

1-4244-0971-3/07/$25.00 ©)2007 IEEE.

A software agent is a kind of software entity thatautonomously acts to perforn tasks on user's behalf.We believe that autonomy and collaboration are two ofthe features that will characterize the behavior of agentsin pervasive computing: autonomous choices will betaken as the result of coordination among differentcooperating software entities.

The structure of the systems underlying pervasivecomputing environment is dynamic and continuouslychanging, so as to the structures of tasks also should bechangeable. Software agent can change tasks' structurewhile concealing the details of task execution for usersin pervasive computing system. A. Ramdane-Cherifl2]has proposed an agent-based architecture of pervasivecomputing by constructing three layers: the higher layer,the internediary layer and the reactive layer. But howdo we make agent understand user's intention? Theanswer is to dispatch tasks to multi-agent. But inpervasive computing system, the role of agent isdifferent and it is not possible for user to present apredefined task for every agent. So we will use treemodel and xml Technology to represent agent's taskswith unified forn.

The structure of this paper is as follows. Section 2will introduce the related works. Section 3 illustratesour approach and our proposed platforn based onagents. Section 4 proposes a model of TRT based onagent's roles according to the analysis of taskrelationship and requirements, and based on TRT, atask decomposing algorithm and scheduling method areproposed. Section 5 introduces the core technologiesthat we have used for designing task representation,namely XML, Schema and analyses how these can beused to represent and process task infornation. Section6 gives a concrete case that applies our methodology toa traffic monitoring scenario. Finally, in section 7, weconclude the paper and points out the direction of thepossible future research.

2. Related works

The goal of task representation is to give preparationfor task decomposition and scheduling. Taskrepresentation technology includes two issues: taskrepresentation model and task describing method. Inrecent years, some mathematical models have been

utilized by researchers to manipulate the task and theirinter-relationship, such as Gantt graph, DAG (DirectedAcyclic Graph)[3] and tree model[4]. Analysis of taskrelationship is the basis of task representation. Ganttgraph does not adapt for represent complicatedstructure of tasks. DAG can represent the relationshipof tasks, but the scheduling process based on DAG willbecome very difficult as tasks grow and the most ofexisting scheduling method based on DAG are static.According to the research on tree model[5][6], the treecan be classified into two classes: task decomposingtree and task relationship tree. Task decomposing treecan be called goal decomposing tree, and it is widelyused in studying agent negotiation[7]. But taskdecomposing tree is designed based up-down idea, andneed human intervening. Knoblock[8] has used themethod of goal and operator to analyze task problemand to attempt to attain Strips-style methods. ButWilkins[9] found that this Strips-style method onlyadapt to small problem. In pervasive computingenvironment, the structure of tasks is complicated andlarge, so we will propose and adopt task relationshiptree model to depict the relationship of tasks.

In earlier works on description and analysis of agenttasks, the focus has been on using high-levelprogramming language to represent task. VincentRegis[9] represents agent coordination problems using"Lisp-ish" language. This method is not easy to use

because the users must master the syntax of thelanguage. A. Keller[ 11 ] uses workflow language todescribe task graph, every task graph is correspondingto a workflow. The limitation of this approach is thatworkflow can work well for batch tasks but can'trepresent task relationship very well for common tasks.In this paper, we will propose XML-based tasklanguage to represent task relationship tree.

3. A pervasive computing platform basedon agents

In pervasive computing environment, there are

more and more users that carry mobile devices such as

PDAs, cell phones and other portable devices. Thecomputing resource is fertile, and the user's task has therequirement of taking advantage of various resources.

So the character of distributed and autonomouscomputing is more important. Through endowingagents with various functions, we establish a platformbased multi-agent (Figure 1).

The agents in this architecture are divided intoseveral roles: "user agent", "decomposing agent","scheduling agent" and "performing agent". "Useragent" is oriented to the users in the system. Userssubmit tasks to "user agent", then, "user agent"transferred the tasks to "decomposing agent". The"decomposing agent" decomposes tasks online.Priority-ranked sub-tasks are grouped according to their

inter-dependences. Sub-tasks with the same priority are

put into the same group and they can be performed inparallel manner, while different groups of sub-taskswith different priorities must be implemented accordingto the order of their priorities. The sub-tasks are

submitted to "scheduling agent" by "decomposingagent" in the order of their priorities. "Schedulingagent" will schedule multi "performing agents" toexecute sub-tasks and the result of tasks will return to"user agent". "User agent" gives the results of tasks tousers with appropriate manner. The pervasivecomputing scale is large and can be divided intodifferent domains. Every domain has a "schedulingagent". The "scheduling agent" schedules all of the"performing agents" in its' domain.

Fig. 1 Pervasive computing platform based on agent

4. TRT model and TRT based taskprocessing

From Section 3 we can see, the tasks in pervasivecomputing environment are transferred and processedby different roles (agents). In order to depict taskstructure clearly, we will analyze task relationship andthen construct the task model.

4.1 Task relationship analysis

To support task decomposing and scheduling, we

propose a tree model called task relationship tree (TRT)to represent tasks and their relationship.

Definition 1 (TRT): A TRT is a directedgraph(Start,Out, V, E), augmented with a unique entrynode Start and a unique exit node Out. V denotes theset of nodes and E denotes the set of edges. For any twonodes A and B connected with an edge, the differenceof the layers ofnode A and B is 1.

Definition 2 (Data Dependence): If task A can beperformed on the condition that the data offered by task(B1, ..., Bm) are available, then {B1, ..., Bm} is calledthe data dependence of task A.

Defi'nition 3 (Control dependence): If the resultsof task B decide whether task A will be performed, thenB is the control dependence of A.

Scheduling agents

Decomposing Agent

User agent Q)ijr lr l,, |,,Performing agent

Environmentnme

Definition 4 (Sequence relationship): For anynode A and B in TRT, if B is the data dependence orcontrol dependence of A, then A must be performedafter B. The relationship between A and B is calledsequence relationship.

Definition 5 (Occupying relationship): Therelationship between agent and resource is calledoccupying relationship.

All of above relationship among tasks, agents andresources is the basis of TRT constructing andrepresentation.

4.2 TRT based on agent's roles

According to the architecture in Figure 1, the tasksare processed by different agent in a stepwise manner.The view of task for different role is also different. Forexample, the "user agent" has the global view of taskand the "performing agent" only has partial view oftask.

In our TRT, the nodes can be divided into severaltypes: start node, end node, the minimal sub-task node,agent node and resource node(Figure 2). The start nodeincludes some initializing actions and may be null. Theend node is the exit of all sub-tasks. The minimal sub-task node is the minimal unit of decomposing. In theTRT, all the sub-tasks assigned to an agent compose an"agent" node and the "agent" node is responsible for agroup of minimal sub-task nodes. "Resource" nodedenotes the network resources, such as CPU, bandwidthand etc.. "Resource" node is of two types: fixedresource and active resource. The fixed resource is notsubstitutable and the active resource is transformable.The directed edges in TRT represent sequencerelationship based on data dependence and controldependence.

( | star~ ) Sub-task <

The minimal Sequencesub-task relationship

end ) Sub-task

Agent

occupying

resource /Fig. 2 The elements of TRT

We define a network monitoring task as an exampleto explain the TRT model. The task in Figure 3 is tomonitor the main devices in the pervasive computingenvironment. Every monitoring sub-task is assigned toone agent, and the agent may need some resources

when performing the task. The directed edge gives thesequence relationship amongst the sub-tasks. Duringthe course of decomposing, the "decomposing agent"sends one layer of sub-tasks in TRT to the "schedulingagent", and the "scheduling agent" scheduling the"performing agent" to execute sub-tasks according toits' task view. The task view of the "scheduling agent"is smaller than the "decomposing agent" and the taskview of the "performing agent" is the smallest.

Route Wirle esscrouter Moboiecell > We see

\ Fixed /Data/dependata\XdFixed Xecsoucc eve.e dpnec dpldl ee7e.e \ esource

Fg 3 TakRec Record the d"td>ecoms aent"

Occuy7l / _

ct e

X~~~~~ctiv\ Rsowce/g/0 0 e suIpased the X u'rv:*

Report the perfonmance

Fig. 3 Task view of the "decomposing agent"

4.3 TRT based task processing method

TRT is a directed graph and a hierarchical structure.Therefore, using breadth first search (BFS) method totraverse the graph is just traversing the TRT layer bylayer. The graph contains control dependence and datadependence, so control dependence set and datadependence set of every sub-task can be obtained byusing BFS algorithm traversing the directed graph, andthe nodes with the same priorities in the graph arestored in a new task file (a sub-TRT). The file is sent to"scheduling agent", and the "scheduling agent" willschedule "performing agent" to perform the sub-tasksdefined in the new file in parallel. The "performingagent" can access the corresponding sequencerelationship from its' task file.

Task decomposing algorithm of "decomposingagent" is:

(1) Traverse the first layer of TRT, and for everynode in this layer, which as the head node, we establisha task queue (chain). At the same time, the sub-tasks inthis layer are stored in a new task file. This task file issubmitted to the "scheduling agent".

(2) Traverse the next layer of TRT, and produce thecontrol dependence set of sub-tasks and the datadependence set of the nodes in this layer. If a task'sdependence in the previous layer is more than one, thenthis task chain is end and a new task queue isestablished, otherwise, the node is added in itsdependence's queue. At the same time, the sub-tasks inthis layer are stored in a new task file. This task file issubmitted to "scheduling agent". The nodes in the samelayer can be executed in parallel

(3) If the nodes in the TRT are all traversed, thealgorithm is end, otherwise, turn to (2).

The scheduling method for the "scheduling agent"is:

(1) Receiving the first task file including a group ofparallel tasks, a group of agents are dispatched toexecute the tasks.

(2) Receiving the next task file in the next layer ofTRT, if a task node is one item of the existing task

queue, then the task is allocated to the same agent,otherwise, is dispatched to a new agent. The tasks in thesame layer are executed in the parallel manner.

(3) If the task nodes in the TRT are all allocated,the algorithm is end, otherwise, turn to (2).

5. XML based agent task representation

When the agent roles based TRT model and TRTbased task processing algorithm is established, how torepresent the TRT? A key issue to successfully provideinformation about dependencies is the introduction of aunified description format to represent the dependenciesin a common way. This is especially necessary to hidethe heterogeneity of the pervasive computing systems.Furthermore, the representation must be easilyunderstood by various agents. In addition, it should bepossible to extend the dependency informationdetermined at agents without requiring changes to otherparts of the infrastructure.

In order to meet these goals, our approach is basedon several key features ofXML. XML provides flexibleand extensible mechanisms to define a notation for thedescription of TRT information. Based on XMLtechnology, we proposed a TRT and agent view baseddescription language (TTVDL). Application on aTTVDL document includes four stages: establishingTTVDL elements, generating TTVDL document,explaining TTVDL document and manipulatingTTVDL document. The main elements of TTVDL are"agent", "task", "succ-tasks" and "resource". Todescribe the structure an XML document, we make useof XML Schema[12]. We will use DOM(DocumentObject Model) parsers to parse XML documents, theygenerate an object model (Java objects instantiatedfrom pre-defined DOM classes) with hierarchicallylinked objects reflecting the exact structure of thedocument.

5.1 The structure of the decomposing agent'stask view

Fig. 4 The schema of decomposing agent's task view

Figure 4 shows the decomposing agent's task viewwith the whole of task structure comprised. Thedependence relationship can be selected by means oftraversing the DOM structure.

5.2 The structure of the scheduling agent's taskview

Figure 5 gives the task schema of scheduling agent.In the figure, an "agent" is responsible for some "task"and possesses some "resource".

The performing agent's task schema is similar to thatof the scheduling agent. The only difference betweenthem is the number of "agent" nodes. This just showsthat the scheduling agent has more information thanperforming agent. The properties correlative with"resource" can offer the information on which theagents will negotiate.

V~~~~~~t5 yi,5X5R

Fig. 5 The schema of scheduling agent's task view

6. Case of the platform and taskrepresentation

As discussed in the previous sections, the proposedagent-based pervasive computing platform needs to beevaluated against the following major functionalities:

* Distributed computing.The tasks should be performed in distributed manner

through distributed agents in the environment.* Dynamic execution without user intervening.

After the task is submitted, the task should bedecomposed, allocated dynamically and autonomously.

* Comparative analysis of the performance ofour method with other representing method of tasks.

6.1. Scenario of application

In this application, the goal of this platform is toguarantee the Qos of a user's media stream. Theenvironment for agent running is Aglet[13]. As shownin Figure 6, the network environment of

implementation includes five subnets. All of the devicesin the environment provide running environment foragent. The user who uses PDA in subnet 1 wants todownload a media stream from a media source insubnet_4. But two interfering stream in subnet 2 andsubnet_3 respectively are sending gusty stream to themedia source in order to affect the normal networktraffic.

Fig. 6 The environment of implementation

The user submits his Qos requirements to the agentin the domain by user agent. According to the task file,the scheduling agent will dispatch some agents tomonitor the guaranteed stream. If finding jam, thescheduling agent will dispatch agent to search thebottleneck, if the bottleneck nodes are found, some

performing agents will be dispatched to the bottlenecknode to observe necessary bandwidth for the guaranteedstream.

6.2 Task representation in this application

The task is dynamically decomposed and allocated toagents and the structure of the task is changeable. Forexample, in the course of task allocation, the schedulingagent appends the tag of "agent" and the necessary

information of tasks into the TTVDL document. Wewill now present by means of TTVDL how theapproach described in section 6 can be applied to thescenario. The following codes give an example of taskrepresentation of the scheduling agent.<agent label="Al ">

<task dependence_type="no" name="Ti1_"><method name=" monitor stream" >

<class-base>1 0. 10.1 .5</class-base></method><address>1 0. 10.1.2</address><succ-tasks>

<task dependence_type="control_dep" name="T2_1" pre-

tasks="TI1I Ti 2"><method name="search bottleneck">

<class-base>10.10.1 .5</class-base></method><address>10.10.1.1</address><address>10.10.3. 1</address><address>10.10.5. 1</address><succ-tasks>

<task dependence_type="data_dep" name="T3_1" pre-tasks=" T2_1 T2_2"><method name=" configure">

<class-base>10. 10. 1.5</class-base></method> <address/><succ-tasks/>

</task></succ-tasks>

</task></succ-tasks>

</task><resource>

<agent-list>A I</agent-list><state>1 .0</state>

</resource></agent>

The above TTVDL code is a segment of the wholetask document which describes one agent's task view.

6.3 Performance evaluation of XML-basedrepresentation

In order to evaluate the effectiveness of our system,two methods of task representation were conducted.The objective of these experiments was to compare theperformance of traditional data representing methodwith the method based on TTVDL and TRT proposedin this paper. By arranging two interfering stream in thesubnet_2 and subnet 3 the task of traffic monitoringwas carried out. Firstly, two "performing agent" are

dispatched to subnet 1 and subnet_4 to monitor thetraffic respectively in the media stream's destinationand source. Once the results sent by these two agentsare not consistent which indicates there may be a

bottleneck in the way of transmitting, the "schedulingagent" will dispatch some agents to search bottlenecknode. The sub-tasks were executed in distributedmanner, namely searching bottleneck of traffic andreserving bandwidth. When the scheduling agentreceived the message of the list of bottleneck nodes, itthen dispatched several "performing agent" toaccomplish the configuration automatically. The wholeprocess indicates that once the task was submitted, itwould be decomposed, scheduled and executeddynamically and autonomously without requiring user'sattention.

As we can see in Table 1, there is a big difference inperformance between these two methods.

Table 1 comparison of performance between our method andthe way of byte array

The items of Using TTVDL tasks Using bytecomparison based on TRT arrayFormat XML document Byte arrayReadable and Difficult tochangeable understandThe elationship Can represent it Difficult toamongst tasks explicitly represent it

Very easy to makeCan verify the mistakes because

maintenance document by XML the data is storedschema by means of byte

arrayFlexibility and

Very convenient Very limitedextensibility

I, ."Pe

Route, 310.10.5.110.10.4.2

6.4 Performance of distributed task processingmethods

To evaluate the performance and adaptability of our

decomposing algorithm and scheduling method, we

apply the IBM Aglet as our implementation example.Under the simulation, with the nodes in the pervasivecomputing environment increasing, the processing timeof task is computed.

Centrali zed manner Di stributed manner

550050004500 -

4* 40000350300025002000

iooo10000 E

10 20 30 40 50 100 200

The number of network nodes in the pervasive computingenvironment

Fig. 7 Comparison of processing time between centralizedmanner and distributed manner

Two methods are implemented to test theprocessing time, one is using centralized manner toexecute the tasks defined in TRT, the other is usingdistributed manner to execute the tasks in TRT. Incentralized manner, only one "performing agent" isdispatched to execute the tasks, and during the course

of executing, the results are returned by messaging. Indistributed manner, multi-agents are dispatched toexecute the tasks in the same layer of TRT. The resultsof two methods (Figure 7) show that the processingtime is increasing with the increasing network nodes.Especially, when the nodes increase to 40approximately, the processing time of centralizedmethod begin to surpass the distributed method. So thedistributed manner described in Section 3 is adaptivefor large network.

7. Conclusion and outlook

This paper has presented an agent based pervasivecomputing platform involving different roles of agents.Based on analyzing the relationships amongst tasksclearly, a new kind of task representation andprocessing method based on TRT and TTVDL has beenproposed for this platform. Unlike traditional methods,which make the task process more complex especiallyas the task grows, our proposed TRT model containstask relationship and represents the task explicitly, theproposed TTVDL can represent TRT in the form ofXML and support dynamic changing.We hope that our research has laid the foundation

for a new method for task processing in pervasivecomputing. Here are some challenges that need to beovercome in the future research. Practical deploymentof the proposed pervasive computing framework wouldrequire all devices to be equipped with the agent

software. The initial task requires to be predefined, sothe future research will focus on automatic generatingand extracting technology for task.

Acknowledgements

This work is supported by National Natural ScienceFoundation of China under Grants No. 90412014 and90604004, and Jiangsu Provincial Key Laboratory ofNetwork and Information Security under Grants No.BM200320 1.

References

[1] Liu R., Chen F., Yang H., and et al. Agent-based WebServices Evolution for Pervasive Computing.11th Asia-Pacific Software Engineering Conference, 2004, pp. 726-731[2] A. Ramdane-Cherif, S. Benarif, N. Levy. AgentTechnologies for Pervasive Computing and Communications.The Third IEEE International Conference on CognitiveInformatics.2004[3] Bozdag D., Catalyurek U., Ozguner F.. A task duplicationbased bottom-up scheduling algorithm for heterogeneousenvironments. 20th International Parallel and DistributedProcessing Symposium. 2006[4] Baskiyar, S.. Scheduling task in-trees on distributedmemory systems. In: 15th International Parallel andDistributed Processing Symposium. 2001[5] Kawaguchi, T.. Static allocation of a task tree onto alinear array. IEEE International Symposium on Circuits andSystems, 1993, vol.3: 1921-1924[6] Anja Feldmann, Ming-Yang Kao, Jiri Sgall, Shang-HuaTeng. Optimal online scheduling of parallel jobs withdependencies. In: 25th Ann. Symp. on Theory of Computing(STOC). 1993, 642-651[7] Dhodhi, M.K.; Ahmad, I..Task tree scheduling onto lineararrays using tabu search. IEEE Proceedings on Computersand Digital Techniques. 1997, 144(5): 317-323[8] S Kambhampati, C Knoblock, Q Yang. Planning asrefinement search: a unified framework for evaluating designtradeoffs in partial order planning. ASU CSE TR 94-002, AlSpecial Issue on Planning and Scheduling, 1995[9] D E Wilkins. Using the SIPE-2 planning system: Amanual for Version 5.0 (Working Document). Menlo Park,CA: Stanford Research International, Artificial. IntelligenceCenter, 1998[10] Vincent Regis, Horling Bryan, Lesser Victor.Experiences in Simulating Multi-Agent Systems UsingTAEMS. The Fourth International Conference on MultiAgentSystems. 2000[11] A. Keller, J. L. Hellerstein and etc.. The CHAMPSSystem: Change Management with Planning and Scheduling.Proceeding of 2004 IEEE/IFIP NetworkOperations&Management Symposium[12] J. Roy and A. Ramanujan. "XML schema language:taking XML to the next level" IT Professional, vol. 3 issue2, March-April 2001, pp. 37-40[13] Aglets: http://www.trl.ibm.com/aglets/