Logo
Distributed Genetic Programming Framework
print print

File org.dgpf.gp.netautomaton.base.NetAutomaton.java

Here you can find all the information about the file org.dgpf.gp.netautomaton.base.NetAutomaton.java. You may explore it here or download it onto your local disk.
/*
 * Copyright (c) 2006 Thomas Weise
 *
 * E-Mail           : tweise@gmx.de
 * Creation Date    : 2006-01-02 09:11:14
 * Original Filename: org.dgpf.netautomaton.base.NetAutomaton.java
 * Version          : 2.2.3
 * Last modification: 2006-06-04
 * Last modified by : Thomas Weise
 *
 * License          : GNU LESSER GENERAL PUBLIC LICENSE
 *                    Version 2.1, February 1999
 *                    You should have received a copy of this license along
 *                    with this library; if not, write to the Free Software
 *                    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *                    MA 02111-1307, USA or download the license under
 *                    http://www.gnu.org/copyleft/lesser.html.
 *
 * Warranty         : This software is provided "as is" without any
 *                    warranty; without even the implied warranty of
 *                    merchantability or fitness for a particular purpose.
 *                    See the Gnu Lesser General Public License for more
 *                    details.
 */


package org.dgpf.gp.netautomaton.base;

import org.dgpf.gp.automaton.base.Automaton;
import org.dgpf.gp.automaton.base.Program;

/**
 * The network-enabled version of an org.dgpf.automaton.
 *
 * @author Thomas Weise
 */

