Debugged multithreaded version. Now investigating some performance issues (not every thread is being used). This is an interesting version.
This commit is contained in:
176
inc/genetic.h
176
inc/genetic.h
@@ -1,6 +1,7 @@
|
||||
#pragma once
|
||||
|
||||
#include <algorithm>
|
||||
#include <cfloat>
|
||||
#include <cstdlib>
|
||||
|
||||
#include "util.h"
|
||||
@@ -30,6 +31,12 @@ template <class T> struct Strategy {
|
||||
// Number of times (epochs) to run the algorithm
|
||||
int num_generations;
|
||||
|
||||
// Each thread will integrate the best globally performing cell
|
||||
bool share_breakthroughs;
|
||||
|
||||
// How many generations to explore before resyncing with the global best
|
||||
int share_breakthrough_gen_period;
|
||||
|
||||
bool test_all; // Sets whether or not every cell's fitness is evaluated every
|
||||
// generation
|
||||
float test_chance; // Chance to test any given cell's fitness. Relevant only
|
||||
@@ -66,16 +73,11 @@ template<class T> struct Stats {
|
||||
DynArray<float> best_cell_fitness;
|
||||
int gen;
|
||||
bool done;
|
||||
TimeSpan start, end;
|
||||
TimeSpan total_crossover_time;
|
||||
int total_crossovers;
|
||||
TimeSpan total_mutate_time;
|
||||
int total_mutates;
|
||||
TimeSpan total_fitness_time;
|
||||
int total_evaluations;
|
||||
TimeSpan total_sorting_time;
|
||||
int total_sorts;
|
||||
|
||||
DynArray<TimeSpan> gen_time;
|
||||
DynArray<TimeSpan> crossover_time;
|
||||
DynArray<TimeSpan> mutate_time;
|
||||
DynArray<TimeSpan> fitness_time;
|
||||
DynArray<TimeSpan> sorting_time;
|
||||
Mutex m;
|
||||
};
|
||||
|
||||
@@ -90,6 +92,10 @@ struct WorkerThreadArgs {
|
||||
Array<T> cells;
|
||||
Array<CellTracker> trackers;
|
||||
Stats<T> *stats;
|
||||
|
||||
Mutex m;
|
||||
float *best_global_score;
|
||||
T* best_global_cell;
|
||||
};
|
||||
|
||||
template<class T> T* _cellp(Array<T> cells, CellTracker tracker) { return &cells[tracker.cellid]; }
|
||||
@@ -101,6 +107,9 @@ template <class T> DWORD worker(LPVOID args) {
|
||||
Array<T> cells = worker_args->cells;
|
||||
Array<CellTracker> trackers = worker_args->trackers;
|
||||
Stats<T> &stats = *worker_args->stats;
|
||||
float* best_global_score = worker_args->best_global_score;
|
||||
T* best_global_cell = worker_args->best_global_cell;
|
||||
Mutex best_m = worker_args->m;
|
||||
|
||||
// Prepare crossover operations as these will be the same every time except
|
||||
// for the exact cell pointers
|
||||
@@ -109,9 +118,29 @@ template <class T> DWORD worker(LPVOID args) {
|
||||
Array<T*> parents = make_array<T*>(npar);
|
||||
Array<T*> children = make_array<T*>(nchild);
|
||||
|
||||
TimeSpan start_algo = now();
|
||||
TimeSpan start;
|
||||
bool gt = strat.higher_fitness_is_better; // Writing strat.higher... is annoying
|
||||
|
||||
// printf("Core: %d\n", get_affinity());
|
||||
|
||||
TimeSpan start, diff, gen_start;
|
||||
while(stats.gen < strat.num_generations) {
|
||||
gen_start = now();
|
||||
|
||||
// 0. Share/Integrate global breakthrough
|
||||
if (strat.share_breakthroughs && (stats.gen + get_affinity()) % strat.share_breakthrough_gen_period) {
|
||||
lock(best_m);
|
||||
if (better(gt, front(trackers).score, *best_global_score) != *best_global_score) {
|
||||
// Share
|
||||
*best_global_cell = *_cellp(cells, trackers[0]);
|
||||
*best_global_score = trackers[0].score;
|
||||
|
||||
} else {
|
||||
// Integrate
|
||||
*_cellp(cells, trackers[0]) = *best_global_cell;
|
||||
trackers[0].score = *best_global_score;
|
||||
}
|
||||
unlock(best_m);
|
||||
}
|
||||
|
||||
// 1. crossover
|
||||
start = now();
|
||||
@@ -119,14 +148,19 @@ template <class T> DWORD worker(LPVOID args) {
|
||||
int parent_end = npar;
|
||||
int child_begin = trackers.len-nchild;
|
||||
while (parent_end <= child_begin) {
|
||||
|
||||
// Get pointers to all the parent cells
|
||||
for (int i = parent_end-npar; i < parent_end; i++) {
|
||||
parents[i - (parent_end-npar)] = _cellp(cells, trackers[i]);
|
||||
T* cell = _cellp(cells, trackers[i]);
|
||||
assert(cell != NULL);
|
||||
parents[i - (parent_end-npar)] = cell;
|
||||
}
|
||||
|
||||
// Get pointers to all the child cells (these will be overwritten)
|
||||
for (int i = child_begin; i < child_begin+nchild; i++) {
|
||||
children[i-child_begin] = _cellp(cells, trackers[i]);
|
||||
T* cell = _cellp(cells, trackers[i]);
|
||||
assert(cell != NULL);
|
||||
children[i-child_begin] = cell;
|
||||
}
|
||||
strat.crossover(parents, children);
|
||||
parent_end += strat.crossover_parent_stride;
|
||||
@@ -134,8 +168,7 @@ template <class T> DWORD worker(LPVOID args) {
|
||||
}
|
||||
}
|
||||
lock(stats.m);
|
||||
stats.total_crossover_time = stats.total_crossover_time + (now() - start);
|
||||
stats.total_crossovers++;
|
||||
append(stats.crossover_time, now() - start);
|
||||
unlock(stats.m);
|
||||
|
||||
|
||||
@@ -147,8 +180,7 @@ template <class T> DWORD worker(LPVOID args) {
|
||||
}
|
||||
}
|
||||
lock(stats.m);
|
||||
stats.total_mutate_time = stats.total_mutate_time + (now() - start);
|
||||
stats.total_mutates++;
|
||||
append(stats.mutate_time, now() - start);
|
||||
unlock(stats.m);
|
||||
|
||||
// 3. evaluate
|
||||
@@ -165,67 +197,63 @@ template <class T> DWORD worker(LPVOID args) {
|
||||
}
|
||||
}
|
||||
lock(stats.m);
|
||||
stats.total_fitness_time = stats.total_fitness_time + (now() - start);
|
||||
stats.total_evaluations++;
|
||||
append(stats.fitness_time, now() - start);
|
||||
unlock(stats.m);
|
||||
|
||||
// 4. sort
|
||||
start = now();
|
||||
std::sort(&trackers[0], &trackers[trackers.len-1], [strat](CellTracker &a, CellTracker &b){ return strat.higher_fitness_is_better ? a.score > b.score : a.score < b.score; });
|
||||
std::sort(&trackers[0], &trackers[trackers.len-1], [strat](CellTracker &a, CellTracker &b){ return better(strat.higher_fitness_is_better, a.score, b.score) == a.score; });
|
||||
lock(stats.m);
|
||||
stats.total_sorting_time = stats.total_sorting_time + (now() - start);
|
||||
stats.total_sorts++;
|
||||
append(stats.sorting_time, now() - start);
|
||||
|
||||
append(stats.best_cells, cells[trackers[0].cellid]);
|
||||
append(stats.best_cell_fitness, trackers[0].score);
|
||||
append(stats.gen_time, now() - gen_start);
|
||||
stats.gen++;
|
||||
unlock(stats.m);
|
||||
}
|
||||
stats.done = true;
|
||||
stats.end = now();
|
||||
return 0;
|
||||
}
|
||||
|
||||
template <class T> T run(Strategy<T> strat) {
|
||||
Array<Stats<T>> stats = make_array<Stats<T>>(strat.num_threads);
|
||||
Array<Thread> threads = make_array<Thread>(strat.num_threads);
|
||||
Array<T> cells = make_array<T>(strat.num_threads*strat.num_cells_per_thread);
|
||||
Array<CellTracker> trackers = make_array<CellTracker>(cells.len);
|
||||
|
||||
Array<WorkerThreadArgs<T>> args = make_array<WorkerThreadArgs<T>>(strat.num_threads);
|
||||
|
||||
for (int i = 0; i < cells.len; i++) {
|
||||
cells[i] = strat.make_default_cell();
|
||||
trackers[i] = {0, i};
|
||||
}
|
||||
float best_global_score = strat.higher_fitness_is_better ? FLT_MIN : FLT_MAX;
|
||||
T best_global_cell;
|
||||
|
||||
allow_all_processors();
|
||||
set_affinity(0);
|
||||
|
||||
for (int i = 0; i < strat.num_threads; i++) {
|
||||
stats[i] = {
|
||||
.best_cells=make_dynarray<T>(strat.num_generations),
|
||||
.best_cell_fitness=make_dynarray<float>(strat.num_generations),
|
||||
.gen=0,
|
||||
.done=false,
|
||||
.start=from_s(0),
|
||||
.end=from_s(0),
|
||||
.total_crossover_time=from_s(0),
|
||||
.total_crossovers=0,
|
||||
.total_mutate_time=from_s(0),
|
||||
.total_mutates=0,
|
||||
.total_fitness_time=from_s(0),
|
||||
.total_evaluations=0,
|
||||
.total_sorting_time=from_s(0),
|
||||
.total_sorts=0,
|
||||
.gen_time=make_dynarray<TimeSpan>(strat.num_generations),
|
||||
.crossover_time=make_dynarray<TimeSpan>(strat.num_generations),
|
||||
.mutate_time=make_dynarray<TimeSpan>(strat.num_generations),
|
||||
.fitness_time=make_dynarray<TimeSpan>(strat.num_generations),
|
||||
.sorting_time=make_dynarray<TimeSpan>(strat.num_generations),
|
||||
.m=make_mutex()
|
||||
};
|
||||
Array<T> tcells = { &cells[i*strat.num_cells_per_thread], strat.num_cells_per_thread };
|
||||
Array<CellTracker> ttrackers = { &trackers[i*strat.num_cells_per_thread], strat.num_cells_per_thread };
|
||||
Array<T> cells = make_array<T>(strat.num_threads*strat.num_cells_per_thread);
|
||||
Array<CellTracker> trackers = make_array<CellTracker>(strat.num_cells_per_thread);
|
||||
for (int i = 0; i < strat.num_cells_per_thread; i++) {
|
||||
cells[i] = strat.make_default_cell();
|
||||
trackers[i] = {0, i};
|
||||
}
|
||||
|
||||
args[i].strat=strat;
|
||||
args[i].cells=tcells;
|
||||
args[i].trackers=ttrackers;
|
||||
args[i].cells=cells;
|
||||
args[i].trackers=trackers;
|
||||
args[i].stats=&stats[i];
|
||||
args[i].best_global_score=&best_global_score;
|
||||
args[i].best_global_cell=&best_global_cell;
|
||||
args[i].m = make_mutex();
|
||||
|
||||
threads[i] = make_thread(worker<T>, &args[i]);
|
||||
threads[i] = make_thread(worker<T>, &args[i], i+1);
|
||||
}
|
||||
|
||||
// We are the stats thread
|
||||
@@ -234,12 +262,14 @@ template <class T> T run(Strategy<T> strat) {
|
||||
sleep(from_s(strat.stats_print_period_s));
|
||||
|
||||
printf("**********************\n");
|
||||
float g_avg_gen_time = 0;
|
||||
float g_avg_crossover_time = 0;
|
||||
float g_avg_mutate_time = 0;
|
||||
float g_avg_fitness_time = 0;
|
||||
float g_avg_sorting_time = 0;
|
||||
float g_avg_overhead_time = 0;
|
||||
float g_progress_per = 0;
|
||||
float g_best_fitness = strat.higher_fitness_is_better ? 0.0 : 999999999999999999.9;
|
||||
float g_best_fitness = strat.higher_fitness_is_better ? FLT_MIN : FLT_MAX;
|
||||
|
||||
complete = true;
|
||||
|
||||
@@ -247,43 +277,57 @@ template <class T> T run(Strategy<T> strat) {
|
||||
lock(stats[i].m);
|
||||
complete &= stats[i].done;
|
||||
|
||||
float avg_crossover_time = to_s(stats[i].total_crossover_time) / static_cast<float>(stats[i].total_crossovers);
|
||||
|
||||
float avg_mutate_time = to_s(stats[i].total_mutate_time) / static_cast<float>(stats[i].total_mutates);
|
||||
|
||||
float avg_fitness_time = to_s(stats[i].total_fitness_time) / static_cast<float>(stats[i].total_evaluations);
|
||||
|
||||
float avg_sorting_time = to_s(stats[i].total_sorting_time) / static_cast<float>(stats[i].total_sorts);
|
||||
int end = stats[i].gen_time.end-1;
|
||||
|
||||
float gen_time = to_s(stats[i].gen_time[end]);
|
||||
float crossover_time = to_s(stats[i].crossover_time[end]);
|
||||
float mutate_time = to_s(stats[i].mutate_time[end]);
|
||||
float fitness_time = to_s(stats[i].fitness_time[end]);
|
||||
float sorting_time = to_s(stats[i].sorting_time[end]);
|
||||
float progress_per = static_cast<float>(stats[i].gen) / static_cast<float>(strat.num_generations) * 100;
|
||||
|
||||
float best_score = back(stats[i].best_cell_fitness);
|
||||
|
||||
g_avg_crossover_time += avg_crossover_time;
|
||||
g_avg_mutate_time += avg_mutate_time;
|
||||
g_avg_fitness_time += avg_fitness_time;
|
||||
g_avg_sorting_time += avg_sorting_time;
|
||||
g_progress_per += progress_per;
|
||||
g_best_fitness = strat.higher_fitness_is_better ? max(best_score, g_best_fitness) : min(best_score, g_best_fitness);
|
||||
float overhead = max(0, gen_time - (crossover_time + mutate_time + fitness_time + sorting_time));
|
||||
|
||||
printf("THREAD %d, Progress %.1f\%, Top Score %.5e, Cross %.5f (s), Mutate: %.5f (s), Fitness: %.5f (s), Sorting: %.5f (s)\n", i, progress_per, best_score, avg_crossover_time, avg_mutate_time, avg_fitness_time, avg_sorting_time);
|
||||
float overhead_per = overhead / gen_time * 100;
|
||||
|
||||
g_avg_gen_time += gen_time;
|
||||
g_avg_crossover_time += crossover_time;
|
||||
g_avg_mutate_time += mutate_time;
|
||||
g_avg_fitness_time += fitness_time;
|
||||
g_avg_sorting_time += sorting_time;
|
||||
g_progress_per += progress_per;
|
||||
g_best_fitness = better(strat.higher_fitness_is_better, best_score, g_best_fitness);
|
||||
|
||||
g_avg_overhead_time += overhead;
|
||||
|
||||
printf("%d, Progress %d/%d, Top: %.5e, Overhead Per: %.4f%%, Gen: %.4f, Overhead: %.4f, Cross: %.4f (s), Mutate: %.4f (s), Fitness: %.4f (s), Sorting: %.4f (s)\n", i, stats[i].gen, strat.num_generations, best_score, overhead_per, gen_time, overhead, crossover_time, mutate_time, fitness_time, sorting_time);
|
||||
unlock(stats[i].m);
|
||||
}
|
||||
|
||||
g_avg_gen_time /= stats.len;
|
||||
g_avg_crossover_time /= stats.len;
|
||||
g_avg_mutate_time /= stats.len;
|
||||
g_avg_fitness_time /= stats.len;
|
||||
g_avg_sorting_time /= stats.len;
|
||||
g_progress_per /= stats.len;
|
||||
|
||||
printf("OVERALL, Progress %.1f\%, Top Score: %.5e, Cross %.5f (s), Mutate: %.5f (s), Fitness: %.5f (s), Sorting: %.5f (s)\n", g_progress_per, g_best_fitness, g_avg_crossover_time, g_avg_mutate_time, g_avg_fitness_time, g_avg_sorting_time);
|
||||
g_avg_overhead_time /= stats.len;
|
||||
|
||||
float g_avg_overhead_per = g_avg_overhead_time / g_avg_gen_time * 100;
|
||||
|
||||
printf("GLOBAL, Progress %.1f%%, Top: %.5e, Overhead Per: %.4f%%, Gen: %.4f, Overhead: %.4f, Cross: %.4f (s), Mutate: %.4f (s), Fitness: %.4f (s), Sorting: %.4f (s)\n", g_progress_per, g_best_fitness, g_avg_overhead_per, g_avg_gen_time, g_avg_overhead_time, g_avg_crossover_time, g_avg_mutate_time, g_avg_fitness_time, g_avg_sorting_time);
|
||||
|
||||
if (complete) break;
|
||||
}
|
||||
|
||||
for (int i = 0; i < threads.len; i++) {
|
||||
join(threads[i]);
|
||||
}
|
||||
|
||||
T best_cell;
|
||||
// TODO: bad
|
||||
float best_score = strat.higher_fitness_is_better ? 0.0 : 999999999999999999.9;
|
||||
float best_score = strat.higher_fitness_is_better ? FLT_MIN : FLT_MAX;
|
||||
for (int i = 0; i < stats.len; i++) {
|
||||
float score = back(stats[i].best_cell_fitness);
|
||||
if (strat.higher_fitness_is_better ? score > best_score : score < best_score) {
|
||||
|
||||
Reference in New Issue
Block a user