[Avida-SVN] r1452 - branches/collect/source/main
blwalker at myxo.css.msu.edu
blwalker at myxo.css.msu.edu
Mon Apr 2 20:20:36 PDT 2007
Author: blwalker
Date: 2007-04-02 23:20:35 -0400 (Mon, 02 Apr 2007)
New Revision: 1452
Modified:
branches/collect/source/main/cPhenotype.cc
branches/collect/source/main/cPhenotype.h
branches/collect/source/main/cReactionResult.cc
branches/collect/source/main/cReactionResult.h
branches/collect/source/main/cStats.cc
branches/collect/source/main/cStats.h
Log:
Added various stats / tracking variables for resource bins and tasks using internal resources.
Not quite a complete implementation, TODO:
- add new variables in cPhenotype to SaveState() and LoadState()
- update cur_rbin_total and cur_rbin_avail in cHardwareCPU::Inst_Collect()
Modified: branches/collect/source/main/cPhenotype.cc
===================================================================
--- branches/collect/source/main/cPhenotype.cc 2007-04-02 19:23:51 UTC (rev 1451)
+++ branches/collect/source/main/cPhenotype.cc 2007-04-03 03:20:35 UTC (rev 1452)
@@ -42,8 +42,12 @@
: m_world(world)
, initialized(false)
, cur_task_count(m_world->GetEnvironment().GetNumTasks())
+ , cur_internal_task_count(m_world->GetEnvironment().GetNumTasks())
, eff_task_count(m_world->GetEnvironment().GetNumTasks())
, cur_task_quality(m_world->GetEnvironment().GetNumTasks())
+ , cur_internal_task_quality(m_world->GetEnvironment().GetNumTasks())
+ , cur_rbin_total(m_world->GetNumResources())
+ , cur_rbin_avail(m_world->GetNumResources())
, cur_reaction_count(m_world->GetEnvironment().GetReactionLib().GetSize())
, cur_reaction_add_reward(m_world->GetEnvironment().GetReactionLib().GetSize())
, cur_inst_count(world->GetHardwareManager().GetInstSet().GetSize())
@@ -129,8 +133,12 @@
cur_num_errors = 0;
cur_num_donates = 0;
cur_task_count.SetAll(0);
+ cur_internal_task_count.SetAll(0);
eff_task_count.SetAll(0);
cur_task_quality.SetAll(0);
+ cur_internal_task_quality.SetAll(0);
+ cur_rbin_total.SetAll(0);
+ cur_rbin_avail.SetAll(0);
cur_reaction_count.SetAll(0);
cur_reaction_add_reward.SetAll(0);
cur_inst_count.SetAll(0);
@@ -145,7 +153,11 @@
last_num_errors = parent_phenotype.last_num_errors;
last_num_donates = parent_phenotype.last_num_donates;
last_task_count = parent_phenotype.last_task_count;
+ last_internal_task_count = parent_phenotype.last_internal_task_count;
last_task_quality = parent_phenotype.last_task_quality;
+ last_internal_task_quality= parent_phenotype.last_internal_task_quality;
+ last_rbin_total = parent_phenotype.last_rbin_total;
+ last_rbin_avail = parent_phenotype.last_rbin_avail;
last_reaction_count = parent_phenotype.last_reaction_count;
last_reaction_add_reward = parent_phenotype.last_reaction_add_reward;
last_inst_count = parent_phenotype.last_inst_count;
@@ -219,8 +231,12 @@
cur_num_errors = 0;
cur_num_donates = 0;
cur_task_count.SetAll(0);
+ cur_internal_task_count.SetAll(0);
eff_task_count.SetAll(0);
cur_task_quality.SetAll(0);
+ cur_internal_task_quality.SetAll(0);
+ cur_rbin_total.SetAll(0);
+ cur_rbin_avail.SetAll(0);
cur_reaction_count.SetAll(0);
cur_reaction_add_reward.SetAll(0);
cur_inst_count.SetAll(0);
@@ -234,7 +250,11 @@
last_num_errors = 0;
last_num_donates = 0;
last_task_count.SetAll(0);
+ last_internal_task_count.SetAll(0);
last_task_quality.SetAll(0);
+ last_internal_task_quality.SetAll(0);
+ last_rbin_total.SetAll(0);
+ last_rbin_avail.SetAll(0);
last_reaction_count.SetAll(0);
last_reaction_add_reward.SetAll(0);
last_sense_count.SetAll(0);
@@ -314,7 +334,11 @@
last_num_errors = cur_num_errors;
last_num_donates = cur_num_donates;
last_task_count = cur_task_count;
+ last_internal_task_count = cur_internal_task_count;
last_task_quality = cur_task_quality;
+ last_internal_task_quality= cur_internal_task_quality;
+ last_rbin_total = cur_rbin_total;
+ last_rbin_avail = cur_rbin_avail;
last_reaction_count = cur_reaction_count;
last_reaction_add_reward = cur_reaction_add_reward;
last_inst_count = cur_inst_count;
@@ -325,8 +349,12 @@
cur_num_errors = 0;
cur_num_donates = 0;
cur_task_count.SetAll(0);
+ cur_internal_task_count.SetAll(0);
eff_task_count.SetAll(0);
cur_task_quality.SetAll(0);
+ cur_internal_task_quality.SetAll(0);
+ cur_rbin_total.SetAll(0);
+ cur_rbin_avail.SetAll(0);
cur_reaction_count.SetAll(0);
cur_reaction_add_reward.SetAll(0);
cur_inst_count.SetAll(0);
@@ -414,7 +442,11 @@
last_num_errors = cur_num_errors;
last_num_donates = cur_num_donates;
last_task_count = cur_task_count;
+ last_internal_task_count = cur_internal_task_count;
last_task_quality = cur_task_quality;
+ last_internal_task_quality= cur_internal_task_quality;
+ last_rbin_total = cur_rbin_total;
+ last_rbin_avail = cur_rbin_avail;
last_reaction_count = cur_reaction_count;
last_reaction_add_reward = cur_reaction_add_reward;
last_inst_count = cur_inst_count;
@@ -425,8 +457,12 @@
cur_num_errors = 0;
cur_num_donates = 0;
cur_task_count.SetAll(0);
+ cur_internal_task_count.SetAll(0);
eff_task_count.SetAll(0);
cur_task_quality.SetAll(0);
+ cur_internal_task_quality.SetAll(0);
+ cur_rbin_total.SetAll(0);
+ cur_rbin_avail.SetAll(0);
cur_reaction_count.SetAll(0);
cur_reaction_add_reward.SetAll(0);
cur_inst_count.SetAll(0);
@@ -506,6 +542,7 @@
cur_num_errors = 0;
cur_num_donates = 0;
cur_task_count.SetAll(0);
+ cur_internal_task_count.SetAll(0);
eff_task_count.SetAll(0);
cur_reaction_count.SetAll(0);
cur_reaction_add_reward.SetAll(0);
@@ -521,6 +558,7 @@
last_num_errors = clone_phenotype.last_num_errors;
last_num_donates = clone_phenotype.last_num_donates;
last_task_count = clone_phenotype.last_task_count;
+ last_internal_task_count = clone_phenotype.last_internal_task_count;
last_reaction_count = clone_phenotype.last_reaction_count;
last_reaction_add_reward = clone_phenotype.last_reaction_add_reward;
last_inst_count = clone_phenotype.last_inst_count;
@@ -607,8 +645,13 @@
{
cur_task_count[i]++;
eff_task_count[i]++;
+ if(result.UsedEnvResource() == false) { cur_internal_task_count[i]++; }
}
- if (result.TaskQuality(i) > 0) cur_task_quality[i]+= result.TaskQuality(i);
+ if (result.TaskQuality(i) > 0)
+ {
+ cur_task_quality[i]+= result.TaskQuality(i);
+ if(result.UsedEnvResource() == false) { cur_internal_task_quality[i] += result.TaskQuality(i); }
+ }
}
for (int i = 0; i < num_reactions; i++) {
if (result.ReactionTriggered(i) == true) cur_reaction_count[i]++;
@@ -623,6 +666,18 @@
for (int i = 0; i < res_in.GetSize(); i++) {
res_change[i] = result.GetProduced(i) - result.GetConsumed(i);
}
+
+ // Update rbin stats as necessary
+ if(result.UsedEnvResource() == false)
+ {
+ double rbin_diff;
+ for(int i = 0; i < num_resources; i++)
+ {
+ rbin_diff = cur_rbin_avail[i] - rbins_in[i];
+ cur_rbin_avail[i] = rbins_in[i];
+ if(rbin_diff > 0) { cur_rbin_total[i] += rbin_diff; }
+ }
+ }
// Save the instructions that should be triggered...
insts_triggered = result.GetInstArray();
Modified: branches/collect/source/main/cPhenotype.h
===================================================================
--- branches/collect/source/main/cPhenotype.h 2007-04-02 19:23:51 UTC (rev 1451)
+++ branches/collect/source/main/cPhenotype.h 2007-04-03 03:20:35 UTC (rev 1452)
@@ -104,8 +104,12 @@
int cur_num_errors; // Total instructions executed illeagally.
int cur_num_donates; // Number of donations so far
tArray<int> cur_task_count; // Total times each task was performed
+ tArray<int> cur_internal_task_count; // Total times each task was performed using internal resources
tArray<int> eff_task_count; // Total times each task was performed (resetable during the life of the organism)
tArray<double> cur_task_quality; // Average (total?) quality with which each task was performed
+ tArray<double> cur_internal_task_quality; // Average (total?) quaility with which each task using internal resources was performed
+ tArray<double> cur_rbin_total; // Total amount of resources collected
+ tArray<double> cur_rbin_avail; // Total amount of internal resources available
tArray<int> cur_reaction_count; // Total times each reaction was triggered.
tArray<double> cur_reaction_add_reward; // Bonus change from triggering each reaction.
tArray<int> cur_inst_count; // Instruction exection counter
@@ -126,14 +130,18 @@
int last_num_errors;
int last_num_donates;
tArray<int> last_task_count;
+ tArray<int> last_internal_task_count;
tArray<double> last_task_quality;
+ tArray<double> last_internal_task_quality;
+ tArray<double> last_rbin_total;
+ tArray<double> last_rbin_avail;
tArray<int> last_reaction_count;
tArray<double> last_reaction_add_reward;
tArray<int> last_inst_count; // Instruction exection counter
tArray<int> last_sense_count; // Total times resource combinations have been sensed; @JEB
double last_fitness; // Used to determine sterilization.
- // 4. Records from this organisms life...
+ // 4. Records from this organism's life...
int num_divides; // Total successful divides organism has produced.
int generation; // Number of birth events to original ancestor.
int cpu_cycles_used; // Total CPU cycles consumed. @JEB
@@ -233,8 +241,12 @@
int GetCurNumErrors() const { assert(initialized == true); return cur_num_errors; }
int GetCurNumDonates() const { assert(initialized == true); return cur_num_donates; }
const tArray<int>& GetCurTaskCount() const { assert(initialized == true); return cur_task_count; }
+ const tArray<int>& GetCurInternalTaskCount() const { assert(initialized == true); return cur_internal_task_count; }
void ClearEffTaskCount() { assert(initialized == true); eff_task_count.SetAll(0); }
const tArray<double> & GetCurTaskQuality() const { assert(initialized == true); return cur_task_quality; }
+ const tArray<double> & GetCurInternalTaskQuality() const { assert(initialized == true); return cur_internal_task_quality; }
+ const tArray<double>& GetCurRBinTotal() const { assert(initialized == true); return cur_rbin_total; }
+ const tArray<double>& GetCurRBinAvail() const { assert(initialized == true); return cur_rbin_avail; }
const tArray<int>& GetCurReactionCount() const { assert(initialized == true); return cur_reaction_count;}
const tArray<int>& GetCurInstCount() const { assert(initialized == true); return cur_inst_count; }
const tArray<int>& GetCurSenseCount() const { assert(initialized == true); return cur_sense_count; }
@@ -248,7 +260,11 @@
int GetLastNumErrors() const { assert(initialized == true); return last_num_errors; }
int GetLastNumDonates() const { assert(initialized == true); return last_num_donates; }
const tArray<int>& GetLastTaskCount() const { assert(initialized == true); return last_task_count; }
+ const tArray<int>& GetLastInternalTaskCount() const { assert(initialized == true); return last_internal_task_count; }
const tArray<double>& GetLastTaskQuality() const { assert(initialized == true); return last_task_quality; }
+ const tArray<double>& GetLastInternalTaskQuality() const { assert(initialized == true); return last_internal_task_quality; }
+ const tArray<double>& GetLastRBinTotal() const { assert(initialized == true); return last_rbin_total; }
+ const tArray<double>& GetLastRBinAvail() const { assert(initialized == true); return last_rbin_avail; }
const tArray<int>& GetLastReactionCount() const { assert(initialized == true); return last_reaction_count; }
const tArray<double>& GetLastReactionAddReward() const { assert(initialized == true); return last_reaction_add_reward; }
const tArray<int>& GetLastInstCount() const { assert(initialized == true); return last_inst_count; }
Modified: branches/collect/source/main/cReactionResult.cc
===================================================================
--- branches/collect/source/main/cReactionResult.cc 2007-04-02 19:23:51 UTC (rev 1451)
+++ branches/collect/source/main/cReactionResult.cc 2007-04-03 03:20:35 UTC (rev 1452)
@@ -41,6 +41,7 @@
, insts_triggered(0)
, lethal(false)
, active_reaction(false)
+ , used_env_resource(true)
{
}
@@ -66,7 +67,8 @@
void cReactionResult::Consume(int id, double num, bool is_env_resource)
{
ActivateReaction();
- if(is_env_resource) {resources_consumed[id] += num;}
+ if(is_env_resource) { resources_consumed[id] += num; }
+ else { used_env_resource = false; }
}
Modified: branches/collect/source/main/cReactionResult.h
===================================================================
--- branches/collect/source/main/cReactionResult.h 2007-04-02 19:23:51 UTC (rev 1451)
+++ branches/collect/source/main/cReactionResult.h 2007-04-03 03:20:35 UTC (rev 1452)
@@ -44,6 +44,7 @@
tArray<int> insts_triggered;
bool lethal;
bool active_reaction;
+ bool used_env_resource;
inline void ActivateReaction();
@@ -80,6 +81,8 @@
double GetReactionAddBonus(const int i) { return reaction_add_bonus[i]; }
double GetMultBonus() { return bonus_mult; }
tArray<int>& GetInstArray() { return insts_triggered; }
+ bool UsedEnvResource() { return used_env_resource; }
+ bool IsEnvResource() { return used_env_resource; }
};
Modified: branches/collect/source/main/cStats.cc
===================================================================
--- branches/collect/source/main/cStats.cc 2007-04-02 19:23:51 UTC (rev 1451)
+++ branches/collect/source/main/cStats.cc 2007-04-03 03:20:35 UTC (rev 1452)
@@ -151,6 +151,18 @@
reaction_names.Resize( m_world->GetNumReactions() );
resource_names.Resize( m_world->GetNumResources() );
+
+ // Stats for internal resource bins and use of internal resources
+ task_internal_cur_count.Resize(num_tasks, 0);
+ task_internal_last_count.Resize(num_tasks, 0);
+ task_internal_cur_quality.Resize(num_tasks, 0);
+ task_internal_last_quality.Resize(num_tasks, 0);
+ task_internal_cur_max_quality.Resize(num_tasks, 0);
+ task_internal_last_max_quality.Resize(num_tasks, 0);
+ rbin_avail_cur_count.Resize(m_world->GetNumResources(), 0);
+ rbin_avail_last_count.Resize(m_world->GetNumResources(), 0);
+ rbin_total_cur_count.Resize(m_world->GetNumResources(), 0);
+ rbin_total_last_count.Resize(m_world->GetNumResources(), 0);
// This block calculates how many slots we need to
// make for paying attention to different label combinations
@@ -291,6 +303,12 @@
task_last_quality[i] = 0;
task_last_max_quality[i] = 0;
task_cur_max_quality[i] = 0;
+ task_internal_cur_count[i] = 0;
+ task_internal_cur_quality[i] = 0;
+ task_internal_cur_max_quality[i] = 0;
+ task_internal_last_count[i] = 0;
+ task_internal_last_quality[i] = 0;
+ task_internal_last_max_quality[i] = 0;
}
}
@@ -437,6 +455,18 @@
task_cur_max_quality.SetAll(0);
task_last_max_quality.SetAll(0);
task_exe_count.SetAll(0);
+
+ task_internal_cur_count.SetAll(0);
+ task_internal_last_count.SetAll(0);
+ task_internal_cur_quality.SetAll(0);
+ task_internal_last_quality.SetAll(0);
+ task_internal_cur_max_quality.SetAll(0);
+ task_internal_last_max_quality.SetAll(0);
+
+ rbin_avail_cur_count.SetAll(0);
+ rbin_avail_last_count.SetAll(0);
+ rbin_total_cur_count.SetAll(0);
+ rbin_total_last_count.SetAll(0);
sense_last_count.SetAll(0);
sense_last_exe_count.SetAll(0);
@@ -970,3 +1000,49 @@
}
df.Endl();
}
+
+void cStats::PrintInternalTasksData(const cString& filename)
+{
+ cString file = filename;
+
+ // flag to print both in_tasks.dat and in_taskquality.dat
+ if (filename == "in_tasksq.dat")
+ {
+ file = "in_tasks.dat";
+ PrintInternalTasksQualData("in_taskquality.dat");
+ }
+
+ // print in_tasks.dat
+ cDataFile& df = m_world->GetDataFile(file);
+ df.WriteComment("Avida tasks data: tasks performed with internal resources");
+ df.WriteTimeStamp();
+ df.WriteComment("First column gives the current update, next columns give the number");
+ df.WriteComment("of organisms that have the particular task, performed with internal resources, ");
+ df.WriteComment("as a component of their merit");
+
+ df.Write(m_update, "Update");
+ for(int i = 0; i < task_internal_last_count.GetSize(); i++) {
+ df.Write(task_internal_last_count[i], task_names[i] );
+ }
+ df.Endl();
+}
+
+void cStats::PrintInternalTasksQualData(const cString& filename)
+{
+ cDataFile& df = m_world->GetDataFile(filename);
+
+ df.WriteComment("Avida tasks quality data: tasks performed using internal resources");
+ df.WriteTimeStamp();
+ df.WriteComment("First column gives the current update, rest give average and max task quality ");
+ df.WriteComment("for those tasks performed using internal resources");
+ df.Write(m_update, "Update");
+ for(int i = 0; i < task_internal_last_count.GetSize(); i++) {
+ double qual = 0.0;
+ if (task_internal_last_count[i] > 0)
+ qual = task_internal_last_quality[i] / static_cast<double>(task_internal_last_count[i]);
+ df.Write(qual, task_names[i] + " Average");
+ df.Write(task_internal_last_max_quality[i], task_names[i] + " Max");
+ }
+ df.Endl();
+}
+
Modified: branches/collect/source/main/cStats.h
===================================================================
--- branches/collect/source/main/cStats.h 2007-04-02 19:23:51 UTC (rev 1451)
+++ branches/collect/source/main/cStats.h 2007-04-03 03:20:35 UTC (rev 1452)
@@ -216,6 +216,18 @@
tArray<double> task_cur_max_quality;
tArray<double> task_last_max_quality;
tArray<int> task_exe_count;
+
+ // Stats for internal resource bins and use of internal resources
+ tArray<int> task_internal_cur_count;
+ tArray<int> task_internal_last_count;
+ tArray<double> task_internal_cur_quality;
+ tArray<double> task_internal_last_quality;
+ tArray<double> task_internal_cur_max_quality;
+ tArray<double> task_internal_last_max_quality;
+ tArray<double> rbin_avail_cur_count;
+ tArray<double> rbin_avail_last_count;
+ tArray<double> rbin_total_cur_count;
+ tArray<double> rbin_total_last_count;
tArray<double> reaction_count;
tArray<double> reaction_add_reward;
@@ -456,6 +468,26 @@
void IncLastSenseExeCount(int res_comb_index, int count)
{ sense_last_exe_count[res_comb_index]+= count; }
+ // internal resource bins and use of internal resources
+ void AddInternalCurTask(int task_num) { task_internal_cur_count[task_num]++; }
+ void AddInternalCurTaskQuality(int task_num, double quality)
+ {
+ task_internal_cur_quality[task_num] += quality;
+ if(quality > task_internal_cur_max_quality[task_num])
+ task_internal_cur_max_quality[task_num] = quality;
+ }
+ void AddInternalLastTask(int task_num) { task_internal_last_count[task_num]++; }
+ void AddInternalLastTaskQuality(int task_num, double quality)
+ {
+ task_internal_last_quality[task_num] += quality;
+ if(quality > task_internal_last_max_quality[task_num])
+ task_internal_last_max_quality[task_num] = quality;
+ }
+ void SetCurAvailRBins(const tArray<double> &_in) { rbin_avail_cur_count = _in; }
+ void SetLastAvailRBins(const tArray<double> &_in) { rbin_avail_last_count = _in; }
+ void SetCurTotalRBins(const tArray<double> &_in) { rbin_total_cur_count = _in; }
+ void SetLastTotalRBins(const tArray<double> &_in) { rbin_total_last_count = _in; }
+
void SetReactions(const tArray<double> &_in) { reaction_count = _in; }
void AddLastReactionAddReward(int _id, double _reward) { reaction_add_reward[_id] += _reward; }
void ZeroRewards();
@@ -512,6 +544,18 @@
double GetTaskMaxCurQuality(int task_num) const { return task_cur_max_quality[task_num];}
double GetTaskMaxLastQuality(int task_num) const { return task_last_max_quality[task_num];}
int GetTaskExeCount(int task_num) const { return task_exe_count[task_num]; }
+
+ // internal resource bins and use of internal resources
+ int GetTaskInternalCurCount(int task_num) const { return task_internal_cur_count[task_num]; }
+ double GetTaskInternalCurQuality(int task_num) const { return task_internal_cur_quality[task_num]/(double)task_internal_cur_count[task_num]; }
+ double GetTaskMaxInternalCurQuality(int task_num) const { return task_internal_cur_max_quality[task_num]; }
+ int GetTaskInternalLastCount(int task_num) const { return task_internal_last_count[task_num]; }
+ double GetTaskInternalLastQuality(int task_num) const { return task_internal_last_quality[task_num]/(double)task_internal_last_count[task_num]; }
+ double GetTaskMaxInternalLastQuality(int task_num) const { return task_internal_last_max_quality[task_num]; }
+ const tArray<double> & GetCurAvailRBins() const { return rbin_avail_cur_count; }
+ const tArray<double> & GetLastAvailRBins() const { return rbin_avail_last_count; }
+ const tArray<double> & GetCurTotalRBins() const { return rbin_total_cur_count; }
+ const tArray<double> & GetLastTotalRBins() const { return rbin_total_last_count; }
const tArray<double> & GetReactions() const { return reaction_count; }
const tArray<double> & GetResources() const { return resource_count; }
@@ -602,6 +646,8 @@
void PrintMarketData(const cString& filename);
void PrintSenseData(const cString& filename);
void PrintSenseExeData(const cString& filename);
+ void PrintInternalTasksData(const cString& filename);
+ void PrintInternalTasksQualData(const cString& filename);
};
More information about the Avida-cvs
mailing list