Agents in AjSharp (Part 1)

I started to implement agent ideas in my AjSharp interpreter. I explored channel, queue channels and futures in previous posts:

Channels and GoRoutines in AjSharp (Part 1)
Channels and GoRoutines in AjSharp (Part 2)
AjSharp: Implementing Futures
Queue Channels in AjSharp

and a direct parallel implementation in C#:

Genetic Algorithms using GoRoutines and Channels in C#

but it would be nice to have a more clear model for parallel computation. In non-trivial programs, the management of multiple channels could be cumbersome, as I showed in the genetic algorithm implementation. So, I extend the language to support agent-like objects, towards a partial actor model, with  declarations like:

agent MyAgent {
    // ....
}
An agent definition is like a class, you can create agents using the new operator and constructors:
agent = new MyAgent(parameter);
The difference is: when the agent instance is created, it launches a separate background thread to process a queue, where the method calls are collected (method and its parameters). A minimal example:
agent IncrementAgent 
{
  sub Process(channel, value)
  {
    channel <- value + 1;
  }
}
myagent = new IncrementAgent();
channel = new Channel();
myagent.Process(channel, 1);
result = <-channel; // result == 2

The call myagent.Process(..) is put in the agent queue, and it’s processed by the agent thread. Actually, the internal queue is a queue channel, so synchronization between callers and agent call processing is automatic.
To implement agents, I added AgentFunction class, representing the method to call. It’s invocation forwards the call to the agent process:
public object Invoke(IBindingEnvironment environment, object[] arguments)
{
    AgentObject agent = (AgentObject)((ObjectEnvironment)environment).Object;
    agent.SendInvoke(this.function, environment, arguments);
    // TODO if function, return a Future
    return null;
    // Old direct code
    //            return this.function.Invoke(environment, arguments);
}

The SendInvoke call puts the invoke information in the agent internal processing queue.
There is an AgentClass, derived from DynamicClass (the normal definition of a class in AjSharp), extended with a new instance creation method:
public override object NewInstance(object[] parameters)
{
    AgentObject dynobj = new AgentObject(this);
    this.NewInstance(dynobj, parameters);
    dynobj.Launch();
    return dynobj;
}

dynobj.Launch() launches the parallel agent processing thread.
In this way, calling an agent method is like a message passing invocation. If you know Smalltalk, remember that a method call is a message with message name symbol and arguments. In my opinion, using the usual dot invoke convention is a clear and transparent way of implementing a message passing-like behavior in “normal” syntax.
This is the current naive agent object implementation:
    public class AgentObject : DynamicClassicObject
    {
        // TODO 100 is hard coded
        private QueueChannel channel = new QueueChannel(100);
        public AgentObject(IClass objclass) 
            : base(objclass)
        {
        }
        public IChannel Channel { get { return this.channel; } }
        public void Launch()
        {
            Thread thread = new Thread(new ParameterizedThreadStart(this.Execute));
            thread.IsBackground = true;
            thread.Start(Machine.Current);
        }
        public void SendInvoke(ICallable function, IBindingEnvironment environment, object[] arguments)
        {
            AgentTask task = new AgentTask() { Callable = function, Environment = environment, Arguments = arguments };
            this.channel.Send(task);
        }
        private void Execute(object parameter)
        {
            Machine machine = (Machine) parameter;
            machine.SetCurrent();
            while (true)
            {
                object obj = this.channel.Receive();
                AgentTask task = (AgentTask) obj;
                task.Callable.Invoke(task.Environment, task.Arguments);
            }
        }
    }
    internal class AgentTask
    {
        internal ICallable Callable;
        internal IBindingEnvironment Environment;
        internal object[] Arguments;
    }

As usual, the code is published at:
http://code.google.com/p/ajcodekatas/source/browse/#svn/trunk/AjLanguage
Next steps:

Explore agent processing in an example. I could port the genetic algorithm example I wrote in C#.
Support invocation of functions in agent: the returning result would be a future, filled by the agent parallel processing of the function call 
A more ambitious one: distributed agents 

Keep tuned!
Angel “Java” Lopez

  
http://www.ajlopez.com 
http://twitter.com/ajlopez