Logo
Distributed Genetic Programming Framework
print print

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

Here you can find all the information about the file org.dgpf.gp.netautomaton.base.NetSupport.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-18 05:57:42
 * Original Filename: org.dgpf.netautomaton.base.NetSupport.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.Program;
import org.sfc.collections.Arrays;
import org.sfc.math.stochastic.Randomizer;


/**
 * This class holds the network simulation data.
 *
 * @author Thomas Weise
 */

public class NetSupport
  {
/**
 * The list of the network automatons running.
 */

   private  final NetAutomaton[]  m_automatons  ;
/**
 * The links the network automates participate in.
 */

   private  final Link[][]        m_links       ;
/**
 * The time index.
 */

   private        int             m_time        ;
/**
 * The maximum message length.
 */

           final  int             m_max_msg_len       ;
/**
 * The count of messages sent.
 */

  private         long            m_transmissions     ;
/**
 * The count of messages received (but without any assumptions on if these
 * have been processed.)
 */

  private         long            m_dispatches ;
/**
 * The count of messages lost.
 */

  private         long            m_collisions     ;
/**
 * The count of messages lost due to the message-get-lost probability.
 */

  private         long            m_lost      ;
/**
 * The count of messages processed.
 */

                  long            m_processed ;

/**
 * The probability that a transmission gets lost without no special cause
 * like collision.
 */

  private final   double          m_lose_prob;

/**
 * The internal randomizer.
 */

  private final   Randomizer      m_random  ;

/**
 * Create a new genetic org.dgpf.automaton.base randomizer.
 * @param p_definition  The network genetics definition applied to this
 *                      context.
 * @param p_random      The automaton random used.
 */

  public  NetSupport (final NetDefinition   p_definition,
                      final Randomizer      p_random)
    {
    super();

    final int l_c;

    l_c = p_definition.get_automaton_count();

    this.m_automatons  = new NetAutomaton[l_c];
    this.m_max_msg_len = p_definition.get_max_msg_len();
    this.m_links       = new Link[l_c][];
    this.m_lose_prob   = p_definition.get_lose_prob();
    this.m_random      = p_random;

    NetUtilities.create_links(this.m_links, p_random);
    }


/**
 * Create a new network automaton. This method is called iteratively by
 * <code>init</code> to create the automatons to be used for the simulation.
 * @param p_program   The program to be applied to the org.dgpf.automaton.
 * @param p_index     The index of the automaton to create.
 * @return  The new automaton.
 * @see #begin_simulation(Program)
 */

  protected NetAutomaton  create_automaton  (final  Program p_program,
                                             final  int     p_index)
    {
    return new NetAutomaton(p_program);
    }

/**
 * Prepare the simulation to run.
 * @param p_program     The program to be applied to the automatons.
 * @see #create_automaton(Program,int)
 */

  protected void  begin_simulation  (final  Program p_program)
    {
    final NetAutomaton[]  l_na;
          int             l_i;
          NetAutomaton    l_naa;

    l_na              = this.m_automatons;
    for(l_i = (l_na.length-1); l_i >= 0; l_i--)
      {
      l_naa           = this.create_automaton(p_program, l_i);
      l_naa.m_id      = l_i;
      l_naa.m_support = this;
      l_na[l_i]       = l_naa;
      }
    }

/**
 * Cleanup the simulation after it has finished.
 */

  final void  end_simulation ()
    {
    final Link[][]        l_lnk;
          int             l_i, l_j;
          Link[]          l_ln;

    this.m_collisions     = 0;
    this.m_dispatches     = 0;
    this.m_transmissions  = 0;
    this.m_time           = 0;
    this.m_lost           = 0;

    Arrays.fill(this.m_automatons, null);

    l_lnk             = this.m_links;
    for(l_i = (l_lnk.length-1); l_i >= 0; l_i--)
      {
      l_ln            = l_lnk[l_i];

      for(l_j = (l_ln.length-1); l_j >= 0; l_j--)
        {
        l_ln[l_j].clear();
        }
      }
    }

/**
 * Send a message into the air.
 * @param p_message The message to be sent.
 * @param p_source  The sending org.dgpf.automaton.
 */

  final void  send_message  (final int[]        p_message,
                             final NetAutomaton p_source)
    {
    final int             l_id           ;
    final int             l_time, l_arrival_time ;
    final Link[]          l_lnks;
          int             l_i, l_t;
          Link            l_l;
    final Randomizer      l_r;

    l_id           = p_source.m_id;
    l_time         = this.m_time;
    l_r            = this.m_random;
    l_arrival_time = (l_time + (int)(l_r.exponential(this.m_max_msg_len)));
    l_lnks         = this.m_links[l_id];
    l_i            = l_lnks.length;
    this.m_transmissions += l_i;

    for(--l_i; l_i >= 0; l_i--)
      {
      l_l = l_lnks[l_i];
      l_t = l_l.m_arrival;

      if(l_t <= l_time)
        {
        if(l_r.nextDouble() < this.m_lose_prob)
          {
          if(l_l.m_data != null)
            {
            this.m_automatons[(l_l.m_source
                ? l_l.m_end_1 : l_l.m_end_2)].receive_message(l_l.m_data);
            this.m_dispatches++;
            }
          l_l.m_arrival = l_arrival_time;
          l_l.m_data    = p_message;
          l_l.m_source  = (l_id != l_l.m_end_1);
          }
        else this.m_lost++;
        }
      else
        {
        l_l.m_arrival = Math.max(l_t, l_arrival_time);
        if(l_l.m_data != null) this.m_collisions += 2;
        else                   this.m_collisions++;
        l_l.m_data    = null;
        }
      }
    }

/**
 * Perform some ticks of the hosted networked automatons.
 * @param p_count The count of ticks to perform.
 */

  public  final void  ticks  (int p_count)
    {
          int             l_i, l_j, l_time, l_k;
    final NetAutomaton[]  l_ats ;
    final int             l_cnt ;
    final Link[][]        l_lnks;
          Link[]          l_lnk;
          Link            l_l;
    final Randomizer      l_r;

    l_ats  = this.m_automatons;
    l_cnt  = l_ats.length;
    l_lnks = this.m_links;
    l_time = this.m_time;
    l_r    = this.m_random;

    for(; p_count > 0; p_count--)
      {
      for(l_i = (l_cnt - 1); l_i >= 0; l_i--)
        {
        l_j   = l_r.nextInt(l_cnt);
        l_lnk = l_lnks[l_j];

        for(l_k = (l_lnk.length-1); l_k >= 0; l_k--)
          {
          l_l = l_lnk[l_k];
          if((l_l.m_arrival <= l_time) && (l_l.m_data != null))
            {
            l_ats[(l_l.m_source ? l_l.m_end_1
                      : l_l.m_end_2)].receive_message(l_l.m_data);
            this.m_dispatches++;
            l_l.m_data = null;
            }
          }

        l_ats[l_j].tick();
        }

      l_time++;
      this.m_time = l_time;
      }
    }


/**
 * Obtain the current time index.
 * @return  The current time index.
 */

  public  final int get_time  ()
    {
    return this.m_time;
    }


/**
 * 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.
 * @param p_automaton The automaton that wants to check the channel.
 * @return <code>true</code> if the automaton can send a message probably
 *         without  causing a transmission collission.
 */

  final boolean can_send_message  (final NetAutomaton p_automaton)
    {
          int             l_i;
    final Link[]          l_lnks;
    final int             l_time;

    l_lnks = this.m_links[p_automaton.m_id];
    l_time = this.m_time;

    for(l_i = (l_lnks.length-1); l_i >= 0; l_i--)
      {
      if(l_lnks[l_i].m_arrival > (l_time+1)) return false;
      }

    return true;
    }

/**
 * Obtain the count of transmissions on all links. This will be more than
 * the sum of all <code>NetAutomaton.get_sent_msg_count()</code> since
 * a message will always be sent on all links descending from an automaton,
 * where each link traversion is counted as a transmission. So if an
 * automaton is connected by three links with its neighbors and sends a
 * message, this will make up three transmissions.
 * @return  The total transmission count.
 * @see NetAutomaton#get_sent_msg_count()
 */

  public  final long get_transmission_count  ()
    {
    return this.m_transmissions;
    }

/**
 * Obtain the count of collissions. If a message is about to be transmitted
 * over a link while another message is still being transmitted on that
 * link, the two will collide, destroying both messages but keeping the
 * link occupied with trash for as long as the real transmission would have
 * taken.
 * @return  The count of collissions.
 * @see #get_transmission_count()
 * @see NetAutomaton#get_lost_msg_count()
 * @see NetAutomaton#get_processed_msg_count()
 */

  public  final long get_collission_count()
    {
    return this.m_collisions;
    }

/**
 * Obtain the count of transmissions lost due to some natural phenomenom
 * that is described by the message-get-lost-probability.
 * @return  The count of messages lost without special cause.
 * @see #m_lose_prob
 * @see #get_transmission_count()
 * @see NetAutomaton#get_lost_msg_count()
 * @see NetAutomaton#get_processed_msg_count()
 */

  public  final long get_lost_count()
    {
    return this.m_lost;
    }

/**
 * The count of transmissions that have been dispatched to the network
 * automatons. A transmission is regarded as dispatched when it passed a
 * link without collission. However, a dispatched message can still be lost
 * if the input buffer of the receiving automaton is full.
 * @return  The count of dispatched messages.
 * @see #get_transmission_count()
 * @see NetAutomaton#get_lost_msg_count()
 * @see NetAutomaton#get_processed_msg_count()
 */

  public  final long get_dispatch_count  ()
    {
    return this.m_dispatches;
    }
  
/**
 * The count of transmissions that have been dispatched to the network
 * automatons and have complete been processed. A transmission is regarded
 * as processed if it was stored in the input buffer of a net automaton
 * and has been read completely from it by the automaton.
 * @return  The count of dispatched messages.
 * @see #get_transmission_count()
 * @see NetAutomaton#get_lost_msg_count()
 * @see NetAutomaton#get_processed_msg_count()
 */

  public  final long get_processed_count  ()
    {
    return this.m_processed;
    }

/**
 * Obtain the count of automatons simulated inside this context.
 * @return  The count of automatons simulated inside this context.
 */

  public  final int get_automaton_count ()
    {
    return this.m_automatons.length;
    }

/**
 * Returns the net automaton with the specified index.
 * @param p_index The index of the net automaton you want to obtain.
 * @return  The net automaton located by the specified index.
 */

  public  final NetAutomaton  get_automaton (final int p_index)
    {
    return this.m_automatons[p_index];
    }

/**
 * Obtain the randomizer used by this net support.
 * @return  The randomizer used by this net support.
 */

  protected final Randomizer  get_random  ()
    {
    return this.m_random;
    }

/**
 * Obtain the maximum length of a message that can be exchanged by network
 * automatons.
 * @return The maximum length of a message that can be exchanged by network
 *         automatons.
 */

  public  final int get_max_msg_len ()
    {
    return this.m_max_msg_len;
    }

/**
 * A link represents something like a bus where multiple networked
 * automatons are attached to. On a link there can only be one message
 * transmitted at a time. That means if a second message is pushed on
 * that link, both messages will get lost.
 *
 * @author Thomas Weise
 */

  static  final class Link
    {
/**
 * The first end of the link.
 */

          int           m_end_1 ;
/**
 * The second end of the link.
 */

          int           m_end_2 ;

/**
 * The source automate.
 */

          boolean       m_source  ;
/**
 * The data sent.
 */

          int[]         m_data  ;
/**
 * The arrival time.
 */

          int           m_arrival;

/**
 * Create a new link.
 * @param p_end_1 The first end of the link.
 * @param p_end_2 The second end of the link.
 */

    Link  (final int  p_end_1,
           final int  p_end_2)
      {
      super();
      this.m_end_1 = p_end_1;
      this.m_end_2 = p_end_2;
      this.clear();
      }

/**
 * Clear this link.
 */

    final void  clear ()
      {
      this.m_data    = null;
      this.m_arrival = -1;
      }

/**
 * A string representation of this link.
 * @return The string representation of this link.
 */

    @Override
    public  final String  toString()
      {
      return (this.m_end_1 + "<->" + this.m_end_2);
      }
    }
  }

File Information:

file name:NetSupport.java
package:org.dgpf.gp.netautomaton.base
qualified name:org.dgpf.gp.netautomaton.base.NetSupport.java
file type:Java Source File
download location:download http://dgpf.sourceforge.net/source/org/dgpf/gp/netautomaton/base/NetSupport.java
size:14.139 KB (14479 B)
uploaded: 2015-07-22 04:10:55 GMT+0000
last update: 2006-06-04 12:30:24 GMT+0000
last access: 2017-11-23 07:09:56 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-23 07:09:56 GMT+0000.
Valid CSS Valid XHTML 1.1
Valid RSS SourceForge.net Logo