Logo
Distributed Genetic Programming Framework
print print

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

Here you can find all the information about the file org.dgpf.gp.vm.base.VMDefinition.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-06-23 06:36:19
 * Original Filename: org.dgpf.gp.vm.VMSettings.java
 * Version          : 1.0.0
 * Last modification: 2006-06-23
 *                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.dgpf.search.api.FitnessFunction;
import org.dgpf.search.api.SearchContext;
import org.dgpf.search.api.SearchDefinition;
import org.sfc.events.IEventListener;

/**
 * This class holds the settings for virtual machines.
 *
 * @author Thomas Weise
 */

public class VMDefinition extends     SearchDefinition<Program>
  {
/**
 * The serial version uid.
 */

  private static  final long  serialVersionUID        = 1;  
/**
 * The maximum memory frame size.
 * @see #get_max_mem_size() 
 */

  private int             m_max_mem_size  ;
/**
 * The maximum count of execution frames that can be granted to an
 * automaton during the simulation process.
 * @see #get_max_frame_count()
 */

  private int             m_max_frame_count ;
  
/**
 * The instruction set to be used by the virtual machine programs.
 * @see #get_instruction_set()
 */

  private InstructionSet  m_instruction_set ;
/**
 * The minimum count of procedures. You may set this count to some value
 * greater than one if needing asynchronous io.
 * @see #get_min_proc_count()
 */

  private int             m_min_proc_count  ;
/**
 * Is relative addressing possible?
 * @see #can_relative()
 */

  private boolean               m_can_relative    ;


/**
 * Create a new search definition.
 * @param p_definition  The search definition to use as blueprint for the
 *                      internally stored data.
 */

  public  VMDefinition(final VMDefinition p_definition)
    {
    super(p_definition);
    }
 
/**
 * Create a new search definition.
 * @param p_functions   The fitness functions to be applied in this
 *                      evolution.
 */

  public VMDefinition(final FitnessFunction<Program,?>[]  p_functions)
    {
    super(p_functions);
    this.m_max_mem_size    = VMUtils.DEFAULT_MAX_MEM_SIZE;
    this.m_max_frame_count = VMUtils.DEFAULT_MAX_EXEC_COUNT;
    this.m_instruction_set = VMUtils.DEFAULT_INSTRUCTION_SET;
    this.m_min_proc_count  = VMUtils.DEFAULT_MIN_PROC_COUNT;
    }
  


/**
 * Obtain the minimum count of procedures. This count might be a value
 * greater than one if needing asynchronous io.
 * @return The minimum count of procedures. This count might be a value
 *         greater than one if needing asynchronous io.
 */

  public  final int get_min_proc_count  ()
    {
    return this.m_min_proc_count;
    }
  
/**
 * The minimum count of procedures. You may set this count to some value
 * greater than one if needing asynchronous io.
 * @param p_min_proc_count  The new minimum procedure count. You may set
 *                          this count to some value greater than one if
 *                          needing asynchronous io.
 */

  public  void  set_min_proc_count  (final int p_min_proc_count)
    {
    if(p_min_proc_count >= 1) this.m_min_proc_count = p_min_proc_count;
    }
  
  
/**
 * Obtain the maximum memory frame size.
 * @return The maximum memory frame size.
 */

  public  final int get_max_mem_size  ()
    {
    return this.m_max_mem_size;
    }
  
/**
 * Set the maximum memory frame size.
 * @param p_max_mem_size  The new maximum memory frame size.
 */

  public  final void  set_max_mem_size  (final int p_max_mem_size)
    {
    if(p_max_mem_size > 0) this.m_max_mem_size = p_max_mem_size;
    }
  

/**
 * Obtain the maximum count of execution frames that can be granted during
 * the simulation process.
 * @return The maximum count of execution frames that can be granted during
 *         the simulation process.
 */

  public  final int get_max_frame_count  ()
    {
    return this.m_max_frame_count;
    }
  
/**
 * Set the maximum count of execution frames that can be granted during the
 * simulation process.
 * @param p_max_exec_count  The maximum count of execution frames that can
 *                          be granted during the simulation process.
 */

  public  final void  set_max_exec_count (final int p_max_exec_count)
    {
    if(p_max_exec_count > 0) this.m_max_frame_count = p_max_exec_count;
    }
  
/**
 * Obtain the instruction set to be used form virtual machines.
 * @return The instruction set to be used form virtual machines.
 */

  public  final InstructionSet  get_instruction_set()
    {
    return this.m_instruction_set;
    }

/**
 * Set the instruction set to be used form virtual machines.
 * @param p_set The instruction set to be used form virtual machines.
 */

  public  void  set_instruction_set (final InstructionSet p_set)
    {
    if( (p_set != null) && (p_set.size() > 0) )
      {
      this.m_instruction_set = p_set;
      }
    }
  
/**
 * Using this method, a search definition works as factory for search
 * contexts. You must override it to provide a real search context.
 * 
 * @param p_events  The event propagator to be used to propagate error
 *                  events, if needed.
 * 
 * @return A new search context.
 */

  @Override
  public SearchContext<Program> create_context(final IEventListener p_events)
    {
    return new SingleVMContext(this, p_events);
    }
  
  
/**
 * Assign this virtual machine context to the specified object.
 * @param p_data  The object to assign to.
 */

  @Override
  public  void  assign  (final Object p_data)
    {
    VMDefinition l_def;
    VMContext    l_ctx;
    
    super.assign(p_data);
        
    if(p_data instanceof VMDefinition)
      {
      l_def = ((VMDefinition)p_data);      
      this.set_max_mem_size(l_def.m_max_mem_size);
      this.set_max_exec_count(l_def.m_max_frame_count);
      this.set_instruction_set(l_def.m_instruction_set);
      this.set_min_proc_count(l_def.m_min_proc_count);
      this.set_can_relative(l_def.m_can_relative);
      }
    else if(p_data instanceof VMContext)
      {
      l_ctx = ((VMContext)p_data);
      this.set_max_mem_size(l_ctx.get_max_mem_size());
      this.set_max_exec_count(l_ctx.get_max_frame_count());
      this.set_instruction_set(l_ctx.get_instruction_set());
      this.set_min_proc_count(l_ctx.get_min_proc_count());
      this.set_can_relative(l_ctx.can_relative());
      }
    }
  
/**
 * Check whether this context supports the relative addressing mode or not.
 * @return  <code>true</code> if and only relative addressing (and thus,
 *          turing completeness,) is supported, <code>false</code> if only
 *          absolute addresses are available.
 */

  public  final boolean can_relative  ()
    {
    return this.m_can_relative;
    }
  
/**
 * Determine whether this context supports the relative addressing mode or
 * not.
 * @param p_relative  <code>true</code> if and only relative addressing
 *                    (and thus, turing completeness,) is supported,
 *                    <code>false</code> if only absolute addresses are
 *                    available.
 */

  public  final void  set_can_relative  (final boolean p_relative)
    {
    this.m_can_relative = p_relative;
    }
  }

File Information:

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