public class NetAutomaton extends Automaton
  {
/**
 * The serial version uid.
 */

  private static  final long              serialVersionUID  = 1;

/**
 * The network support containing all automatons of this simulation step.
 */

                NetSupport  m_support;
/**
 * The automaton's id.
 */

                int         m_id  ;
/**
 * The out buffer.
 */

  private       int[]       m_out_buf ;
/**
 * The incomming message.
 */

  private       int[]       m_in_buf ;
/**
 * The position inside the incomming message.
 */

  private       int         m_in_pos ;
/**
 * The count of messages sent.
 */

                int         m_sent      ;
/**
 * The count of messages received and processed.
 */

                int         m_processed ;
/**
 * The count of messages lost because the input buffer was still full.
 */

                int         m_lost  ;

/**
 * Create a new networked org.dgpf.automaton.
 * @param p_code        The compiled code to be run on this networked
 *                      automaton.
 */

  public  NetAutomaton(final Program    p_code)
    {
    super(p_code);
    }

/**
 * Obtain the unique identificator of this networking org.dgpf.automaton.
 * @return The unique identificator of this networking org.dgpf.automaton.
 */

  public  final int get_id  ()
    {
    return this.m_id;
    }

/**
 * WriteDirect an integer into the cells output buffer so it can be send.
 * @param p_value The int to be buffered.
 */

  public  final void  send_word (final int p_value)
    {
    int[] l_b;
    int   l_i;

    l_b = this.m_out_buf;
    if(l_b == null)
      {
      l_b            = new int[this.m_support.m_max_msg_len+1];
      l_b[0]         = 1;
      l_i            = 1;
      this.m_out_buf = l_b;
      }
    else
      {
      l_i            = l_b[0];
      }

    if(l_i < l_b.length)
      {
      l_b[l_i] = p_value;
      l_b[0]   = (l_i+1);
      }
    }

/**
 * Obtain the net support of this automaton.
 * @return The net support of this automaton.
 */

  public  final NetSupport  get_support()
    {
    return this.m_support;
    }
  
/**
 * Send the internal output buffer.
 * @param p_block <code>true</code> if this instruction should put the
 *                automaton into blocking mode until the "carrier" is free,
 *                <code>false</code> if the message should be send
 *                regardless.
 */

  public  final void  send_message  (final boolean p_block)
    {
    int[] l_b;

    l_b = this.m_out_buf;
    if(l_b != null)
      {
      this.m_out_buf = null;
      if(p_block)
        {
        if(!(this.m_support.can_send_message(this)))
          {
          this.block();
          return;
          }
        }
      this.m_support.send_message(l_b, this);
      this.m_sent++;
      }
    }

/**
 * Receive a new message into the incomming buffer.
 * @param p_message The message to be buffered.
 */

  final void  receive_message (final int[]  p_message)
    {
    if(this.m_in_buf == null)
      {
      this.m_in_buf = p_message;
      this.m_in_pos = 1;
      }
    else this.m_lost++;
    }

/**
 * ReadDirect an integer from the current message.
 * @param p_block <code>true</code> if the function should put the
 *                automaton into blocking mode if no word is available,
 *                <code>false</code> otherwise.
 * @return The integer read from the current message or <code>FALSE</code>
 *         if no message is currently buffered.
 */

  public final int receive_word  (final boolean p_block)
    {
    int[] l_c;
    int   l_ic, l_ret;

    l_c = this.m_in_buf;

    if(l_c != null)
      {
      l_ic  = this.m_in_pos;
      if(l_ic == 1) this.m_processed++;
      l_ret = l_c[l_ic];
      l_ic++;

      if(l_ic >= l_c[0])
        {
        this.m_in_buf = null;
        synchronized(this.m_support)
          {
          this.m_support.m_processed++;
          }
        }
      else
        {
        this.m_in_pos = l_ic;
        }

      return l_ret;
      }

    if(p_block) this.block();
    return FALSE;
    }


/**
 * Returns <code>true</code> if there is a message currently buffered and
 * ready to be read, meaning you can apply <code>read_int</code>.
 * @return <code>true</code> if there is a message currently buffered and
 *         ready to be read, meaning you can apply <code>read_int</code>.
 */

  public final boolean has_word ()
    {
    return (this.m_in_buf != null);
    }

/**
 * Return wether there is a message prepared to be sent or not.
 * @return  <code>true</code> if and only if the ouput buffer is not empty.
 */

  public  final boolean has_message ()
    {
    return (this.m_out_buf != null);
    }

/**
 * Returns <code>true</code> if the automaton can send a message probably
 * without causing a transmission collission. This is a model method for
 * checking if the channel is occupied. If this method returns
 * <code>true</code>, the automaton can send a message which probably will
 * cause no collission. Probably because the situation might change in the
 * meantime between checking the channel and sending the message. Also, a
 * return value of <code>true</code> implies that there is a message in the
 * output buffer, ready for transmission.
 * @return <code>true</code> if the automaton can send a message probably
 *         without  causing a transmission collission.
 */

  public final boolean can_send ()
    {
    return ((this.m_out_buf != null) &&
             this.m_support.can_send_message(this));
    }

/**
 * Obtain the count of messages sent. This will be the count of messages
 * that were sent by this org.dgpf.automaton.
 * @return  The total count of messages sent.
 * @see #get_lost_msg_count()
 * @see #get_processed_msg_count()
 */

  public  final int get_sent_msg_count ()
    {
    return this.m_sent;
    }

/**
 * Obtain the count of messages that were received
 * <strong>and processed</strong> by this automaton, meaning messages that
 * were read at least partly from the input buffer.
 * Messages will only be removed from the input buffer when completely
 * read. As long as one message resides in the input buffer, no other
 * message can be received or processed. For that time, each newly arriving
 * message will get lost.
 * @return The count of messages that have been received and at least been
 *         partly processed.
 * @see #get_lost_msg_count()
 */

  public  final int get_processed_msg_count ()
    {
    return this.m_processed;
    }

/**
 * Obtain the count of messages lost due to input buffer occupation. An
 * incomming message will get lost if the input buffer is full. The input
 * buffer is able to hold one message and will keep this message until
 * it has been read completely.
 * @return  The count messages lost due to input buffer occupation.
 * @see #get_processed_msg_count()
 */

  public  final int get_lost_msg_count  ()
    {
    return this.m_lost;
    }
  }

File Information:

file name:NetAutomaton.java
package:org.dgpf.gp.netautomaton.base
qualified name:org.dgpf.gp.netautomaton.base.NetAutomaton.java
file type:Java Source File
download location:download http://dgpf.sourceforge.net/source/org/dgpf/gp/netautomaton/base/NetAutomaton.java
size:8.295 KB (8495 B)
uploaded: 2015-07-22 04:10:55 GMT+0000
last update: 2006-06-04 12:30:24 GMT+0000
last access: 2017-11-17 21:24:14 GMT+0000

statistics online since 2006-01-02.   RSS Feed
Contact us by sending an email to tweise@gmx.de to receive further information, to report errors, or to join our project.
All content on this site (http://dgpf.sourceforge.net/) is LGPL-licensed.
http://dgpf.sourceforge.net/scripts/source/source.php last modified at 2015-07-22 04:10:53 GMT+0000 served at 2017-11-17 21:24:14 GMT+0000.
Valid CSS Valid XHTML 1.1
Valid RSS SourceForge.net Logo