Workshop on Mechatronic Multiagent Systems

Size: px

Start display at page:

Download "Workshop on Mechatronic Multiagent Systems"

Phebe Harper
5 years ago
Views:

1 Workshop on Mechatronic Multiagent Systems UNINOVA, Caparica 15th Feb 2011 Luis Ribeiro José Barata André Cavalcante Rogério Rosa

2 Agenda for today Morning - Theoretical Background 9h00-10h30 Advanced JADE Aspects JADE complex behaviours 10h30 - Break 11h00-11h30 JADE communication behaviours 12h30 - Lunch Afternoon - Practical Exercises 2h00-3h30 Implementation of FIPA communication Protocols Implementation of Complex Behaviours 3h30 - Break 4h00-6h30 Implementation of Complex Behaviours Implementation of Agents in the COMBO controllers (control of a mechatronic setup) 6h30 - End of the Second Day

3 Advanced JADE Aspects

4 The force and the dark side of JADE All currently supported Platforms are JAVA based Cross platform interoperability. Performance JADE normally outperforms other platforms. The Source has endured years of optimization. Support JADE is extensively documented. JADE has a hyperactive mailing list. Ease of Use The API is well documented and easy to use There are several extensions for JADE that foster interoperability and integration with other platforms and technologies.

5 Yesterday... We have seen how we can write and execute behaviours: Behaviour Simple Behaviour OneShot Behaviour Waker Behaviour Cyclice Behaviour Ticker Behaviour And how to explore simple behaviours to establish more complex and rich response. Stepped behaviours (kind of a FSM) Behaviours inside behaviours

6 Yet... How does exactly this execution happens? How are the behaviours scheduled? Why can t we have blocking code inside a behaviour?

7 Some NOTES ON BEHAVIOUR SCHEDULING

8 Agent Thread Path Of Execution From the JADE documentation.

9 Agent Scheduler JADE provides " Support to the execution of multiple, parallel and concurrent agent activities via the behaviour model. JADE schedules the agent behaviours in a nonpreemptive fashion. From the JADE documentation. JADE never shifts contextually from one process to another, instead each behaviour is scheduled for execution in a round-robin fashion.

10 Behaviours Revisited

11 A little bit more complicated in fact Behaviours can be blocked. JADE uses two queues to manage behaviours the ready behaviours queue and the blocked behaviours queue. The scheduler operates in the ready behaviours queue The addbehaviour method puts it on the ready behaviours queue. Blocked behaviours are executed again if: a message is received, the behaviour is manualy restarted, block times out...

12 The problem of Blocking Code Remember Round-Robin non-preemptive The next scheduled behaviour can only execute after the done function in the current behaviour returns anything... While(true) here or While(true) here Block the Agent Forever

13 Some performance issues too Sometimes is better to use smaller and more behaviours that a few complicated behaviours. If we can break-up a task into smaller pieces it may allow the agent to switch faster between the behaviours (processing more parallely ).

14 COMPLEX BEHAVIOURS

15 Some Revision Work First... From: Developing Multiagent System With JADE, Willey, 2007

16 Composite Behaviours Are complex behaviours that execute subbehaviours according to some specific scheduling policy. The scheduling policy normally dictates when the composite behaviour ends. The composite behaviour controls whether some of its sub-behaviours are blocked or running.

17 Sequential Behaviour Is a composite behaviour that schedules the execution of its sub-behaviours sequentially. The first child is executed. Once its done method returns true the second child is executed...until the last. One can add a child behaviour using the method addsubbehaviour. Once the last child returns TRUE the Sequential Behaviour ends (Done function returns TRUE)

