void driver_core_deinit(driver_core_t *core) {
assert(core);
unix_socket_server_deinit(&core->uss);
vector_deinit(&core->payload->commands);
avl_tree_purge(&core->connection_state);
if (core->greeting)
free(core->greeting);
if (core->path) {
unlink(core->path);
free(core->path);
}
}
/**
* @brief Evaluates the function, increases the number of evaluations and outputs information based on the
* observer options.
*/
static void logger_biobj_evaluate(coco_problem_t *problem, const double *x, double *y) {
logger_biobj_data_t *logger;
logger_biobj_avl_item_t *node_item;
logger_biobj_indicator_t *indicator;
avl_node_t *solution;
int update_performed;
size_t i;
logger = (logger_biobj_data_t *) coco_problem_transformed_get_data(problem);
/* Evaluate function */
coco_evaluate_function(coco_problem_transformed_get_inner_problem(problem), x, y);
logger->number_of_evaluations++;
/* Update the archive with the new solution, if it is not dominated by or equal to existing solutions in
* the archive */
node_item = logger_biobj_node_create(x, y, logger->number_of_evaluations, logger->number_of_variables,
logger->number_of_objectives);
update_performed = logger_biobj_tree_update(logger, coco_problem_transformed_get_inner_problem(problem),
node_item);
/* If the archive was updated and you need to log all nondominated solutions, output the new solution to
* nondom_file */
if (update_performed && (logger->log_nondom_mode == LOG_NONDOM_ALL)) {
logger_biobj_tree_output(logger->archive_file, logger->buffer_tree, logger->number_of_variables,
logger->number_of_objectives, logger->log_vars, logger->precision_x, logger->precision_f);
avl_tree_purge(logger->buffer_tree);
/* Flush output so that impatient users can see progress. */
fflush(logger->archive_file);
}
/* Perform output to the:
* - dat file, if the archive was updated and a new target was reached for an indicator;
* - tdat file, if the number of evaluations matches one of the predefined numbers.
*
* Note that a target is reached when the (best_value - current_value) <= relative_target_value
* The relative_target_value is a target for indicator difference, not indicator value!
*/
if (logger->compute_indicators) {
for (i = 0; i < OBSERVER_BIOBJ_NUMBER_OF_INDICATORS; i++) {
indicator = logger->indicators[i];
indicator->target_hit = 0;
/* If the update was performed, update the overall indicator value */
if (update_performed) {
/* Compute the overall_value of an indicator */
if (strcmp(indicator->name, "hyp") == 0) {
if (indicator->current_value == 0) {
/* The additional penalty for hypervolume is the minimal distance from the nondominated set to the ROI */
indicator->additional_penalty = DBL_MAX;
if (logger->archive_tree->tail) {
solution = logger->archive_tree->head;
while (solution != NULL) {
double distance = mo_get_distance_to_ROI(((logger_biobj_avl_item_t*) solution->item)->y,
problem->best_value, problem->nadir_value, problem->number_of_objectives);
indicator->additional_penalty = coco_double_min(indicator->additional_penalty, distance);
solution = solution->next;
}
}
assert(indicator->additional_penalty >= 0);
} else {
indicator->additional_penalty = 0;
}
indicator->overall_value = indicator->best_value - indicator->current_value
+ indicator->additional_penalty;
} else {
coco_error("logger_biobj_evaluate(): Indicator computation not implemented yet for indicator %s",
indicator->name);
}
/* Check whether a target was hit */
while ((indicator->next_target_id < MO_NUMBER_OF_TARGETS)
&& (indicator->overall_value <= mo_relateive_target_values[indicator->next_target_id])) {
/* A target was hit */
indicator->target_hit = 1;
if (indicator->next_target_id + 1 < MO_NUMBER_OF_TARGETS)
indicator->next_target_id++;
else
break;
}
}
/* Log to the dat file if a target was hit */
if (indicator->target_hit) {
fprintf(indicator->dat_file, "%lu\t%.*e\t%.*e\n", logger->number_of_evaluations, logger->precision_f,
indicator->overall_value, logger->precision_f,
mo_relateive_target_values[indicator->next_target_id - 1]);
}
/* Log to the tdat file if the number of evaluations matches one of the predefined numbers */
if (coco_observer_evaluation_to_log(logger->number_of_evaluations, logger->number_of_variables)) {
fprintf(indicator->tdat_file, "%lu\t%.*e\n", logger->number_of_evaluations, logger->precision_f,
indicator->overall_value);
}
}
}
}
void
master_deinit_(master_t *m) {
timer_deinit(&m->tmr);
avl_tree_purge(&m->slaves);
}
int main(int argc, char **argv) {
avl_tree_t *t;
avl_node_t *c;
char *s, *n;
char *ob, *bb, *eb;
int r, bs;
int l, u;
struct stat st;
int mmapped = 0;
t = avl_tree_malloc((avl_cmp_t)strcmp, NULL);
/* t = avl_tree_malloc((avl_cmp_t)avl_pointer_cmp, NULL); */
u = 0;
if(!fstat(STDIN_FILENO, &st) && S_ISREG(st.st_mode)) {
bs = st.st_size;
bb = eb = mmap(NULL, bs+1, PROT_READ|PROT_WRITE, MAP_PRIVATE, STDIN_FILENO, 0);
if(bb) {
mmapped = 1;
eb = bb+bs;
} else {
bb = eb = malloc(bs+1);
if(!bb) {
perror("malloc()");
exit(2);
}
while(bs > 0) {
r = read(STDIN_FILENO, eb, bs);
if(r <= 0) {
perror("moo");
exit(2);
}
eb += r;
bs -= r;
}
}
} else {
bs = 65536;
r = 0;
bb = eb = ob = malloc(bs);
if(!bb) {
perror("malloc()");
exit(2);
}
for(;;) {
eb += r;
r = read(STDIN_FILENO, eb, 65536);
if(r < 0) {
perror("moo");
exit(2);
}
if(r == 0)
break;
bb = realloc(ob = bb, bs += r);
if(!bb) {
fprintf(stderr, "realloc() to %d bytes failed.\n", bs);
exit(2);
}
if(bb != ob) {
eb += bb - ob;
u++;
}
}
}
if(*(eb-1) != '\n')
*eb++ = '\n';
bs = eb - bb;
bb = s = mmapped?(ob=bb):realloc(ob = bb, bs);
if(bb != ob)
u++;
eb = bb + bs;
if(mmapped)
fprintf(stderr, "Finished reading input (mmap()ed)\n");
else
fprintf(stderr, "Finished reading input (%d relocations)\n", u);
l = 0;
for(n = s = bb; s<eb; s = n) {
n = strchr(n, '\n');
*n++ = '\0';
avl_item_insert_somewhere(t, s);
l++;
}
fprintf(stderr, "Inserted %d lines\n", l);
l = 0;
for(c = t->head; c; c = c->next) {
puts(c->item);
l++;
}
fprintf(stderr, "Wrote %d lines, depth %d\n", l, t->top?t->top->depth:0);
for(; l; l--)
avl_delete(t, t->top);
if(!t->top) fprintf(stderr, "Deleted all lines\n");
avl_tree_purge(t);
return 0;
}
