1380 lines
47 KiB
C
1380 lines
47 KiB
C
/* lil-gp Genetic Programming System, version 1.0, 11 July 1995
|
|
* Copyright (C) 1995 Michigan State University
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of version 2 of the GNU General Public License as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*
|
|
* Douglas Zongker (zongker@isl.cps.msu.edu)
|
|
* Dr. Bill Punch (punch@isl.cps.msu.edu)
|
|
*
|
|
* Computer Science Department
|
|
* A-714 Wells Hall
|
|
* Michigan State University
|
|
* East Lansing, Michigan 48824
|
|
* USA
|
|
*
|
|
*/
|
|
|
|
#include <lilgp.h>
|
|
|
|
popstats* run_stats;
|
|
saved_ind* saved_head, * saved_tail;
|
|
|
|
#if !defined(POSIX_MT) && !defined(SOLARIS_MT)
|
|
|
|
globaldata global_g;
|
|
|
|
#else
|
|
|
|
int numthreads = 0;
|
|
|
|
struct thread_param_t
|
|
{
|
|
population* pop;
|
|
int startidx;
|
|
int endidx;
|
|
globaldata g;
|
|
};
|
|
|
|
#ifdef POSIX_MT
|
|
|
|
#include <pthread.h>
|
|
|
|
static pthread_key_t g_key;
|
|
static pthread_attr_t pthread_attr;
|
|
#endif
|
|
|
|
#ifdef SOLARIS_MT
|
|
#include <thread.h>
|
|
static thread_key_t g_key;
|
|
#endif
|
|
|
|
#endif /* !defined(POSIX_MT) && !defined(SOLARIS_MT) */
|
|
|
|
/* run_gp()
|
|
*
|
|
* the whole enchilada. runs, from generation startgen, using population
|
|
* mpop. accumulates time spent evaluating and breeding in t_eval and t_breed.
|
|
*/
|
|
|
|
void run_gp(multipop* mpop, int startgen,
|
|
event* t_eval, event* t_breed, int startfromcheckpoint)
|
|
{
|
|
|
|
char* param;
|
|
int gen;
|
|
int maxgen;
|
|
int exch_gen;
|
|
int i, j;
|
|
int checkinterval;
|
|
char* checkfileformat;
|
|
char* checkfilename = NULL;
|
|
event start, end, diff;
|
|
int term = 0;
|
|
int stt_interval;
|
|
int bestn;
|
|
|
|
if (!startfromcheckpoint)
|
|
{
|
|
|
|
/* get the number of top individuals to track. */
|
|
bestn = atoi(get_parameter("output.bestn"));
|
|
if (bestn < 1)
|
|
{
|
|
error(E_WARNING, "\"output.bestn\" must be at least 1. defaulting to 1.");
|
|
bestn = 1;
|
|
}
|
|
|
|
/* allocate statistics for overall run. */
|
|
run_stats = (popstats*) MALLOC((mpop->size + 1) * sizeof(popstats));
|
|
for (i = 0; i < mpop->size + 1; ++i)
|
|
{
|
|
run_stats[i].bestn = bestn;
|
|
run_stats[i].size = -1;
|
|
}
|
|
|
|
/* initialize the linked list of saved individuals. */
|
|
saved_head = (saved_ind*) MALLOC(sizeof(saved_ind));
|
|
saved_head->ind = NULL;
|
|
saved_head->refcount = 0;
|
|
saved_head->next = NULL;
|
|
saved_tail = saved_head;
|
|
}
|
|
|
|
/* get the maximum number of generations. */
|
|
param = get_parameter("max_generations");
|
|
if (param == NULL)
|
|
error(E_FATAL_ERROR,
|
|
"no value specified for \"max_generations\".");
|
|
maxgen = atoi(param);
|
|
if (maxgen <= 0)
|
|
error(E_FATAL_ERROR,
|
|
"\"max_generations\" must be greater than zero.");
|
|
|
|
/* get the interval for subpopulation exchanges, if there is more than
|
|
one subpopulation. */
|
|
if (mpop->size > 1)
|
|
{
|
|
param = get_parameter("multiple.exch_gen");
|
|
if (param == NULL)
|
|
error(E_FATAL_ERROR,
|
|
"no value specified for \"multiple.exch_gen\".");
|
|
exch_gen = atoi(param);
|
|
if (exch_gen <= 0)
|
|
error(E_FATAL_ERROR,
|
|
"\"multiple.exch_gen\" must be greater than zero.");
|
|
}
|
|
|
|
/* get the interval for doing checkpointing. */
|
|
param = get_parameter("checkpoint.interval");
|
|
if (param == NULL)
|
|
/* checkpointing disabled. */
|
|
checkinterval = -1;
|
|
else
|
|
checkinterval = atoi(param);
|
|
|
|
/* get the format string for the checkpoint filenames. */
|
|
checkfileformat = get_parameter("checkpoint.filename");
|
|
checkfilename = (char*) MALLOC(strlen(checkfileformat) + 50);
|
|
|
|
/* get the interval for writing information to the .stt file. */
|
|
stt_interval = atoi(get_parameter("output.stt_interval"));
|
|
if (stt_interval < 1)
|
|
error(E_FATAL_ERROR,
|
|
"\"output.stt_interval\" must be greater than zero.");
|
|
|
|
oputs(OUT_SYS, 10, "\n\nstarting evolution.\n");
|
|
|
|
/* print out how often we'll be doing checkpointing. */
|
|
if (checkinterval > 0)
|
|
oprintf(OUT_SYS, 20,
|
|
"checkpointing will be done every %d generations and "\
|
|
"after the last generation.\n", checkinterval);
|
|
else if (checkinterval == 0)
|
|
oprintf(OUT_SYS, 20,
|
|
"checkpointing will be done only after the last "\
|
|
"generation.\n");
|
|
else
|
|
oprintf(OUT_SYS, 20,
|
|
"no checkpointing will be done.\n");
|
|
|
|
output_stream_open(OUT_STT);
|
|
oprintf(OUT_STT, 50, "GEN#\tSUB#\tμFGEN\tFsBestGEN\tFsWorstGEN\tμTreeSzGEN\tμTreeDpGEN\tbTreeSzGEN\tbTreeDpGEN\twTreeSzGEN\twTreeDpGEN\tμFRUN\t"
|
|
"FsBestRUN\tFsWorstRUN\tμTreeSzRUN\tμTreeDpRUN\tbTreeSzRUN\tbTreeDpRUN\twTreeSzRUN\twTreeDpRUN\n");
|
|
|
|
/* the big loop. */
|
|
for (gen = startgen; gen <= maxgen && !term; ++gen)
|
|
{
|
|
oprintf(OUT_SYS, 20,
|
|
"=== generation %d.\n", gen);
|
|
app_begin_of_evaluation(gen, mpop);
|
|
|
|
/* unless this is the first generation after loading a checkpoint
|
|
file... */
|
|
if (!(startfromcheckpoint && gen == startgen))
|
|
{
|
|
|
|
/* evaluate the population. */
|
|
event_mark(&start);
|
|
for (i = 0; i < mpop->size; ++i)
|
|
evaluate_pop(mpop->pop[i]);
|
|
event_mark(&end);
|
|
event_diff(&diff, &start, &end);
|
|
|
|
#ifdef TIMING_AVAILABLE
|
|
oprintf(OUT_SYS, 40, " evaluation complete. (%s)\n",
|
|
event_string(&diff));
|
|
#else
|
|
oprintf ( OUT_SYS, 40, " evaluation complete.\n" );
|
|
#endif
|
|
|
|
event_accum(t_eval, &diff);
|
|
|
|
/* calculate and print statistics. returns 1 if user termination
|
|
criterion was met, 0 otherwise. */
|
|
term = generation_information(gen, mpop, stt_interval,
|
|
run_stats[0].bestn);
|
|
if (term)
|
|
oprintf(OUT_SYS, 30, "user termination criterion met.\n");
|
|
|
|
flush_output_streams();
|
|
|
|
}
|
|
|
|
/** write a checkpoint file if checkinterval is non-negative and:
|
|
we've reached the last generation, or
|
|
the user termination criterion has been met, or
|
|
we've reached the specified checkpoint interval. **/
|
|
if (checkinterval >= 0 &&
|
|
(gen == maxgen || term ||
|
|
(checkinterval > 0 && gen > startgen && (gen % checkinterval) == 0)))
|
|
{
|
|
sprintf(checkfilename, checkfileformat, gen);
|
|
write_checkpoint(gen, mpop, checkfilename);
|
|
}
|
|
|
|
/** if this is not the last generation and the user criterion hasn't
|
|
been met, then do breeding. **/
|
|
if (gen != maxgen && !term)
|
|
{
|
|
|
|
/** exchange subpops if it's time. **/
|
|
if (mpop->size > 1 && gen && (gen % exch_gen) == 0)
|
|
{
|
|
exchange_subpopulations(mpop);
|
|
oprintf(OUT_SYS, 10,
|
|
" subpopulation exchange complete.\n");
|
|
}
|
|
|
|
/* breed the new population. */
|
|
event_mark(&start);
|
|
for (i = 0; i < mpop->size; ++i)
|
|
mpop->pop[i] = change_population(mpop->pop[i], mpop->bpt[i]);
|
|
event_mark(&end);
|
|
event_diff(&diff, &start, &end);
|
|
|
|
/* call the application end-of-breeding callback. */
|
|
app_end_of_breeding(gen, mpop);
|
|
|
|
#ifdef TIMING_AVAILABLE
|
|
oprintf(OUT_SYS, 30, " breeding complete. (%s)\n",
|
|
event_string(&diff));
|
|
#else
|
|
oprintf ( OUT_SYS, 30, " breeding complete.\n" );
|
|
#endif
|
|
|
|
event_accum(t_breed, &diff);
|
|
|
|
}
|
|
|
|
/* free unused ERCs. */
|
|
ephem_const_gc();
|
|
|
|
flush_output_streams();
|
|
|
|
}
|
|
|
|
/** free up a lot of stuff before returning. */
|
|
|
|
if (checkfilename)
|
|
FREE(checkfilename);
|
|
|
|
ephem_const_gc();
|
|
|
|
for (i = 0; i < mpop->size + 1; ++i)
|
|
{
|
|
for (j = 0; j < run_stats[i].bestn; ++j)
|
|
--run_stats[i].best[j]->refcount;
|
|
FREE(run_stats[i].best);
|
|
}
|
|
FREE(run_stats);
|
|
|
|
saved_individual_gc();
|
|
FREE(saved_head);
|
|
}
|
|
|
|
/* generation_information()
|
|
*
|
|
* calculates and prints population statistics.
|
|
*/
|
|
|
|
int generation_information(int gen, multipop* mpop, int stt_interval,
|
|
int bestn)
|
|
{
|
|
int i, j;
|
|
int newbest;
|
|
static int fd = -1;
|
|
popstats* gen_stats;
|
|
int ret = 0;
|
|
FILE* bout, * hout;
|
|
|
|
/* number of decimal digits to use when printing fitness values. */
|
|
if (fd == -1)
|
|
fd = atoi(get_parameter("output.digits"));
|
|
|
|
/* allocate stats records for the current generation. */
|
|
gen_stats = (popstats*) MALLOC((mpop->size + 1) * sizeof(popstats));
|
|
for (i = 0; i < mpop->size + 1; ++i)
|
|
{
|
|
gen_stats[i].bestn = bestn;
|
|
gen_stats[i].size = -1;
|
|
}
|
|
|
|
oprintf(OUT_GEN, 90, "=== GENERATION %d ===\n", gen);
|
|
oprintf(OUT_PRG, 90, "=== GENERATION %d ===\n", gen);
|
|
|
|
/* for each subpopulation... */
|
|
for (i = 0; i < mpop->size; ++i)
|
|
{
|
|
/* calculate stats for subpopulation. */
|
|
calculate_pop_stats(gen_stats + i + 1, mpop->pop[i], gen, i);
|
|
/* accumulate that into stats for whole popluation... */
|
|
accumulate_pop_stats(gen_stats, gen_stats + i + 1);
|
|
/* ...and stats for this subpopulation over the whole run. */
|
|
accumulate_pop_stats(run_stats + i + 1, gen_stats + i + 1);
|
|
|
|
/* if only one subpop, don't print out the subpop stuff. */
|
|
if (mpop->size == 1)
|
|
continue;
|
|
|
|
/** print much stuff to .gen, .prg, and .stt files. */
|
|
|
|
if (test_detail_level(90))
|
|
{
|
|
oprintf(OUT_GEN, 90, " subpopulation %d:\n", i + 1);
|
|
oprintf(OUT_GEN, 90, " generation:\n");
|
|
oprintf(OUT_GEN, 90, " mean: nodes: %.3lf (%d-%d); depth: %.3lf (%d-%d)\n",
|
|
(double) gen_stats[i + 1].totalnodes / gen_stats[i + 1].size,
|
|
gen_stats[i + 1].minnodes, gen_stats[i + 1].maxnodes,
|
|
(double) gen_stats[i + 1].totaldepth / gen_stats[i + 1].size,
|
|
gen_stats[i + 1].mindepth, gen_stats[i + 1].maxdepth);
|
|
oprintf(OUT_GEN, 90, " best: nodes: %d; depth: %d\n",
|
|
gen_stats[i + 1].bestnodes, gen_stats[i + 1].bestdepth);
|
|
oprintf(OUT_GEN, 90, " worst: nodes: %d; depth: %d\n",
|
|
gen_stats[i + 1].worstnodes, gen_stats[i + 1].worstdepth);
|
|
oprintf(OUT_GEN, 90, " run: (%d trees)\n",
|
|
run_stats[i + 1].size);
|
|
oprintf(OUT_GEN, 90, " mean: nodes: %.3lf (%d-%d); depth: %.3lf (%d-%d)\n",
|
|
(double) run_stats[i + 1].totalnodes / run_stats[i + 1].size,
|
|
run_stats[i + 1].minnodes, run_stats[i + 1].maxnodes,
|
|
(double) run_stats[i + 1].totaldepth / run_stats[i + 1].size,
|
|
run_stats[i + 1].mindepth, run_stats[i + 1].maxdepth);
|
|
oprintf(OUT_GEN, 90, " best: nodes: %d; depth: %d\n",
|
|
run_stats[i + 1].bestnodes, run_stats[i + 1].bestdepth);
|
|
oprintf(OUT_GEN, 90, " worst: nodes: %d; depth: %d\n",
|
|
run_stats[i + 1].worstnodes, run_stats[i + 1].worstdepth);
|
|
}
|
|
|
|
if (test_detail_level(90))
|
|
{
|
|
oprintf(OUT_PRG, 90, " subpopulation %d:\n", i + 1);
|
|
oprintf(OUT_PRG, 90, " generation stats:\n");
|
|
oprintf(OUT_PRG, 90, " mean: hits: %.3lf (%d-%d); standardized fitness: %.*lf\n",
|
|
(double) gen_stats[i + 1].totalhits / gen_stats[i + 1].size,
|
|
gen_stats[i + 1].minhits, gen_stats[i + 1].maxhits,
|
|
fd, (double) gen_stats[i + 1].totalfit / gen_stats[i + 1].size);
|
|
oprintf(OUT_PRG, 90, " best: hits: %d; standardized fitness: %.*lf\n",
|
|
gen_stats[i + 1].besthits, fd,
|
|
(double) gen_stats[i + 1].bestfit);
|
|
oprintf(OUT_PRG, 90, " worst: hits: %d; standardized fitness: %.*lf\n",
|
|
gen_stats[i + 1].worsthits, fd,
|
|
(double) gen_stats[i + 1].worstfit);
|
|
oprintf(OUT_PRG, 90, " run stats: (%d trees)\n",
|
|
run_stats[i + 1].size);
|
|
oprintf(OUT_PRG, 90, " mean: hits: %.3lf (%d-%d); standardized fitness: %.*lf\n",
|
|
(double) run_stats[i + 1].totalhits / run_stats[i + 1].size,
|
|
run_stats[i + 1].minhits, run_stats[i + 1].maxhits,
|
|
fd, (double) run_stats[i + 1].totalfit / run_stats[i + 1].size);
|
|
oprintf(OUT_PRG, 90, " best: hits: %d; standardized fitness: %.*lf; generation: %d\n",
|
|
run_stats[i + 1].besthits, fd, (double) run_stats[i + 1].bestfit,
|
|
run_stats[i + 1].bestgen);
|
|
oprintf(OUT_PRG, 90, " worst: hits: %d; standardized fitness: %.*lf; generation: %d\n",
|
|
run_stats[i + 1].worsthits, fd,
|
|
(double) run_stats[i + 1].worstfit, run_stats[i + 1].worstgen);
|
|
}
|
|
|
|
if (gen % stt_interval == 0)
|
|
{
|
|
oprintf(OUT_STT, 50, "%d\t%d\t", gen, i + 1);
|
|
oprintf(OUT_STT, 50, "%.*lf\t%.*lf %.*lf\t",
|
|
fd, gen_stats[i + 1].totalfit / gen_stats[i + 1].size,
|
|
fd, gen_stats[i + 1].bestfit,
|
|
fd, gen_stats[i + 1].worstfit);
|
|
oprintf(OUT_STT, 50, "%.3lf\t%.3lf\t%d\t%d\t%d\t%d\t",
|
|
(double) gen_stats[i + 1].totalnodes / gen_stats[i + 1].size,
|
|
(double) gen_stats[i + 1].totaldepth / gen_stats[i + 1].size,
|
|
gen_stats[i + 1].bestnodes, gen_stats[i + 1].bestdepth,
|
|
gen_stats[i + 1].worstnodes, gen_stats[i + 1].worstdepth);
|
|
oprintf(OUT_STT, 50, "%.*lf\t%.*lf\t%.*lf\t",
|
|
fd, run_stats[i + 1].totalfit / run_stats[i + 1].size,
|
|
fd, run_stats[i + 1].bestfit,
|
|
fd, run_stats[i + 1].worstfit);
|
|
oprintf(OUT_STT, 50, "%.3lf\t%.3lf\t%d\t%d\t%d\t%d\t",
|
|
(double) run_stats[i + 1].totalnodes / run_stats[i + 1].size,
|
|
(double) run_stats[i + 1].totaldepth / run_stats[i + 1].size,
|
|
run_stats[i + 1].bestnodes, run_stats[i + 1].bestdepth,
|
|
run_stats[i + 1].worstnodes, run_stats[i + 1].worstdepth);
|
|
oprintf(OUT_STT, 50, "\n");
|
|
}
|
|
|
|
}
|
|
|
|
/* merge stats for current generation into overall run stats. */
|
|
newbest = accumulate_pop_stats(run_stats, gen_stats);
|
|
|
|
/** more printing. **/
|
|
|
|
if (test_detail_level(90))
|
|
{
|
|
oprintf(OUT_GEN, 90, " total population:\n");
|
|
oprintf(OUT_GEN, 90, " generation:\n");
|
|
oprintf(OUT_GEN, 90, " mean: nodes: %.3lf (%d-%d); depth: %.3lf (%d-%d)\n",
|
|
(double) gen_stats[0].totalnodes / gen_stats[0].size,
|
|
gen_stats[0].minnodes, gen_stats[0].maxnodes,
|
|
(double) gen_stats[0].totaldepth / gen_stats[0].size,
|
|
gen_stats[0].mindepth, gen_stats[0].maxdepth);
|
|
oprintf(OUT_GEN, 90, " best: nodes: %d; depth: %d\n",
|
|
gen_stats[0].bestnodes, gen_stats[0].bestdepth);
|
|
oprintf(OUT_GEN, 90, " worst: nodes: %d; depth: %d\n",
|
|
gen_stats[0].worstnodes, gen_stats[0].worstdepth);
|
|
oprintf(OUT_GEN, 90, " run: (%d trees)\n",
|
|
run_stats[0].size);
|
|
oprintf(OUT_GEN, 90, " mean: nodes: %.3lf (%d-%d); depth: %.3lf (%d-%d)\n",
|
|
(double) run_stats[0].totalnodes / run_stats[0].size,
|
|
run_stats[0].minnodes, run_stats[0].maxnodes,
|
|
(double) run_stats[0].totaldepth / run_stats[0].size,
|
|
run_stats[0].mindepth, run_stats[0].maxdepth);
|
|
oprintf(OUT_GEN, 90, " best: nodes: %d; depth: %d\n",
|
|
run_stats[0].bestnodes, run_stats[0].bestdepth);
|
|
oprintf(OUT_GEN, 90, " worst: nodes: %d; depth: %d\n",
|
|
run_stats[0].worstnodes, run_stats[0].worstdepth);
|
|
}
|
|
|
|
if (test_detail_level(90))
|
|
{
|
|
oprintf(OUT_PRG, 90, " total population:\n");
|
|
oprintf(OUT_PRG, 90, " generation stats:\n");
|
|
oprintf(OUT_PRG, 90, " mean: hits: %.3lf (%d-%d); standardized fitness: %.*lf\n",
|
|
(double) gen_stats[0].totalhits / gen_stats[0].size,
|
|
gen_stats[0].minhits, gen_stats[0].maxhits,
|
|
fd, (double) gen_stats[0].totalfit / gen_stats[0].size);
|
|
oprintf(OUT_PRG, 90, " best: hits: %d; standardized fitness: %.*lf\n",
|
|
gen_stats[0].besthits, fd, (double) gen_stats[0].bestfit);
|
|
oprintf(OUT_PRG, 90, " worst: hits: %d; standardized fitness: %.*lf\n",
|
|
gen_stats[0].worsthits, fd, (double) gen_stats[0].worstfit);
|
|
oprintf(OUT_PRG, 90, " run stats: (%d trees)\n",
|
|
run_stats[0].size);
|
|
oprintf(OUT_PRG, 90, " mean: hits: %.3lf (%d-%d); standardized fitness: %.*lf\n",
|
|
(double) run_stats[0].totalhits / run_stats[0].size,
|
|
run_stats[0].minhits, run_stats[0].maxhits,
|
|
fd, (double) run_stats[0].totalfit / run_stats[0].size);
|
|
oprintf(OUT_PRG, 90, " best: hits: %d; standardized fitness: %.*lf; generation: %d\n",
|
|
run_stats[0].besthits, fd, (double) run_stats[0].bestfit,
|
|
run_stats[0].bestgen);
|
|
oprintf(OUT_PRG, 90, " worst: hits: %d; standardized fitness: %.*lf; generation: %d\n",
|
|
run_stats[0].worsthits, fd, (double) run_stats[0].worstfit,
|
|
run_stats[0].worstgen);
|
|
}
|
|
|
|
if (gen % stt_interval == 0)
|
|
{
|
|
if (test_detail_level(50))
|
|
{
|
|
oprintf(OUT_STT, 50, "%d\t0\t", gen);
|
|
oprintf(OUT_STT, 50, "%.*lf\t%.*lf\t%.*lf\t",
|
|
fd, gen_stats[0].totalfit / gen_stats[0].size,
|
|
fd, gen_stats[0].bestfit, fd, gen_stats[0].worstfit);
|
|
oprintf(OUT_STT, 50, "%.3lf\t%.3lf\t%d\t%d\t%d\t%d\t",
|
|
(double) gen_stats[0].totalnodes / gen_stats[0].size,
|
|
(double) gen_stats[0].totaldepth / gen_stats[0].size,
|
|
gen_stats[0].bestnodes, gen_stats[0].bestdepth,
|
|
gen_stats[0].worstnodes, gen_stats[0].worstdepth);
|
|
oprintf(OUT_STT, 50, "%.*lf\t%.*lf\t%.*lf\t",
|
|
fd, run_stats[0].totalfit / run_stats[0].size,
|
|
fd, run_stats[0].bestfit, fd, run_stats[0].worstfit);
|
|
oprintf(OUT_STT, 50, "%.3lf\t%.3lf\t%d\t%d\t%d\t%d\t",
|
|
(double) run_stats[0].totalnodes / run_stats[0].size,
|
|
(double) run_stats[0].totaldepth / run_stats[0].size,
|
|
run_stats[0].bestnodes, run_stats[0].bestdepth,
|
|
run_stats[0].worstnodes, run_stats[0].worstdepth);
|
|
oprintf(OUT_STT, 50, "\n");
|
|
}
|
|
}
|
|
|
|
/* rewrite the .bst file, and append to the .his file. */
|
|
|
|
output_stream_open(OUT_BST);
|
|
|
|
oprintf(OUT_BST, 10, "=== BEST-OF-RUN ===\n");
|
|
oprintf(OUT_BST, 10, " generation: %d\n",
|
|
run_stats[0].bestgen);
|
|
if (mpop->size > 1)
|
|
oprintf(OUT_BST, 10, " subpopulation: %d\n",
|
|
run_stats[0].bestpop + 1);
|
|
oprintf(OUT_BST, 10, " nodes: %d\n",
|
|
run_stats[0].bestnodes);
|
|
oprintf(OUT_BST, 10, " depth: %d\n",
|
|
run_stats[0].bestdepth);
|
|
oprintf(OUT_BST, 10, " hits: %d\n",
|
|
run_stats[0].besthits);
|
|
|
|
oprintf(OUT_HIS, 10, "=== BEST-OF-RUN ===\n");
|
|
oprintf(OUT_HIS, 10, " current generation: %d\n", gen);
|
|
oprintf(OUT_HIS, 10, " generation: %d\n",
|
|
run_stats[0].bestgen);
|
|
if (mpop->size > 1)
|
|
oprintf(OUT_HIS, 10, " subpopulation: %d\n",
|
|
run_stats[0].bestpop + 1);
|
|
oprintf(OUT_HIS, 10, " nodes: %d\n",
|
|
run_stats[0].bestnodes);
|
|
oprintf(OUT_HIS, 10, " depth: %d\n",
|
|
run_stats[0].bestdepth);
|
|
oprintf(OUT_HIS, 10, " hits: %d\n",
|
|
run_stats[0].besthits);
|
|
|
|
/* retrieve the (FILE *) for the .bst and .his files, so that
|
|
the trees can be printed to them. */
|
|
|
|
bout = output_filehandle(OUT_BST);
|
|
hout = output_filehandle(OUT_HIS);
|
|
|
|
if (run_stats[0].bestn == 1)
|
|
{
|
|
oprintf(OUT_BST, 20, "TOP INDIVIDUAL:\n\n");
|
|
oprintf(OUT_HIS, 20, "TOP INDIVIDUAL:\n\n");
|
|
} else
|
|
{
|
|
oprintf(OUT_BST, 20, "TOP %d INDIVIDUALS (in order):\n\n",
|
|
run_stats[0].bestn);
|
|
oprintf(OUT_HIS, 20, "TOP %d INDIVIDUALS (in order):\n\n",
|
|
run_stats[0].bestn);
|
|
}
|
|
|
|
for (i = 0; i < run_stats[0].bestn; ++i)
|
|
{
|
|
oprintf(OUT_BST, 20, "\n\n-- #%d --\n", i + 1);
|
|
|
|
oprintf(OUT_BST, 20, " hits: %d\n",
|
|
run_stats[0].best[i]->ind->hits);
|
|
oprintf(OUT_BST, 20, " raw fitness: %.*lf\n",
|
|
fd, run_stats[0].best[i]->ind->r_fitness);
|
|
oprintf(OUT_BST, 20, " standardized fitness: %.*lf\n",
|
|
fd, run_stats[0].best[i]->ind->s_fitness);
|
|
oprintf(OUT_BST, 20, " adjusted fitness: %.*lf\n",
|
|
fd, run_stats[0].best[i]->ind->a_fitness);
|
|
|
|
oprintf(OUT_HIS, 20, "\n\n-- #%d --\n", i + 1);
|
|
|
|
oprintf(OUT_HIS, 20, " hits: %d\n",
|
|
run_stats[0].best[i]->ind->hits);
|
|
oprintf(OUT_HIS, 20, " raw fitness: %.*lf\n",
|
|
fd, run_stats[0].best[i]->ind->r_fitness);
|
|
oprintf(OUT_HIS, 20, " standardized fitness: %.*lf\n",
|
|
fd, run_stats[0].best[i]->ind->s_fitness);
|
|
oprintf(OUT_HIS, 20, " adjusted fitness: %.*lf\n",
|
|
fd, run_stats[0].best[i]->ind->a_fitness);
|
|
|
|
/* print the tree to both files here. */
|
|
if (test_detail_level(20))
|
|
{
|
|
pretty_print_individual(run_stats[0].best[i]->ind, bout);
|
|
pretty_print_individual_equ(run_stats[0].best[i]->ind, bout);
|
|
pretty_print_individual(run_stats[0].best[i]->ind, hout);
|
|
}
|
|
}
|
|
|
|
/* call the end-of-evaluation callback. returns 1 if user termination
|
|
criterion is met, 0 otherwise. */
|
|
ret = app_end_of_evaluation(gen, mpop, newbest, gen_stats, run_stats);
|
|
|
|
/* close the .bst file. */
|
|
output_stream_close(OUT_BST);
|
|
|
|
/* free stats structures for current generation. */
|
|
for (i = 0; i < mpop->size + 1; ++i)
|
|
{
|
|
for (j = 0; j < gen_stats[i].bestn; ++j)
|
|
--gen_stats[i].best[j]->refcount;
|
|
FREE(gen_stats[i].best);
|
|
}
|
|
FREE(gen_stats);
|
|
|
|
/* deallocate saved individuals that are no longer needed. */
|
|
saved_individual_gc();
|
|
|
|
/* return value the application callback gave us. */
|
|
return ret;
|
|
|
|
}
|
|
|
|
/* evaluate_pop()
|
|
*
|
|
* evaluates all the individuals in a population whose cached
|
|
* fitness values are invalid.
|
|
*/
|
|
|
|
void evaluate_pop(population* pop)
|
|
{
|
|
int i;
|
|
#if defined(POSIX_MT) || defined(SOLARIS_MT)
|
|
int start, end, inc, err;
|
|
struct thread_param_t* t_param;
|
|
#endif
|
|
#if POSIX_MT
|
|
pthread_t* t_ids;
|
|
#endif
|
|
|
|
#ifdef DEBUG
|
|
print_individual ( pop->ind, stdout );
|
|
#ifdef COEVOLUTION
|
|
printf("Can't do COEVOLUTION and DEBUG at the same time, sorry!\n");
|
|
#else
|
|
app_eval_fitness ( pop->ind );
|
|
#endif
|
|
exit(0);
|
|
#endif
|
|
|
|
#if !defined(POSIX_MT) && !defined(SOLARIS_MT)
|
|
#ifdef COEVOLUTION
|
|
|
|
if (pop->size % 2)
|
|
{
|
|
/* It's not even! */
|
|
error ( E_FATAL_ERROR, "Population must be even to do COEVOLUTION\n");
|
|
}
|
|
|
|
for ( i = 0; i < pop->size; i+=2)
|
|
if ( pop->ind[i].evald != EVAL_CACHE_VALID ||
|
|
pop->ind[i+1].evald != EVAL_CACHE_VALID )
|
|
app_eval_fitness ( (pop->ind)+i );
|
|
#else
|
|
for ( i = 0; i < pop->size; ++i )
|
|
if ( pop->ind[i].evald != EVAL_CACHE_VALID )
|
|
app_eval_fitness ( (pop->ind)+i );
|
|
#endif
|
|
|
|
#else
|
|
|
|
#if POSIX_MT
|
|
t_ids = (pthread_t*) MALLOC(numthreads * sizeof(pthread_t));
|
|
#endif
|
|
t_param = (struct thread_param_t*) MALLOC(numthreads *
|
|
sizeof(struct thread_param_t));
|
|
|
|
/* figure out how many pop members per thread */
|
|
inc = pop->size / numthreads;
|
|
if (pop->size != inc * numthreads) inc++;
|
|
|
|
start = 0;
|
|
for (i = 0; i < numthreads; i++)
|
|
{
|
|
end = start + inc;
|
|
if (end > pop->size) end = pop->size;
|
|
|
|
/* setup the paramater to pass */
|
|
t_param[i].pop = pop;
|
|
t_param[i].startidx = start;
|
|
t_param[i].endidx = end;
|
|
t_param[i].g = *(get_globaldata());
|
|
|
|
#ifdef POSIX_MT
|
|
err = pthread_create(&t_ids[i], &pthread_attr,
|
|
evaluate_pop_chunk, &t_param[i]);
|
|
#endif
|
|
#ifdef SOLARIS_MT
|
|
err = thr_create(NULL, (int)NULL, evaluate_pop_chunk,
|
|
&t_param[i], (int)NULL,NULL);
|
|
#endif
|
|
if (err != 0)
|
|
{
|
|
error(E_FATAL_ERROR, "cannot create thread");
|
|
}
|
|
|
|
start = end;
|
|
}
|
|
|
|
#ifdef SOLARIS_MT
|
|
while (thr_join(NULL, NULL, NULL) == 0);
|
|
#endif
|
|
#ifdef POSIX_MT
|
|
for (i = 0; i < numthreads; i++)
|
|
{
|
|
pthread_join(t_ids[i], NULL);
|
|
}
|
|
FREE(t_ids);
|
|
#endif
|
|
FREE(t_param);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
/* calculate_pop_stats()
|
|
*
|
|
* tabulates stats for a population: fitness and size of best, worst,
|
|
* mean, etc. also finds top N individuals and saves them.
|
|
*/
|
|
|
|
void calculate_pop_stats(popstats* s, population* pop, int gen,
|
|
int subpop)
|
|
{
|
|
int i, j, k, l;
|
|
int b;
|
|
saved_ind* shp;
|
|
individual** temp;
|
|
|
|
/* allocate a list of the top N individuals. */
|
|
s->best = (saved_ind**) MALLOC(s->bestn *
|
|
sizeof(saved_ind*));
|
|
temp = (individual**) MALLOC((s->bestn + 1) * sizeof(individual*));
|
|
|
|
s->size = pop->size;
|
|
|
|
/** this is all pretty obvious -- set all the max and min values to the
|
|
first individual's values, then go through the population looking for
|
|
things that are bigger/smaller/better/worse/etc. **/
|
|
|
|
s->maxnodes = s->minnodes = s->totalnodes = s->bestnodes = s->worstnodes =
|
|
individual_size(pop->ind + 0);
|
|
s->maxdepth = s->mindepth = s->totaldepth = s->bestdepth = s->worstdepth =
|
|
individual_depth(pop->ind + 0);
|
|
s->maxhits = s->minhits = s->totalhits = s->besthits = s->worsthits =
|
|
pop->ind[0].hits;
|
|
s->bestfit = s->worstfit = s->totalfit = pop->ind[0].a_fitness;
|
|
temp[0] = pop->ind;
|
|
b = 1;
|
|
s->bestgen = s->worstgen = gen;
|
|
s->bestpop = s->worstpop = subpop;
|
|
|
|
for (i = 1; i < s->size; ++i)
|
|
{
|
|
j = individual_size(pop->ind + i);
|
|
s->totalnodes += j;
|
|
if (j < s->minnodes) s->minnodes = j;
|
|
if (j > s->maxnodes) s->maxnodes = j;
|
|
|
|
k = individual_depth(pop->ind + i);
|
|
s->totaldepth += k;
|
|
if (k < s->mindepth) s->mindepth = k;
|
|
if (k > s->maxdepth) s->maxdepth = k;
|
|
|
|
l = pop->ind[i].hits;
|
|
s->totalhits += l;
|
|
if (l < s->minhits) s->minhits = l;
|
|
if (l > s->maxhits) s->maxhits = l;
|
|
|
|
s->totalfit += pop->ind[i].a_fitness;
|
|
if (pop->ind[i].a_fitness > s->bestfit)
|
|
{
|
|
s->bestfit = pop->ind[i].a_fitness;
|
|
s->bestnodes = j;
|
|
s->bestdepth = k;
|
|
s->besthits = l;
|
|
} else if (pop->ind[i].a_fitness < s->worstfit)
|
|
{
|
|
s->worstfit = pop->ind[i].a_fitness;
|
|
s->worstnodes = j;
|
|
s->worstdepth = k;
|
|
s->worsthits = l;
|
|
}
|
|
|
|
/** insert the current individual into the top N list
|
|
(if it belongs there). **/
|
|
|
|
for (j = b; j > 0; --j)
|
|
{
|
|
if (pop->ind[i].a_fitness < temp[j - 1]->a_fitness)
|
|
break;
|
|
temp[j] = temp[j - 1];
|
|
}
|
|
if (j < s->bestn)
|
|
temp[j] = pop->ind + i;
|
|
if (b < s->bestn)
|
|
++b;
|
|
}
|
|
|
|
/** now save copies of the individuals in the "temp" list **/
|
|
for (i = 0; i < b; ++i)
|
|
{
|
|
shp = (saved_ind*) MALLOC(sizeof(saved_ind));
|
|
shp->ind = (individual*) MALLOC(sizeof(individual));
|
|
shp->ind->tr = (tree*) MALLOC(tree_count * sizeof(tree));
|
|
duplicate_individual(shp->ind, temp[i]);
|
|
for (j = 0; j < tree_count; ++j)
|
|
reference_ephem_constants(shp->ind->tr[j].data, 1);
|
|
shp->refcount = 1;
|
|
shp->next = NULL;
|
|
|
|
saved_tail->next = shp;
|
|
saved_tail = shp;
|
|
++saved_head->refcount;
|
|
|
|
s->best[i] = shp;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
printf ( "the best list is:\n" );
|
|
for ( j = 0; j < s->bestn; ++j )
|
|
printf ( " %08x %lf\n", s->best[j], s->best[j]->ind->a_fitness );
|
|
#endif
|
|
|
|
FREE(temp);
|
|
|
|
}
|
|
|
|
/* accumulate_pop_stats()
|
|
*
|
|
* this merges the second statistics record into the first, so that it reflects
|
|
* the "sum" of the underlying populations. returns 1 if the best individual
|
|
* of the first record has changed (that is, if the second record has a better
|
|
* best individual.
|
|
*/
|
|
|
|
int accumulate_pop_stats(popstats* total, popstats* n)
|
|
{
|
|
int ret = 0;
|
|
int i, j, k;
|
|
saved_ind** temp;
|
|
|
|
if (total->size == -1)
|
|
{
|
|
/* if the "total" record is empty, then just copy the second record
|
|
into it. */
|
|
memcpy(total, n, sizeof(popstats));
|
|
total->best = (saved_ind**) MALLOC(total->bestn *
|
|
sizeof(saved_ind*));
|
|
memcpy(total->best, n->best, total->bestn *
|
|
sizeof(saved_ind*));
|
|
ret = 1;
|
|
} else
|
|
{
|
|
/* sum the totals. */
|
|
total->size += n->size;
|
|
total->totalnodes += n->totalnodes;
|
|
total->totaldepth += n->totaldepth;
|
|
total->totalhits += n->totalhits;
|
|
total->totalfit += n->totalfit;
|
|
|
|
/* find the maximums. */
|
|
if (n->maxnodes > total->maxnodes) total->maxnodes = n->maxnodes;
|
|
if (n->maxdepth > total->maxdepth) total->maxdepth = n->maxdepth;
|
|
if (n->maxhits > total->maxhits) total->maxhits = n->maxhits;
|
|
|
|
/* find the minimums. */
|
|
if (n->minnodes < total->minnodes) total->minnodes = n->minnodes;
|
|
if (n->mindepth < total->mindepth) total->mindepth = n->mindepth;
|
|
if (n->minhits < total->minhits) total->minhits = n->minhits;
|
|
|
|
/* find the best individual's numbers. */
|
|
if (n->bestfit > total->bestfit)
|
|
{
|
|
total->bestfit = n->bestfit;
|
|
total->bestnodes = n->bestnodes;
|
|
total->bestdepth = n->bestdepth;
|
|
total->besthits = n->besthits;
|
|
total->bestgen = n->bestgen;
|
|
total->bestpop = n->bestpop;
|
|
ret = 1;
|
|
}
|
|
|
|
/* find the worst individual's numbers. */
|
|
if (n->worstfit < total->worstfit)
|
|
{
|
|
total->worstfit = n->worstfit;
|
|
total->worstnodes = n->worstnodes;
|
|
total->worstdepth = n->worstdepth;
|
|
total->worsthits = n->worsthits;
|
|
total->worstgen = n->worstgen;
|
|
total->worstpop = n->worstpop;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
printf ( "total list:\n" );
|
|
for ( i = 0; i < total->bestn; ++i )
|
|
printf ( " %08x %lf\n",
|
|
total->best[i], total->best[i]->ind->a_fitness );
|
|
printf ( "new list:\n" );
|
|
for ( i = 0; i < n->bestn; ++i )
|
|
printf ( " %08x %lf\n",
|
|
n->best[i], n->best[i]->ind->a_fitness );
|
|
#endif
|
|
|
|
/** here we merge the two "top N" lists into one, discarding
|
|
the remaining N individuals. **/
|
|
|
|
temp = (saved_ind**) MALLOC(total->bestn *
|
|
sizeof(saved_ind*));
|
|
j = 0; /* position in "total"s list */
|
|
k = 0; /* position in "n"s list */
|
|
for (i = 0; i < total->bestn; ++i)
|
|
{
|
|
/* if the n list is empty, take from the total list. */
|
|
if (k == -1)
|
|
temp[i] = total->best[j++];
|
|
/* if the total list is empty, take from the n list. */
|
|
else if (j == -1)
|
|
{
|
|
ret |= (i == 0);
|
|
temp[i] = n->best[k++];
|
|
}
|
|
/* if neither list is empty, take the better individual. */
|
|
else if (total->best[j]->ind->a_fitness <
|
|
n->best[k]->ind->a_fitness)
|
|
{
|
|
ret |= (i == 0);
|
|
temp[i] = n->best[k++];
|
|
} else
|
|
temp[i] = total->best[j++];
|
|
|
|
/* have we run off the end of either list? */
|
|
if (j >= total->bestn)
|
|
j = -1;
|
|
if (k >= n->bestn)
|
|
k = -1;
|
|
}
|
|
|
|
/* decrement the reference count of the old "best" list. */
|
|
for (i = 0; i < total->bestn; ++i)
|
|
--total->best[i]->refcount;
|
|
|
|
FREE(total->best);
|
|
total->best = temp;
|
|
|
|
#ifdef DEBUG
|
|
printf ( "new total list:\n" );
|
|
for ( i = 0; i < total->bestn; ++i )
|
|
printf ( " %08x %lf\n",
|
|
total->best[i], total->best[i]->ind->a_fitness );
|
|
#endif
|
|
}
|
|
|
|
/* increment the reference count of the new "best" list. */
|
|
for (i = 0; i < total->bestn; ++i)
|
|
++total->best[i]->refcount;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* saved_individual_gc()
|
|
*
|
|
* go through the list of saved individuals, deleting any which are no longer
|
|
* referred to.
|
|
*/
|
|
|
|
void saved_individual_gc(void)
|
|
{
|
|
int j;
|
|
saved_ind* shp = saved_head->next;
|
|
saved_ind* shm = saved_head;
|
|
|
|
while (shp)
|
|
{
|
|
if (shp->refcount == 0)
|
|
{
|
|
/** found one that needs to be deleted. **/
|
|
|
|
/* dereference its trees' ERCs and delete the trees. */
|
|
for (j = 0; j < tree_count; ++j)
|
|
{
|
|
reference_ephem_constants(shp->ind->tr[j].data, -1);
|
|
free_tree(shp->ind->tr + j);
|
|
}
|
|
FREE(shp->ind->tr);
|
|
FREE(shp->ind);
|
|
|
|
/* cut the record out of the linked list. */
|
|
shm->next = shp->next;
|
|
if (saved_tail == shp)
|
|
saved_tail = shm;
|
|
FREE(shp);
|
|
shp = shm->next;
|
|
|
|
/* the refcount field of the list head (a dummy node) holds the
|
|
size of the list. */
|
|
--saved_head->refcount;
|
|
} else
|
|
{
|
|
/* move down the list. */
|
|
shm = shp;
|
|
shp = shp->next;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* read_saved_individuals()
|
|
*
|
|
* reads the list of saved individuals from a checkpoint file. constructs
|
|
* an index translating indices to addresses.
|
|
*/
|
|
|
|
saved_ind** read_saved_individuals(ephem_const** eind, FILE* f)
|
|
{
|
|
char* buffer;
|
|
int count;
|
|
int i;
|
|
saved_ind* p;
|
|
saved_ind** sind;
|
|
|
|
buffer = (char*) MALLOC(MAXCHECKLINELENGTH);
|
|
|
|
/* read the number of saved individuals. */
|
|
fscanf(f, "%*s %d\n", &count);
|
|
|
|
/* allocate the index. */
|
|
sind = (saved_ind**) MALLOC(count * sizeof(saved_ind*));
|
|
|
|
/* allocate the head of the linked list (a dummy node whose refcount
|
|
equals the number of individuals on the list). */
|
|
saved_head = (saved_ind*) MALLOC(sizeof(saved_ind));
|
|
saved_head->ind = NULL;
|
|
saved_head->refcount = count;
|
|
p = saved_head;
|
|
for (i = 0; i < count; ++i)
|
|
{
|
|
/* allocate the next saved_ind on the list. */
|
|
p->next = (saved_ind*) MALLOC(sizeof(saved_ind));
|
|
p = p->next;
|
|
/* allocate the individual. */
|
|
p->ind = (individual*) MALLOC(sizeof(individual));
|
|
/* make the index entry. */
|
|
sind[i] = p;
|
|
/* read the refcount. */
|
|
fscanf(f, "%d ", &(p->refcount));
|
|
/* read the individual. */
|
|
read_individual(p->ind, eind, f, buffer);
|
|
}
|
|
/* mark the end of the list. */
|
|
p->next = NULL;
|
|
saved_tail = p;
|
|
|
|
FREE(buffer);
|
|
|
|
return sind;
|
|
}
|
|
|
|
/* read_stats_checkpoint()
|
|
*
|
|
* read the overall run statistics structures from a checkpoint file.
|
|
*/
|
|
|
|
void read_stats_checkpoint(multipop* mpop, ephem_const** eind, FILE* f)
|
|
{
|
|
int i, j, k;
|
|
saved_ind** sind;
|
|
|
|
/* read and index the saved individuals list. */
|
|
sind = read_saved_individuals(eind, f);
|
|
|
|
/* allocate the run_stats array. */
|
|
run_stats = (popstats*) MALLOC((mpop->size + 1) * sizeof(popstats));
|
|
for (i = 0; i < mpop->size + 1; ++i)
|
|
{
|
|
/* read lots of integer values into run_stats. */
|
|
fscanf(f, "%d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d\n",
|
|
&(run_stats[i].size),
|
|
&(run_stats[i].maxnodes), &(run_stats[i].minnodes),
|
|
&(run_stats[i].totalnodes), &(run_stats[i].bestnodes),
|
|
&(run_stats[i].worstnodes),
|
|
&(run_stats[i].maxdepth), &(run_stats[i].mindepth),
|
|
&(run_stats[i].totaldepth), &(run_stats[i].bestdepth),
|
|
&(run_stats[i].worstdepth),
|
|
&(run_stats[i].maxhits), &(run_stats[i].minhits),
|
|
&(run_stats[i].totalhits), &(run_stats[i].besthits),
|
|
&(run_stats[i].worsthits));
|
|
/** double-precision values are stored as hex data to avoid loss
|
|
of precision. **/
|
|
read_hex_block(&(run_stats[i].bestfit), sizeof(double), f);
|
|
fgetc(f);
|
|
read_hex_block(&(run_stats[i].worstfit), sizeof(double), f);
|
|
fgetc(f);
|
|
read_hex_block(&(run_stats[i].totalfit), sizeof(double), f);
|
|
/* they are also printed as decimal values, for the benefit of human
|
|
readers -- skip these fields. */
|
|
fscanf(f, " %*f %*f %*f\n");
|
|
/* read some more integers. */
|
|
fscanf(f, "%d %d %d %d %d ",
|
|
&(run_stats[i].bestgen), &(run_stats[i].worstgen),
|
|
&(run_stats[i].bestpop), &(run_stats[i].worstpop),
|
|
&(run_stats[i].bestn));
|
|
run_stats[i].best = (saved_ind**) MALLOC(run_stats[i].bestn *
|
|
sizeof(saved_ind*));
|
|
/** read the indices of the contents of the best array, and look up
|
|
the addresses in the index. **/
|
|
for (j = 0; j < run_stats[i].bestn; ++j)
|
|
{
|
|
fscanf(f, "%d\n", &k);
|
|
run_stats[i].best[j] = sind[k];
|
|
}
|
|
}
|
|
FREE(sind);
|
|
}
|
|
|
|
/* write_saved_individuals()
|
|
*
|
|
* writes the linked list of saved individuals to a checkpoint file. returns
|
|
* an index for translating saved_ind addresses to integer indices.
|
|
*/
|
|
|
|
saved_ind** write_saved_individuals(ephem_index* eind, FILE* f)
|
|
{
|
|
saved_ind** index;
|
|
saved_ind* shp;
|
|
int i = 0;
|
|
|
|
index = (saved_ind**) MALLOC(saved_head->refcount *
|
|
sizeof(saved_ind*));
|
|
|
|
/* write the count of individuals. */
|
|
fprintf(f, "saved-individual-count: %d\n", saved_head->refcount);
|
|
|
|
shp = saved_head->next;
|
|
|
|
/** traverse the linked list. **/
|
|
while (shp)
|
|
{
|
|
/* write the reference count and individual. */
|
|
fprintf(f, "%d ", shp->refcount);
|
|
write_individual(shp->ind, eind, f);
|
|
|
|
/* record the address in the index. */
|
|
index[i++] = shp;
|
|
|
|
shp = shp->next;
|
|
}
|
|
|
|
return index;
|
|
}
|
|
|
|
/* write_stats_checkpoint()
|
|
*
|
|
* write the overall run statistics structures to a checkpoint file.
|
|
*/
|
|
|
|
void write_stats_checkpoint(multipop* mpop, ephem_index* eind, FILE* f)
|
|
{
|
|
int i, j, k;
|
|
saved_ind** sind;
|
|
|
|
/* write and index the saved individuals list. */
|
|
sind = write_saved_individuals(eind, f);
|
|
|
|
for (i = 0; i < mpop->size + 1; ++i)
|
|
{
|
|
/* write many integer values. */
|
|
fprintf(f, "%d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d\n",
|
|
run_stats[i].size,
|
|
run_stats[i].maxnodes, run_stats[i].minnodes,
|
|
run_stats[i].totalnodes, run_stats[i].bestnodes,
|
|
run_stats[i].worstnodes,
|
|
run_stats[i].maxdepth, run_stats[i].mindepth,
|
|
run_stats[i].totaldepth, run_stats[i].bestdepth,
|
|
run_stats[i].worstdepth,
|
|
run_stats[i].maxhits, run_stats[i].minhits,
|
|
run_stats[i].totalhits, run_stats[i].besthits,
|
|
run_stats[i].worsthits);
|
|
/** write double-precision values as hex data. **/
|
|
write_hex_block(&(run_stats[i].bestfit), sizeof(double), f);
|
|
fputc(' ', f);
|
|
write_hex_block(&(run_stats[i].worstfit), sizeof(double), f);
|
|
fputc(' ', f);
|
|
write_hex_block(&(run_stats[i].totalfit), sizeof(double), f);
|
|
/* also write them as decimal values. */
|
|
fprintf(f, " %f %f %f\n", run_stats[i].bestfit,
|
|
run_stats[i].worstfit, run_stats[i].totalfit);
|
|
/* write more integers. */
|
|
fprintf(f, "%d %d %d %d %d ",
|
|
run_stats[i].bestgen, run_stats[i].worstgen,
|
|
run_stats[i].bestpop, run_stats[i].worstpop,
|
|
run_stats[i].bestn);
|
|
/** write the best array, indexing saved individuals using integers. **/
|
|
for (j = 0; j < run_stats[i].bestn; ++j)
|
|
{
|
|
/** search the index for the address. **/
|
|
for (k = 0; k < saved_head->refcount; ++k)
|
|
if (run_stats[i].best[j] == sind[k])
|
|
{
|
|
/* print the index to the checkpoint file. */
|
|
fprintf(f, " %d", k);
|
|
break;
|
|
}
|
|
/** address was not found in the index. **/
|
|
if (k == saved_head->refcount)
|
|
{
|
|
/* this shouldn't ever happen. */
|
|
fprintf(f, " -1");
|
|
error(E_WARNING, "bestn pointer is bad.");
|
|
}
|
|
}
|
|
|
|
fputc('\n', f);
|
|
}
|
|
|
|
FREE(sind);
|
|
}
|
|
|
|
|
|
#if !defined(POSIX_MT) && !defined(SOLARIS_MT)
|
|
|
|
/* return the globaldata structure */
|
|
globaldata *get_globaldata(void) {
|
|
return( &global_g );
|
|
}
|
|
|
|
#else /* continues to end of file */
|
|
|
|
/* provide each thread with seperate copy of 'g' */
|
|
globaldata* get_globaldata(void)
|
|
{
|
|
globaldata* retval;
|
|
|
|
#ifdef POSIX_MT
|
|
retval = pthread_getspecific(g_key);
|
|
#endif
|
|
#ifdef SOLARIS_MT
|
|
thr_getspecific( g_key, (void *)&retval );
|
|
#endif
|
|
|
|
if (retval == NULL)
|
|
{
|
|
error(E_FATAL_ERROR, "get_globaldata() tried to return NULL");
|
|
}
|
|
|
|
return (retval);
|
|
}
|
|
|
|
|
|
/*
|
|
* initialize_threading()
|
|
*
|
|
* Setup the program for multithreading use.
|
|
*/
|
|
|
|
void initialize_threading(void)
|
|
{
|
|
char* numthreads_str;
|
|
globaldata* main_g;
|
|
|
|
/* numthreads_str = getenv( "NUM_THREADS" );*/
|
|
numthreads_str = get_parameter("num_threads"); /* Now in input file */
|
|
if (numthreads_str == NULL)
|
|
{
|
|
error(E_FATAL_ERROR, "num_threads undefined");
|
|
}
|
|
numthreads = atoi(numthreads_str);
|
|
if (numthreads < 1)
|
|
{
|
|
error(E_FATAL_ERROR, "num_threads must be > 0");
|
|
}
|
|
|
|
printf("numthreads: %d\n", numthreads);
|
|
|
|
/* create the thread key for access to 'g' */
|
|
#ifdef POSIX_MT
|
|
pthread_key_create(&g_key, NULL);
|
|
#endif
|
|
#ifdef SOLARIS_MT
|
|
thr_keycreate( &g_key, NULL );
|
|
#endif
|
|
|
|
/* main thread needs its own 'g' */
|
|
main_g = (globaldata*) malloc(sizeof(globaldata));
|
|
#ifdef POSIX_MT
|
|
pthread_setspecific(g_key, main_g);
|
|
#endif
|
|
#ifdef SOLARIS_MT
|
|
thr_setspecific(g_key, main_g);
|
|
#endif
|
|
|
|
#ifdef POSIX_MT
|
|
/* Setup default thread attributes */
|
|
pthread_attr_init(&pthread_attr);
|
|
pthread_attr_setscope(&pthread_attr, PTHREAD_SCOPE_SYSTEM);
|
|
|
|
if (1)
|
|
{
|
|
size_t size;
|
|
size_t guard;
|
|
|
|
/* Double the stack size */
|
|
pthread_attr_getstacksize(&pthread_attr, &size);
|
|
printf("Kernel Old Size %d\n", (int) size);
|
|
pthread_attr_setstacksize(&pthread_attr, size * 2);
|
|
pthread_attr_getstacksize(&pthread_attr, &size);
|
|
printf("Kernel New Size %d\n", (int) size);
|
|
|
|
/* Double the Guard size (account for old pthread implementation) */
|
|
#ifdef PTHREAD_1.X
|
|
pthread_attr_getguardsize_np(&pthread_attr,&guard);
|
|
printf("Kernel Old Guard %d\n",(int)guard);
|
|
pthread_attr_setguardsize_np(&pthread_attr,2*guard);
|
|
pthread_attr_getguardsize_np(&pthread_attr,&guard);
|
|
#else
|
|
pthread_attr_getguardsize(&pthread_attr, &guard);
|
|
printf("Kernel Old Guard %d\n", (int) guard);
|
|
pthread_attr_setguardsize(&pthread_attr, 2 * guard);
|
|
pthread_attr_getguardsize(&pthread_attr, &guard);
|
|
#endif
|
|
printf("Kernel New Guard %d\n", (int) guard);
|
|
}
|
|
#endif
|
|
|
|
#ifdef SOLARIS_MT
|
|
/* let the OS know how many threads to run at once */
|
|
thr_setconcurrency( numthreads );
|
|
#endif
|
|
|
|
}
|
|
|
|
/* evaluate_pop_chuck()
|
|
*
|
|
* Called from evaluate_pop to do a chunk of evaluations on a pop.
|
|
* This was done to allow multithreading.
|
|
*/
|
|
|
|
void* evaluate_pop_chunk(void* param)
|
|
{
|
|
int k, startidx, endidx;
|
|
population* pop;
|
|
globaldata* g;
|
|
struct thread_param_t* t_param;
|
|
|
|
t_param = (struct thread_param_t*) param;
|
|
pop = t_param->pop;
|
|
startidx = t_param->startidx;
|
|
endidx = t_param->endidx;
|
|
|
|
#ifdef POSIX_MT
|
|
pthread_setspecific(g_key, &t_param->g);
|
|
#endif
|
|
#ifdef SOLARIS_MT
|
|
thr_setspecific(g_key, &t_param->g);
|
|
#endif
|
|
|
|
g = get_globaldata();
|
|
|
|
/* printf("START: %d,%d\n", startidx, endidx); */
|
|
|
|
#ifdef COEVOLUTION /* Here we hack it to provide *two* individuals */
|
|
|
|
if ((endidx-startidx)%2) /* it it's not even */
|
|
|
|
{
|
|
char xx[256];
|
|
sprintf(xx,"Uneven number of individuals (%d) at %d",
|
|
endidx-startidx,startidx);
|
|
error ( E_FATAL_ERROR,xx);
|
|
}
|
|
|
|
for ( k = startidx; k < endidx; k+=2 )
|
|
|
|
/* It's GOT to have even number of inds */
|
|
|
|
if ( pop->ind[k].evald != EVAL_CACHE_VALID ||
|
|
pop->ind[k+1].evald != EVAL_CACHE_VALID )
|
|
{
|
|
app_eval_fitness ( (pop->ind)+k, (pop->ind)+(k+1) );
|
|
}
|
|
#else
|
|
for (k = startidx; k < endidx; ++k)
|
|
if (pop->ind[k].evald != EVAL_CACHE_VALID)
|
|
{
|
|
app_eval_fitness((pop->ind) + k);
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
#endif /* !defined(POSIX_MT) && !defined(SOLARIS_MT) */
|
|
|
|
|