[Avida-cvs] [avida-svn] r918 - development/documentation

[brysonda at myxo.css.msu.edu]

Author: brysonda
Date: 2006-08-31 23:32:53 -0400 (Thu, 31 Aug 2006)
New Revision: 918

Modified:
   development/documentation/code_life_cycle.html
Log:
Update avidian life cycle documentation. (font -> span transformation)

Modified: development/documentation/code_life_cycle.html
===================================================================
--- development/documentation/code_life_cycle.html	2006-09-01 03:31:23 UTC (rev 917)
+++ development/documentation/code_life_cycle.html	2006-09-01 03:32:53 UTC (rev 918)
@@ -29,7 +29,7 @@
 which will allocate space for an offspring to be placed into.  If you look at
 the file <kbd>source/cpu/cHardwareCPU.cc</kbd>, you will see that this
 instruction is associated with the method
-<font color="#880000">cHardwareCPU</font>::<font color="#008800">Inst_MaxAlloc</font>().
+<span style="color: #880000">cHardwareCPU</span>::<span style="color: #008800">Inst_MaxAlloc</span>().
 What this means is that the organism will automatically allocate as much
 space as it possibly can, without having to first calculate its needs.  When
 the organism is finished copying itself and divides off its child, any excess
@@ -53,7 +53,7 @@
 Most of the initial self-analysis done on Avida organisms is with the
 <code>search</code> instruction or one of its variants.  In the heads based
 instruction set, we call this <code>h-search</code> and associate it with the
-method <font color="#880000">cHardwareCPU</font>::<font color="#008800">Inst_HeadSearch</font>().
+method <span style="color: #880000">cHardwareCPU</span>::<span style="color: #008800">Inst_HeadSearch</span>().
 </p>
 <p>
 The search type instructions read in the template (series of nops) that
@@ -98,13 +98,13 @@
 that will read in an instruction from the location of the read-head, and write
 it out to the location of the write-head.  It will then advance both heads to
 the next positions in the genomes.  Take a look at the source code for the
-method <font color="#880000">cHardwareCPU</font>::<font color="#008800">Inst_HeadCopy</font>().
+method <span style="color: #880000">cHardwareCPU</span>::<span style="color: #008800">Inst_HeadCopy</span>().
 </p>
 <p>
 The first thing that happens in this method is the variables
-<font color="#000088">read_head</font>,
-<font color="#000088">write_head</font>, and
-<font color="#000088">cpu_stats</font> are setup as references to the
+<span style="color: #000088">read_head</span>,
+<span style="color: #000088">write_head</span>, and
+<span style="color: #000088">cpu_stats</span> are setup as references to the
 appropriate objects in the hardware and organism (that is, any modifications
 to these references change the actual objects, not just a local copy of them).
 This is so that we have easy to use variables locally for those objects that
@@ -115,12 +115,12 @@
 </p>
 <p>
 Next, the instruction at the read head is recorded in the variable
-<font color="#000088">read_inst</font>, and we test to see if this should
+<span style="color: #000088">read_inst</span>, and we test to see if this should
 be mutated to some other value.  If a mutation does occur, we change the
 read_inst variable to a random value, increment the mutation count, and mark
 flags at the instruction position of the write head to denote the mutation.
 After we determine what instruction was read (be it a correct reading or not),
-we call the <font color="#008800">ReadInst</font>() method, which is simply
+we call the <span style="color: #008800">ReadInst</span>() method, which is simply
 used to keep track of the most recent template copied.  This template is used
 to help detect the end of the organism, which we shall discuss in a moment.
 </p>
@@ -165,7 +165,7 @@
 When an organism finishes copying itself, it needs to divide off its
 child using a divide command.  In the heads based instruction set, this is
 the <code>h-divide</code> command which calls the
-<font color="#880000">cHardwareCPU</font>::<font color="#008800">Inst_HeadDivide</font>()
+<span style="color: #880000">cHardwareCPU</span>::<span style="color: #008800">Inst_HeadDivide</span>()
 method.
 </p>
 <p>
@@ -178,11 +178,11 @@
 divide instructions in all of the sets).
 </p>
 <p>
-The <font color="#880000">cHardwareCPU</font>::<font color="#008800">Divide_Main</font>()
+The <span style="color: #880000">cHardwareCPU</span>::<span style="color: #008800">Divide_Main</span>()
 method is therefore what we are most interested in.  It begins by calculating
 the size of that child that would result from the divide point and the
 extra_line count that were passed into it, and runs
-<font color="#008800">Divide_CheckViable</font>() to make sure that all of
+<span style="color: #008800">Divide_CheckViable</span>() to make sure that all of
 these values are legal (that is that both parent and child are reasonable
 sizes for organisms, and reasonable sizes in relationship to each other -- for
 definitions of reasonable as found in the configuration file).  If any of
@@ -190,21 +190,21 @@
 </p>
 <p>
 From this point on, we know the divide is legal, so we just need to process
-it.  We create a variable called <font color="#000088">child_genome</font>,
+it.  We create a variable called <span style="color: #000088">child_genome</span>,
 which we use to construct the child genome.  We use a reference to a cGenome
 object inside of the organism so that this child genome is attached to its
 parent organism and will be easily accessible from other places where it will
 be needed later.  We're not going to be doing all of the work on it right in
 this method.  We initialize the child genome to the section of the parents
 genome that was created for it.  We then run
-<font color="#008800">Resize</font>() on the parent genome to get
+<span style="color: #008800">Resize</span>() on the parent genome to get
 rid of all of this extra space (both child and extra lines).
 </p>
 <p>
-The <font color="#008800">Divide_DoMutations</font>() method will test and
+The <span style="color: #008800">Divide_DoMutations</span>() method will test and
 (if needed) process any divide mutations that may occur.  There are many of
 them, so this method is quite long.  It is followed by
-<font color="#008800">Divide_TestFitnessMeasures</font>(), which will run the 
+<span style="color: #008800">Divide_TestFitnessMeasures</span>(), which will run the 
 offspring through a test CPU for special options that may be set in the
 genesis file (such as mutation reversions).  Obviously this is very processor
 intensive since it would occur with every birth, so tests are only performed