Logo
Distributed Genetic Programming Framework
print print

File org.dgpf.gp.vm.base.SingleVMContext.java

Here you can find all the information about the file org.dgpf.gp.vm.base.SingleVMContext.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-07-03 17:07:16
 * Original Filename: org.dgpf.gp.vm.base.SingleVMContext.java
 * Version          : 1.0.0
 * Last modification: 2006-07-03
 *                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.vm.base;

import org.sfc.events.IEventListener;

/**
 * This context hosts a single virtual machine.
 *
 * @author Thomas Weise
 */

public class SingleVMContext  extends VMContext
  {
/**
 * The serial version uid.
 */

  private static final long serialVersionUID = 1;
  
/**
 * The vm internally used for the simulations.
 */

  private VM  m_vm  ;
  
/**
 * Create a single vm context.
 * @param p_definition  The search definition to use as blueprint for the
 *                      internally stored data.
 * @param p_events      The event listener to be used to propagate
 *                      error events, if needed.
 */

  public    SingleVMContext (final VMDefinition   p_definition,
                             final IEventListener p_events) 
    {
    super(p_definition, p_events);
    this.m_vm = this.create_vm();
    }
  
/**
 * This method is called internally to create the virtual machine to be
 * used for the automaton simulation.
 * @return  A virtual machine to be used for internal simulations.
 */

  protected VM  create_vm()
    {
    return new VM(this);
    }
  
/**
 * Obtain the virtual machine simulated by this context.
 * @return The virtual machine simulated by this context.
 */

  public  final VM  get_vm()
    {
    return this.m_vm;
    }
  
/**
 * This method needs to be called whenever the internal caches (virtual
 * machines for example) need to be resetted.
 */

  @Override
  protected void  reset_caches()
    {
    this.m_vm.dispose();
    super.reset_caches();
    this.m_vm = this.create_vm();
    }
  
  

/**
 * This method is called right before a simulation starts. It allows you
 * to perform some simulation-specific initialization.
 * The simulation-setup of the fitness functions will also be invoked here.
 * @param p_index   The index number of the current simulation. The first
 *                  simulation will have index 0, the second will have
 *                  index 1 and so on.
 * @see #end_simulation(int)
 */

  @Override
  protected final void begin_simulation  (final int p_index)
    {
    this.m_vm.init(this.get_current());
    super.begin_simulation(p_index);
    }
  

/**
 * Perform some simulation steps. This method is used to simulate the
 * current individual.
 * @param p_steps       The count of stepps suggested to run now in a row.
 * @return  <code>true</code> if everything went ok, <code>false</code> if
 *          something failed.
 */

  @Override
  protected boolean  simulate  (long p_steps)
    {
    final VM l_a;
    
    l_a = this.m_vm;
    for(; p_steps > 0; p_steps--)
      {
      if(!(l_a.tick())) return false;
      }
    
    return true;
    }


  
/**
 * Perform a single clock tick.
 * @return  <code>true</code> if and only if the program wasn't terminated
 *          yet and an instruction was executed.
 */

  public  final boolean tick  ()
    {
    return this.m_vm.tick();
    }

/**
 * Obtained the total count of consumed ticks of the (or all if more than
 * one) simulated virtual machines.
 * @return The total count of consumed ticks of the (or all if more than
 *         one) simulated virtual machines.
 */

  public  final long    get_consumed_ticks  ()  
    {
    return this.m_vm.get_consumed_ticks();
    }
  

/**
 * Obtained the total count of consumed costs of the (or all if more than
 * one) simulated virtual machines.
 * @return The total count of consumed costs of the (or all if more than
 *         one) simulated virtual machines.
 */

  public  final double  get_consumed_costs  () 
    {
    return this.m_vm.get_consumed_costs();
    }

  

/**
 * Obtained the total size of consumed memory of the (or all if more than
 * one) simulated virtual machines.
 * @return The total size of consumed memory of the (or all if more than
 *         one) simulated virtual machines.
 */

  public  final int     get_peak_memory () 
    {
    return this.m_vm.get_peak_memory();
    }
  

/**
 * Obtained the total count of used frames of the (or all if more than
 * one) simulated virtual machines.
 * @return The count of used frames of the memory of the (or all if more
 *         than one) simulated virtual machines.
 */

  public  final int     get_peak_frames () 
    {
    return this.m_vm.get_peak_frames();
    }
  
/**
 * Obtain the count a procedure call failed due to insufficient free frames
 * which reflects a stack overflow in normal programming environments.
 * @return The count a procedure call failed due to insufficient free
 *         frames which reflects a stack overflow in normal programming
 *         environments.
 */

  public  final long    get_frame_errors  ()
    {
    return this.m_vm.get_frame_errors();
    }
  
/**
 * Obtain the count of invalid write operations, that is, write operations
 * that surpass the maximum memory address available.
 * @return The count of invalid write operations, that is, write operations
 * that surpass the maximum memory address available.
 */

  public  final long get_mem_errors       ()
    {
    return this.m_vm.get_mem_errors();
    }
  }

File Information:

file name:SingleVMContext.java
package:org.dgpf.gp.vm.base
qualified name:org.dgpf.gp.vm.base.SingleVMContext.java
file type:Java Source File
download location:download http://dgpf.sourceforge.net/source/org/dgpf/gp/vm/base/SingleVMContext.java
size:6.221 KB (6371 B)
uploaded: 2015-07-22 04:10:56 GMT+0000
last update: 2006-07-13 04:15:26 GMT+0000
last access: 2017-11-19 03:03:38 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-19 03:03:39 GMT+0000.
Valid CSS Valid XHTML 1.1
Valid RSS SourceForge.net Logo