18 Sequential Behaviour Normally one does not extend a sequential behaviour. Typicall usage is as follows: public class Agent extends jade.core.agent protected void setup() { SequentialBehaviour sb = new SequentialBehaviour(this); sb.addsubbehaviour(new BasicSimpleBehaviour()); protected void takedown() { super.takedown(); We cannot obviously add Cyclic Behaviours as childs

19 FSM Behaviour Is a composite behaviour that schedules the execution of its sub-behaviours as a finite state machine where the states are the subbehaviours One can add child behaviours and state transitions The FSM behaviour checks the transition table to verify when it should end (after the execution of the last state)

20 FSM Behaviour Normally one does not extend a FSM behaviour. Typicall usage is as follows: protected void setup() { FSMBehaviour fsm = new FSMBehaviour(this); fsm.registerfirststate(new BasicSimpleBehaviour(), "A"); fsm.registerstate(new BasicSimpleBehaviour(), "B"); fsm.registerlaststate(new BasicSimpleBehaviour(), "C"); fsm.registerdefaulttransition("a", "B"); fsm.registertransition("b", "C", 1); We cannot obviously add Cyclic Behaviours as childs

21 Parallel Behaviour Is a composite behaviour that schedules the execution of its sub-behaviours in parallel. Remember that parallel in JADE = Cooperative non preemptive The ending condition can be when all the child-behaviours have finished the execution or one any finishes.

22 Parallel Behaviour Normally one does not extend a Parallel behaviour. Typicall usage is as follows: protected void setup() { ParallelBehaviour pb = new ParallelBehaviour(ParallelBehaviour.WHEN_ANY); pb.addsubbehaviour(new BasicSimpleBehaviour()); pb.addsubbehaviour(new BasicSimpleBehaviour()); There is a subtle but very relevant difference between a Parallel Behaviour and a Sequential Behaviour

23 Threaded Behaviour Any behaviour can be wrapped as a threaded behaviour and evade the non-preemptive logic of JADE. However special attention needs to be directed to thread behaviours as they evade as well most JADE standard termination procedures. Very often context switching is slower than the cooperative switching. Threaded behaviours should be used carefully and their potential performance gain (if any) properly assessed. Also proper synchronization must be used.

24 About Behaviours in general We can make any composition of behaviours so as to achieved the desired level of functionality in the system This of course means that we are free to combine composite with simple behaviours or/and any extension of those. Composite behaviours however are not, normally, to be extended.

25 Leaving the Agent Scope... INTERACTION WITH THE PLATFORM

26 How does an Agent know... About the available services in the Platform? How it can update its services offer? About the status of other agents in the platform with which it may be interacting?

27 Yellow Pages Service (Directory Facilitator) From: Developing Multiagent System With JADE, Willey, 2007

28 DF Service Registration static public void RegisterInDF(Agent agenttobereguistered, Skill[] skills) { DFAgentDescription dfd = new DFAgentDescription(); dfd.setname(agenttobereguistered.getaid()); for (int i = 0; i < skills.length; i++) { ServiceDescription sd = new ServiceDescription(); sd.settype(skills[i].gettype()); sd.setname(skills[i].getname()); sd.addproperties(new Property(skills[i].getName(), skills[i].tostring())); dfd.addservices(sd); try { DFService.register(agentToBeRegistered, dfd); catch (FIPAException fe) { fe.printstacktrace(); Registration of the type and Name of a Service

29 DF Finding About Services static public DFAgentDescription[] FindAgents(Agent agentowner, String servicename, String servicetype) { DFAgentDescription[] agents = null; DFAgentDescription ad = new DFAgentDescription(); ServiceDescription sd = new ServiceDescription(); sd.settype(servicetype); sd.setname(servicename); ad.addservices(sd); try { agents = DFService.search(agentOwner, ad); catch (FIPAException ex) { agents = null; Logger.getLogger(Agent.class.getName()).log(Level.SEVERE, null, ex); return agents; The sort of service the agent is looking for

30 Agent Management System AMSSubscriber myamssubscriber = new AMSSubscriber() { protected void installhandlers(map handlers) { // Associate an handler to born-agent events EventHandler creationshandler = new EventHandler() { public void handle(event ev) { BornAgent ba = (BornAgent) ev; System.out.println("Born agent " + ba.getagent().getname()); ; handlers.put(introspectionvocabulary.bornagent, creationshandler); // Associate an handler to dead-agent events EventHandler terminationshandler = new EventHandler() { ; public void handle(event ev) { DeadAgent da = (DeadAgent) ev; System.out.println("Dead agent " + da.getagent().getname()); agenttoskillmappingcontrol.removeskillsby(da.getagent()); ; handlers.put(introspectionvocabulary.deadagent, terminationshandler); Event Fired when a new agent is plugged on the Platform Event Fired when a new agent is taken from the Platform

31 Summing Up... So far we know how to: Define an agent behaviour (from the very simple to the very complex) Interact with the platform to address changes of state (loss and addition of functionalities in the System) NEXT STEP Have the agents communicating to explore the potential of group interaction

32 BREAK

33 Communication Concepts and Behaviours

34 Yesterday... ACL - FIPA From An Introduction to MultiAgent Systems by Michael Wooldridge, John Wiley & Sons, 2002

35 FIPA Request Interaction Protocol

36 FIPA Contract Net Interaction Protocol

37 Exceptions to both Protocols

38 Auctionning Interactions

39 The JADE Packages we will be interested in... JADE implements most of the FIPA interaction protocols in jade.proto package. Each side of the communication is assigned a behaviour (Initiator and Receiver) These behaviours automatically implement the communication protocol therefore we only have to decide how to handle the message handlers...

40 JADE only implements the following: AchieveREInitiator This is a single homogeneous and effective implementation of all the FIPA-Request-like interaction protocols defined by FIPA, that is all those protocols where the initiator sends a single message (i.e. it performs a single communicative act) within the scope of an interaction protocol in order to verify if the RE (Rational Effect) of the communicative act has been achieved or not. AchieveREResponder This is a single homogeneous and effective implementation of all the FIPA-Request-like interaction protocols defined by FIPA, that is all those protocols where the initiator sends a single message (i.e. it performs a single communicative act) within the scope of an interaction protocol in order to verify if the RE (Rational Effect) of the communicative act has been achieved or not. ContractNetInitiator ContractNetResponder IteratedAchieveREInitiator ProposeInitiator ProposeResponder SimpleAchieveREInitiator SimpleAchieveREResponder This class implements the Fipa-Contract-Net interaction protocol with an API similar and homogeneous to AchieveREInitiator. Behaviour class for fipa-contract-net Responder role. This class implements the initiator role in the iterated version of fipa-request like interaction protocols. This class implements the Fipa-Propose interaction protocol with an API similar and homogeneous to AchieveREInitiator. Behaviour class for fipa-propose Responder role. This is simple implementation of the AchieveREInitiator. This is a single homogeneous and effective implementation of all the FIPA-Request-like interaction protocols defined by FIPA, that is all those protocols where the initiator sends a single message (i.e. it performs a single communicative act) within the scope of an interaction protocol in order to verify if the RE (Rational Effect) of the communicative act has been achieved or not. SSContractNetResponder SSIteratedAchieveREResponder SSIteratedContractNetResponder SSResponderDispatcher SubscriptionInitiator SubscriptionResponder SubscriptionResponder.Subscriptio n Single Session version of the Responder role in the Fipa-Contract-Net protocol. Single Session version of the Responder role in the Iterated-Fipa-Request protocol. This behaviour is designed to be used together with the Single-Session responder protocol classes. This is a single homogeneous and effective implementation of the initiator role in all the FIPA-Subscribe-like interaction protocols defined by FIPA, that is all those protocols where the initiator sends a single "subscription" message and receives notifications each time a given condition becomes true. This is a single homogeneous and effective implementation of the responder role in all the FIPA-Subscribe-like interaction protocols defined by FIPA, that is all those protocols where the initiator sends a single "subscription" message and receives notifications each time a given condition becomes true. Inner calss Subscription This class represents a subscription.

41 Lets go for some examples... private class InitiatorBehaviour extends AchieveREInitiator { public InitiatorBehaviour(Agent ag, ACLMessage msg) { super(ag, protected void handleagree(aclmessage agreemsg) { System.out.println("HANDLING AGREE MESSAGE ###################################"); Initiator side of the REQUEST protected void handleinform(aclmessage informmsg) { System.out.println("HANDLING INFORM MESSAGE ###################################"); String result = protected void handlerefuse(aclmessage refusemsg) { System.out.println("HANDLING REFUSE MESSAGE ###################################");

42 Now the Responder Side private class ResponderBehaviour extends AchieveREResponder { public ResponderBehaviour(Agent agent, MessageTemplate template) { super(agent, protected ACLMessage handlerequest(aclmessage requestmsg) { System.out.println("HANDLING REQUEST MESSAGE ###################################"); ACLMessage response = requestmsg.createreply(); response.setperformative(aclmessage.agree); response.setcontent("i know the operation therefore I agree to compute it"); return protected ACLMessage prepareresultnotification(aclmessage requestmsg, ACLMessage response) { ACLMessage inform = requestmsg.createreply(); inform.setperformative(aclmessage.inform); inform.setcontent("done"); return inform;

43 public class CNETInit extends ContractNetInitiator { public CNETInit(Agent a, ACLMessage cfp) { super(a, protected void handleallresponses(vector responses, Vector acceptances) { super.handleallresponses(responses, protected void handleallresultnotifications(vector resultnotifications) { protected void handleinform(aclmessage inform) { protected void handlepropose(aclmessage propose, Vector acceptances) { super.handlepropose(propose, protected void handlerefuse(aclmessage refuse) { super.handlerefuse(refuse); Contract Net Initiator

44 public class CNETResponder extends ContractNetResponder { public CNETResponder(Agent a, MessageTemplate mt) { super(a, protected ACLMessage handleacceptproposal(aclmessage cfp, ACLMessage propose, ACLMessage accept) throws FailureException { return super.handleacceptproposal(cfp, propose, protected ACLMessage handlecfp(aclmessage cfp) throws RefuseException, FailureException, NotUnderstoodException { return protected ACLMessage prepareresultnotification(aclmessage cfp, ACLMessage propose, ACLMessage accept) throws FailureException { return super.prepareresultnotification(cfp, propose, accept); Contract Net Responder

45 Important Note... The contract Net Responder and the Request Responder are composite Behaviours. In particular FSM behaviours (FSM scheduling applies). This also means that other behaviours can execute between each communication step.

46 About Agent Messages Receiving a Message is an important event for an Agent. For instance receiving a message causes an agent to execute blocked behaviours. The Agent Message queue is not Unlimted by default

47 Some more Advanced NOTES ON WAKER AND TICKER BEHAVIOURS

48 Recurring Actions If we need a recurring action every n miliseconds we can solve a problem with a Ticker Behaviour. What if we need to have two actions one x miliseconds after the other?

49 Recurring Actions We may feel inclined to do the following: SequentialBehaviour seq = new SequentialBehaviour(); seq.addsubbehaviour( new WakerBehaviour( 250 ms)...); seq.addsubbehaviour( <... OneShot to Print Msg 1...> ); seq.addsubbehaviour( new WakerBehaviour( 500 ms)...); seq.addsubbehaviour( <... OneShot to Print Msg 2...> ); addbehaviour( seq ); Which will not work because the waking time is computed from the moment a behaviour is created and not from the moment it is set for execution. From:

50 Also... The same result would be achieved with the following simplified code: From:

51 What we need is to... Make sure the second waker behaviour is created precisely after the first executes: From:

52 Some NOTES on DEBUGGING

53 Remote Monitoring Agent

54 Sniffer Agent

55 Introspection Agent

56 DF Gui

57 Some bad news... Some of these tools do not work properly when we consider the interaction between the PC and COMBO. Also the CDC JAVA profile does not implement the List interface which among other things implies that we cannot use: LinkedLists, ArrayLists,... Object creation ia also relatively performance expensive in CDC so be carefull about printouts

58 What s next... Lunch And Hands on Exercises (After lunch)

Programming Agents with JADE for Multi-Agent Systems

Programming Agents with JADE for Multi-Agent Systems Ass.Lecturer Noor Thamer Based on Jade, Java and Eclipse documentation Ass.Lecturer Noor Thamer 1 Content Briefly about components JADE overview Setting