jason-users Mailing List for jason

Hi!

Your proposal is nice and useful for some applications. Although I am
not sure, I guess that in this approach, if the same agent is
performing two actions at the same time, there will be a problem since
the same Action object is used for both actions. If your appl does not
have this circumstance: no problem.

Another minor comment: if your concern is performance, have you
compared the two approaches? I don't know what is faster: if the
creation of a new Runnable or the search for the agent Action (the
line getAgIdBasedOnName). However, if your concern is memory, of
course your solution is far better.

Another solution (used in previous versions of Jason) is simply to not
use the schedule. The scheduleAction calls directly the executeAction
and returns. the "problem" of this solutions is that the agent thread
is executing the action (in the centralised env); so the agent
reasoning stops until the action is finished. However, if the actions
are "small" (in terms of execution time), in general, it is not a
problem.


Best,

Jomi



2009/11/24  <fe...@al...>:
> Good days,
> I have been analyzing Jason's code to see if it was possible to optimize
> of some form and have observed that in the class "Environment.java"
> there was created a new object Runnable for every action of each one of
> the agents. I have tried to create an object Runnable assigned to every
> agent and when one wants to execute an action, call to the object that
> has assigned.
> The realized changes are:
>
> Environment.java
> ----------------
> public Action actions[];
>
> public void init(String[] args) {
>        int qtyag = Integer.parseInt(args[0]);
>        actions = new Action[qtyag];
>        for (int i = 0; i<qtyag; i++)
>        {
>                actions[i]= new Action("wanderer"+(i+1), this,
> environmentInfraTier);
>        }
>    }
>
> ..
>
> public void scheduleAction(final String agName, final Structure action,
> final Object infraData) {
>        int id = getAgIdBasedOnName(agName);
>        //logger.severe("id:"+id+",");
>        actions[id].setAction(action);
>
>        actions[id].setInfraData(infraData);
>        executor.execute(actions[id]);
>        /*new Runnable(){
>            public void run() {
>                try {
>                    boolean success = executeAction(agName, action);
>                    environmentInfraTier.actionExecuted(agName, action,
> success, infraData); // send the result of the execution to the agent
>                } catch (Exception ie) {
>                    if (!(ie instanceof InterruptedException)) {
>                        logger.log(Level.WARNING, "act error!",ie);
>                    }
>                }
>            }
>        });*/
>    }
>
> Action.java (new class)
> -----------
> package jason.environment;
>
> import java.util.logging.Logger;
> import java.util.logging.Level;
>
> import jason.asSyntax.Structure;
>
> public class Action implements Runnable{
>
>        private static Logger logger =
> Logger.getLogger(Environment.class.getName());
>
>        private String agName;
>        private Structure action;
>        private Environment environment;
>        private EnvironmentInfraTier environmentInfraTier;
>        private Object infraData;
>
>        public void setAction(Structure action) {
>                this.action = action;
>        }
>
>        public void setInfraData(Object infraData) {
>                this.infraData = infraData;
>        }
>
>        public Action(String name, Environment env, EnvironmentInfraTier
> environmentInfraTier){
>                agName = name;
>                environment = env;
>                this.environmentInfraTier = environmentInfraTier;
>        }
>
>        @Override
>        public void run() {
>                try {
>            boolean success = environment.executeAction(agName, action);
>            environmentInfraTier.actionExecuted(agName, action, success,
> infraData); // send the result of the execution to the agent
>        } catch (Exception ie) {
>            if (!(ie instanceof InterruptedException)) {
>                logger.log(Level.WARNING, "act error!",ie);
>            }
>        }
>
>        }
>
>        public void setEnvironmentInfraTier(EnvironmentInfraTier
> environmentInfraTier) {
>                this.environmentInfraTier = environmentInfraTier;
>        }
>
> }
>
> What do you think of this change?
>
> Regards.
>
>
> ------------------------------------------------------------------------------
> Let Crystal Reports handle the reporting - Free Crystal Reports 2008 30-Day
> trial. Simplify your report design, integration and deployment - and focus on
> what you do best, core application coding. Discover what's new with
> Crystal Reports now.  http://p.sf.net/sfu/bobj-july
> _______________________________________________
> Jason-users mailing list
> Jas...@li...
> https://lists.sourceforge.net/lists/listinfo/jason-users
>

Good days, 
I have been analyzing Jason's code to see if it was possible to optimize
of some form and have observed that in the class "Environment.java"
there was created a new object Runnable for every action of each one of
the agents. I have tried to create an object Runnable assigned to every
agent and when one wants to execute an action, call to the object that
has assigned.
The realized changes are:

Environment.java
----------------
public Action actions[];

public void init(String[] args) {
    	int qtyag = Integer.parseInt(args[0]);
    	actions = new Action[qtyag];
        for (int i = 0; i<qtyag; i++)
        {
        	actions[i]= new Action("wanderer"+(i+1), this,
environmentInfraTier);
        }
    }

..

public void scheduleAction(final String agName, final Structure action,
final Object infraData) {
        int id = getAgIdBasedOnName(agName);
        //logger.severe("id:"+id+",");
    	actions[id].setAction(action);
    	
        actions[id].setInfraData(infraData);
    	executor.execute(actions[id]);
        /*new Runnable(){
            public void run() {
                try {
                    boolean success = executeAction(agName, action);
                    environmentInfraTier.actionExecuted(agName, action,
success, infraData); // send the result of the execution to the agent
                } catch (Exception ie) {
                    if (!(ie instanceof InterruptedException)) {
                        logger.log(Level.WARNING, "act error!",ie);
                    }
                }
            }
        });*/
    }

Action.java (new class)
-----------
package jason.environment;

import java.util.logging.Logger;
import java.util.logging.Level;

import jason.asSyntax.Structure;

public class Action implements Runnable{

	private static Logger logger =
Logger.getLogger(Environment.class.getName());
	
	private String agName;
	private Structure action;
	private Environment environment;
	private EnvironmentInfraTier environmentInfraTier;
	private Object infraData;
	
	public void setAction(Structure action) {
		this.action = action;
	}

	public void setInfraData(Object infraData) {
		this.infraData = infraData;
	}

	public Action(String name, Environment env, EnvironmentInfraTier
environmentInfraTier){
		agName = name;
		environment = env;
		this.environmentInfraTier = environmentInfraTier;
	}
	
	@Override
	public void run() {
		try {
            boolean success = environment.executeAction(agName, action);
            environmentInfraTier.actionExecuted(agName, action, success,
infraData); // send the result of the execution to the agent
        } catch (Exception ie) {
            if (!(ie instanceof InterruptedException)) {
                logger.log(Level.WARNING, "act error!",ie);
            }
        }
		
	}

	public void setEnvironmentInfraTier(EnvironmentInfraTier
environmentInfraTier) {
		this.environmentInfraTier = environmentInfraTier;
	}

}

What do you think of this change?

Regards.