Bond Extensions

• The integration of the Java Expert System Shell (JESS) inference engine
• The integration of IBM TSpaces
• The synchronization of the agents
• The remote strategy loading
• Distributed and adaptive algorithms for fault detection and fault information dissemination

The integration of the Java Expert System Shell (JESS) inference engine

An inference engine is necessary to support intelligent agent behavior. In this process, the agent uses a knowledge acquisition mechanism to gather facts, then these facts and associated sets of rules are supplied as input to the inference engine. Then, the new facts that are produced by the engine are fed to actuators, mechanisms that implement agent reactions. Consequently, an agent framework should be flexible enough to allow
integration of one or more inference engines. Integrating an engine into an existing system is a nontrivial task because inference algorithms are time-consuming, and the engine should fit into the scheduling model of the agent and interface the knowledge acquisition model and the actions model of the agents.

The Bond agents are able to perform inference by using the JESS inference engine.  The class, bondInferenceEngine, is a Bond object that wraps the JESS inference engine and provides interfaces to access the inference engine.

The Bond agent framework provides bondInferenceStrategy and bondInferenceGuiStrategy that allow agents to access the JESS inference engine, which is stored in the model of the agents. The inference engine are provided with a set of rules and facts. The rules consist of conditions and action.  The action is executed when the specified conditions are matched. The conditions are matched when the facts that are specified in the conditions are present.

The example agents that use the inference capability is

• Stockwatcher agent: The agent monitors the stock quotes and sends alert E-mails to users when the prices reach specified values. The rules specify the conditions that trigger E-mail transmission. The facts represent the current values of the stocks to which the users subscribe.
• MPEG streaming system: Two agents are involoved in transmit MPEG streaming. One agent on the MPEG server is responsible for control streaming mode, the other agent on the client is for displaying frames and feedbacking the measured performance to the agent on the server. The agent on the server decides to either change streaming methods or reserve resources based on the collected resource data and the feedback from the agent on the client. The rules specify the conditions that trigger the changes of the streaming methods or the resource reservation.

The integration of IBM TSpaces

The agents are able to control and monitor the components of networked systems. The components of networked systems interact with each other in various ways. Among the ways, asynchronous, anonymous, and collective communications are widely used. Accordingly, the agents responsible for interaction among the components should be able to support such communications.

Tuplespace enables the agents to perform those communications; it is a shared dataspace for the agents to write, read, and retrieve tuples that are ordered sets of typed fields. The integration of the tuplespace brings similar challenges to those of the above integration of inference engines.

The Bond agents can use the tuplespace service, which is implemented in bondTupleSpace. The bondTupleSpace is a Bond object that wraps the tuplespace implementation of IBM, TSpaces, which provides a fault-tolerant and transaction-based access tuplespace.
The tuplespace service can be started from the GUI of the resident.

There are strategies that provides the interface to access the tuplespace service: bondTupleSpaceEnabledStrategy and bondTupleSpaceEnabledGuiStrategy.   They are used as the base classes from which other classes requiring the tuplespace service access can be extended.  Some of the interfaces provided by the above classes are as follows:

• putIntoTupleSpace(String host, String sname, String s, Serializable o) : it allows agents to insert a tuple that consists of two fields (s,o) into the subspace sname, of the tuplespace service running on the machine host.
• host: the name of the machine on which the tuplespace service is running.
• sname: the tuplespace consists of a set of subspaces of which names are different each other. sname specifies the name of the subspace.
• s: the first field of the tuple
• o: the second field of the tuple
• getFromTupleSpace(String host, String sname, String s) : it allows agents to retrieve a tuple that has String s as the first field from the subspace sname of the tuplespace running on the machine host. The agents that call this interface is blocked until the tuple matching the condition is returned.

Object copyFromTupleSpace(String host, String sname, String s) : it is same as getFromTupleSpace() except that it leaves a copy of the tuple in the tuplespace. It is blocked until the tuple is returned.
The channel is a shared FIFO queue that is stored in the tuplespace service.
• setupChannel(String host, String sname, String cname) : it allows agents to create a channel cname in the subspace sname in the tuplespace on the machine host.
• putIntoChannel(String host, String sname, String cname, Serializable o) : it allows agents to enqueue object o into the channel cname.
• getFromChannel(String host, String sname, String cname) : it allows agents to dequeue the first item from the channel cname.


The above interfaces requires the name of the machine on which the tuplespace service is running and the name of the subspace to which the action is targeted. These specification can be avoided by set up the default machine name and the subspace name by using the interface,
setTupleSpace(String host, String sname).
 

The synchronization of the agents

The barrier is used to synchronize a set of agents that involve in a task. The barrier originates as a logical point in parallel programs at which all participating processors are synchronized to start and end their executions.

A master--worker barrier synchronization through a shared space was implemented. The barrier is implemented as a tuple in a tuplespace.
The barriers have names that identify and distinguish themselves from other barriers. In the beginning, a master agent creates a barrier to the shared space. The barrier has an associated goal number, the number of tokens that this barrier must collect before notifying the master agent of the completion of all worker agents. Then, the master agent signals a set of worker agents to proceed by sending messages, which also include the barrier name. Upon completion of their tasks, the worker agents post tokens to the barrier, which in turn increase the barrier's internal variable, current token number, incrementally.

The example agent-based system to use the barrier is an agent-based Web benchmarking system.
 

The remote strategy loading

The agent factory, which assembles agents as directed by the blueprint, can download strategies that are required to assemble the agents from remote places, e.g., strategy repository. The agent factory searches for the strategies from the three places in the following order: first, local disk, a specified strategy repository, and finally a default strategy repository. The request for agent creation can contain the parameter that specifies the strategy repository from which required strategies can be downloaded.

The implementation can be found in bondLoader.  A part of bondLoader that is related to remote strategy loading is as follows:

 public Class loadClass(String name, Vector searchpaths) {
      String completename;

       /*
            search for strategies in local disk
       */

       for(int i=0; i!=searchpaths.size(); i++) {
        try {
           Class cl = Class.forName(makeName(name, (String)searchpaths.elementAt(i)));
           /*
               if a required strategy is found, return.
           */
           return cl;
        } catch(ClassNotFoundException cnfe) {
        } catch(Exception ex) {
          Log.Debug("Some exception:");
          ex.printStackTrace();
        }
      }

      /*
          If the execution flow reaches this point, the strategy is not available locally.
          Load classes remotely
       */

      if (cloader == null) {
        /*
             the location of the strategy repository specified in the agent creation request message.
         */
        String c_repository = System.getProperty("bond.current.strategy.repository");
        /*
             the location of the default strategy repository
         */
        String repository = System.getProperty("bond.strategy.repository");
        if (c_repository != null && repository != null) {
        try {
             URL urlList[] = {new URL(c_repository), new URL(repository)};
            cloader = new URLClassLoader(urlList);
        }
        catch (MalformedURLException e) {
            e.printStackTrace();
        }
        }
       else if (repository != null) {
       try {
          URL urlList[] = {new URL (repository)};
          cloader = new URLClassLoader(urlList);
        }
        catch (MalformedURLException e) {
          e.printStackTrace();
        }
      }
 

Distributed and adaptive algorithms for fault detection and fault information dissemination

The Bond agents form a federation, which refer to a set of agents that collaborate a task, and monitor the fault of other agents in distributed way and allows new/repaired agents to join the federation any time. The agents should monitor only one agent and be monitored by only one agent, thus the agents in a federation form a ring monitoring topology if the monitoring relations among the agents are represented as directed graph. The agents detects either the fault of the agent or the join of new/repaired agent. Once such information is detected, the agent starts to disseminate the information to other agents. The agents involving in disseminating the information form a binary tree.
The detail about the algorithms can be found in the paper.

The algorithms were implemented by the following classes that are availabe in Bond/bond/agent/FaultDetection:

• bond.agent.FaultDetection.bondFaultDetectionExecutable: The base class of all executable classes for the fault detection and information dissemination.
• bond.agent.FaultDetection.bondFaultDetectionMH: it handles all incoming messages and dispatches them to proper handler.
• bond.agent.FaultDetection.bondFaultDisseminator: it starts to disseminate the events that are detected.
• bond.agent.FaultDetection.bondFaultInfoHandler: it handles incoming messages that contain event information.
• bond.agent.FaultDetection.bondFaultMonitor: it performs a peridic monitoring by sending messages to the one being monitoring.
• bond.agent.FaultDetection.bondFaultMonitorSearcher: it requests other agents to monitor "me".
• bond.agent.FaultDetection.bondFaultStatus: the fault status table.

The execution of the algorithm is controlled by whether the agent control message "start-agent" contains a parameter ":alias" or not. If the parameter ":alias" is provided and a configuration parameter, bond.faultDetection, as true in the file, properties of which location is Bond/bond/core/, the agents are configured to embed the implementation of the above algorithms. The following is a part of sphAgentControl() method of bondAgent.java.

if (m.content.equals("start-agent")) {
       String als = (String)m.getParameter(":alias");
      if (als != null) {
         dir.addAlias(als, this);
         initFaultDetection();
      }
      start();
      return;
    }

where String als should be non-null and has an agent ID in order to run the algorithms by calling the method initFaultDetection(), which in turn,

  public void initFaultDetection() {
    String tmp;
    if ( (tmp = System.getProperty("bond.faultDetection")) != null && tmp.equals("true")) {
      fs = new bondFaultStatus(dir.getAlias(this)+"+"+com.localaddress+":"+com.localport);
      fs.startFaultDetectionMessageHandler();
      // load system graph
      fs.initStatusTable(System.getProperty("default.monitoring.agent"));
      // start searching
      fs.startMonitorSearcher(true);
    }
  }

where it first create a fault status table and start to run the algorithms. The agent ID that is given as the value of the parameter ":alias" should be non-negative integer. It should be cautious not to assign the same ID to multiple agents.