/* This file is part of GNUnet. Copyright (C) 2010-2013 GNUnet e.V. GNUnet is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. GNUnet 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 Affero General Public License for more details. You should have received a copy of the GNU Affero General Public License along with this program. If not, see . SPDX-License-Identifier: AGPL3.0-or-later */ /** * @file ats-tests/ats-testing-experiment.c * @brief ats benchmark: controlled experiment execution * @author Christian Grothoff * @author Matthias Wachs */ #include "platform.h" #include "gnunet_util_lib.h" #include "gnunet-ats-solver-eval.h" #include "gnunet-service-ats_normalization.h" #include "gnunet-service-ats_preferences.c" #define BIG_M_STRING "unlimited" /** * Handle for statistics. */ struct GNUNET_STATISTICS_Handle *GSA_stats; static struct Experiment *e; static struct LoggingHandle *l; static struct SolverHandle *sh; static struct TestPeer *peer_head; static struct TestPeer *peer_tail; static double default_properties[GNUNET_ATS_PropertyCount]; static double default_preferences[GNUNET_ATS_PreferenceCount]; /** * cmd option -e: experiment file */ static char *opt_exp_file; static char *opt_solver; /** * cmd option -l: enable logging */ static int opt_log; /** * cmd option -p: enable plots */ static int opt_save; /** * cmd option -v: verbose logs */ static int opt_verbose; /** * cmd option -p: print logs */ static int opt_print; /** * cmd option -d: disable normalization */ static int opt_disable_normalization; static int res; static void end_now(); static char * print_generator_type(enum GeneratorType g) { switch (g) { case GNUNET_ATS_TEST_TG_CONSTANT: return "CONSTANT"; case GNUNET_ATS_TEST_TG_LINEAR: return "LINEAR"; case GNUNET_ATS_TEST_TG_RANDOM: return "RANDOM"; case GNUNET_ATS_TEST_TG_SINUS: return "SINUS"; default: return "INVALID"; break; } } static struct TestPeer * find_peer_by_id(int id) { struct TestPeer *cur; for (cur = peer_head; NULL != cur; cur = cur->next) if (cur->id == id) return cur; return NULL; } static struct TestPeer * find_peer_by_pid(const struct GNUNET_PeerIdentity *pid) { struct TestPeer *cur; for (cur = peer_head; NULL != cur; cur = cur->next) if (0 == GNUNET_memcmp(&cur->peer_id, pid)) return cur; return NULL; } static struct TestAddress * find_address_by_id(struct TestPeer *peer, int aid) { struct TestAddress *cur; for (cur = peer->addr_head; NULL != cur; cur = cur->next) if (cur->aid == aid) return cur; return NULL; } /** * Logging */ void GNUNET_ATS_solver_logging_now(struct LoggingHandle *l) { struct LoggingTimeStep *lts; struct TestPeer *cur; struct TestAddress *cur_addr; struct LoggingPeer *log_p; struct LoggingAddress *log_a; int c; lts = GNUNET_new(struct LoggingTimeStep); GNUNET_CONTAINER_DLL_insert_tail(l->head, l->tail, lts); lts->timestamp = GNUNET_TIME_absolute_get(); if (NULL == lts->prev) lts->delta = GNUNET_TIME_UNIT_ZERO; else lts->delta = GNUNET_TIME_absolute_get_duration(lts->prev->timestamp); GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Logging %llu, delta %llu\n", lts->timestamp.abs_value_us, lts->delta.rel_value_us); /* Store logging data here */ for (cur = peer_head; NULL != cur; cur = cur->next) { GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Logging peer id %llu\n", cur->id); log_p = GNUNET_new(struct LoggingPeer); log_p->id = cur->id; log_p->peer_id = cur->peer_id; log_p->is_requested = cur->is_requested; for (c = 0; c < GNUNET_ATS_PreferenceCount; c++) { log_p->pref_abs[c] = cur->pref_abs[c]; log_p->pref_norm[c] = cur->pref_norm[c]; GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "\t %s = %.2f %.2f [abs/rel]\n", GNUNET_ATS_print_preference_type(c), log_p->pref_abs[c], log_p->pref_norm[c]); } GNUNET_CONTAINER_DLL_insert_tail(lts->head, lts->tail, log_p); for (cur_addr = cur->addr_head; NULL != cur_addr; cur_addr = cur_addr->next) { GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Logging peer id %llu address %llu\n", cur->id, cur_addr->aid); log_a = GNUNET_new(struct LoggingAddress); log_a->aid = cur_addr->aid; log_a->active = cur_addr->ats_addr->active; log_a->network = cur_addr->network; log_a->assigned_bw_in = cur_addr->ats_addr->assigned_bw_in; log_a->assigned_bw_out = cur_addr->ats_addr->assigned_bw_out; for (c = 0; c < GNUNET_ATS_PropertyCount; c++) { log_a->prop_abs[c] = cur_addr->prop_abs[c]; log_a->prop_norm[c] = cur_addr->prop_norm[c]; GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "\t %s = %.2f %.2f [abs/rel]\n", GNUNET_ATS_print_property_type(c), log_a->prop_abs[c], log_a->prop_norm[c]); } GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "\t Active = %i\n", log_a->active); GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "\t BW in = %llu\n", log_a->assigned_bw_in); GNUNET_log(GNUNET_ERROR_TYPE_INFO, "\t BW out = %llu\n", log_a->assigned_bw_out); GNUNET_CONTAINER_DLL_insert_tail(log_p->addr_head, log_p->addr_tail, log_a); } } } static void logging_task(void *cls) { struct LoggingHandle *l = cls; l->logging_task = NULL; GNUNET_ATS_solver_logging_now(l); l->logging_task = GNUNET_SCHEDULER_add_delayed(l->log_freq, &logging_task, l); } struct LoggingHandle * GNUNET_ATS_solver_logging_start(struct GNUNET_TIME_Relative freq) { struct LoggingHandle *l; l = GNUNET_new(struct LoggingHandle); GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Start logging every %s\n", GNUNET_STRINGS_relative_time_to_string(freq, GNUNET_NO)); l->log_freq = freq; l->logging_task = GNUNET_SCHEDULER_add_now(&logging_task, l); return l; } void GNUNET_ATS_solver_logging_stop(struct LoggingHandle *l) { if (NULL != l->logging_task) GNUNET_SCHEDULER_cancel(l->logging_task); GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Stop logging\n"); l->logging_task = NULL; } static struct LoggingFileHandle * find_logging_file_handle(struct LoggingFileHandle *lf_head, struct LoggingFileHandle *lf_tail, int peer_id, int address_id) { struct LoggingFileHandle *res; for (res = lf_head; NULL != res; res = res->next) if ((res->pid == peer_id) && (res->aid == address_id)) return res; return NULL; } void GNUNET_ATS_solver_logging_write_to_disk(struct LoggingHandle *l, int add_time_stamp, char *output_dir) { struct LoggingTimeStep *lts; struct LoggingPeer *log_p; struct LoggingAddress *log_a; struct LoggingFileHandle *lf_head; struct LoggingFileHandle *lf_tail; struct LoggingFileHandle *cur; struct LoggingFileHandle *next; char * filename; char * datastring; char * propstring; char * propstring_tmp; char * prefstring; char * prefstring_tmp; int c; int use_dir; use_dir = GNUNET_NO; if (NULL != output_dir) { if (GNUNET_OK != GNUNET_DISK_directory_create_for_file(output_dir)) { fprintf(stderr, "Failed to create directory `%s'\n", output_dir); return; } else { fprintf(stderr, "Created directory `%s'\n", output_dir); use_dir = GNUNET_YES; } } lf_head = NULL; lf_tail = NULL; for (lts = l->head; NULL != lts; lts = lts->next) { GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Writing log step %llu\n", (long long unsigned int)lts->timestamp.abs_value_us); for (log_p = lts->head; NULL != log_p; log_p = log_p->next) { for (log_a = log_p->addr_head; NULL != log_a; log_a = log_a->next) { cur = find_logging_file_handle(lf_head, lf_tail, log_p->id, log_a->aid); if (NULL == cur) { cur = GNUNET_new(struct LoggingFileHandle); cur->aid = log_a->aid; cur->pid = log_p->id; if (GNUNET_YES == add_time_stamp) GNUNET_asprintf(&filename, "%s%s%s_%s_p%u_a%u_%llu.log", (GNUNET_YES == use_dir) ? output_dir : "", (GNUNET_YES == use_dir) ? DIR_SEPARATOR_STR : "", e->log_prefix, opt_solver, cur->pid, cur->aid, l->head->timestamp.abs_value_us); else GNUNET_asprintf(&filename, "%s%s%s_%s_p%u_a%u.log", (GNUNET_YES == use_dir) ? output_dir : "", (GNUNET_YES == use_dir) ? DIR_SEPARATOR_STR : "", e->log_prefix, opt_solver, cur->pid, cur->aid); fprintf(stderr, "Add writing log data for peer %llu address %llu to file `%s'\n", cur->pid, cur->aid, filename); cur->f_hd = GNUNET_DISK_file_open(filename, GNUNET_DISK_OPEN_READWRITE | GNUNET_DISK_OPEN_CREATE | GNUNET_DISK_OPEN_TRUNCATE, GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE | GNUNET_DISK_PERM_GROUP_READ | GNUNET_DISK_PERM_OTHER_READ); if (NULL == cur->f_hd) { fprintf(stderr, "Cannot open `%s' to write log data!\n", filename); GNUNET_free(filename); GNUNET_free(cur); goto cleanup; } GNUNET_free(filename); GNUNET_CONTAINER_DLL_insert(lf_head, lf_tail, cur); GNUNET_asprintf(&datastring, "#time delta;log duration;peer_requested;addr net; addr_active; bw in; bw out; " \ "UTILIZATION_UP [abs/rel]; UTILIZATION_UP; UTILIZATION_DOWN; UTILIZATION_DOWN; " \ "UTILIZATION_PAYLOAD_UP; UTILIZATION_PAYLOAD_UP; UTILIZATION_PAYLOAD_DOWN; UTILIZATION_PAYLOAD_DOWN;" \ "DELAY; DELAY; " \ "DISTANCE ;DISTANCE ; COST_WAN; COST_WAN; COST_LAN; COST_LAN; " \ "COST_WLAN; COST_WLAN;COST_BT; COST_BT; PREF BW abs; PREF BW rel; PREF LATENCY abs; PREF LATENCY rel;\n"); GNUNET_DISK_file_write(cur->f_hd, datastring, strlen(datastring)); GNUNET_free(datastring); } prefstring = GNUNET_strdup(""); for (c = 1; c < GNUNET_ATS_PreferenceCount; c++) { /* fprintf(stderr,"\t %s = %.2f %.2f [abs/rel]\n", GNUNET_ATS_print_preference_type(c), log_p->pref_abs[c], log_p->pref_norm[c]); */ GNUNET_asprintf(&prefstring_tmp, "%s;%.3f;%.3f", prefstring, log_p->pref_abs[c], log_p->pref_norm[c]); GNUNET_free(prefstring); prefstring = GNUNET_strdup(prefstring_tmp); GNUNET_free(prefstring_tmp); } propstring = GNUNET_strdup(""); for (c = 1; c < GNUNET_ATS_PropertyCount; c++) { if (GNUNET_ATS_NETWORK_TYPE == c) continue; /* fprintf(stderr, "\t %s = %.2f %.2f [abs/rel]\n", GNUNET_ATS_print_property_type(c), log_a->prop_abs[c], log_a->prop_norm[c]);*/ GNUNET_asprintf(&propstring_tmp, "%s%.3f;%.3f;", propstring, log_a->prop_abs[c], log_a->prop_norm[c]); GNUNET_free(propstring); propstring = GNUNET_strdup(propstring_tmp); GNUNET_free(propstring_tmp); } GNUNET_asprintf(&datastring, "%llu;%llu;%u;%u;%i;%u;%u;%s;%s\n", GNUNET_TIME_absolute_get_difference(l->head->timestamp, lts->timestamp).rel_value_us / 1000, lts->delta, log_p->is_requested, log_a->network, log_a->active, log_a->assigned_bw_in, log_a->assigned_bw_out, propstring, prefstring); GNUNET_DISK_file_write(cur->f_hd, datastring, strlen(datastring)); GNUNET_free(datastring); GNUNET_free(prefstring); GNUNET_free(propstring); } } } cleanup: next = lf_head; for (cur = next; NULL != cur; cur = next) { next = cur->next; GNUNET_CONTAINER_DLL_remove(lf_head, lf_tail, cur); if (NULL != cur->f_hd) GNUNET_DISK_file_close(cur->f_hd); GNUNET_free(cur); } } void GNUNET_ATS_solver_logging_eval(struct LoggingHandle *l) { struct LoggingTimeStep *lts; struct LoggingPeer *log_p; struct LoggingAddress *log_a; int c; for (lts = l->head; NULL != lts; lts = lts->next) { fprintf(stderr, "Log step %llu %llu: \n", (long long unsigned int)lts->timestamp.abs_value_us, (long long unsigned int)lts->delta.rel_value_us); for (log_p = lts->head; NULL != log_p; log_p = log_p->next) { fprintf(stderr, "\tLogging peer pid %llu\n", log_p->id); for (c = 1; c < GNUNET_ATS_PreferenceCount; c++) { fprintf(stderr, "\t %s = %.2f %.2f [abs/rel]\n", GNUNET_ATS_print_preference_type(c), log_p->pref_abs[c], log_p->pref_norm[c]); } for (log_a = log_p->addr_head; NULL != log_a; log_a = log_a->next) { fprintf(stderr, "\tPeer pid %llu address %llu: %u %u %u\n", log_p->id, log_a->aid, log_a->active, log_a->assigned_bw_in, log_a->assigned_bw_out); for (c = 1; c < GNUNET_ATS_PropertyCount; c++) { if (GNUNET_ATS_NETWORK_TYPE == c) continue; fprintf(stderr, "\t %s = %.2f %.2f [abs/rel]\n", GNUNET_ATS_print_property_type(c), log_a->prop_abs[c], log_a->prop_norm[c]); } } } } } void GNUNET_ATS_solver_logging_free(struct LoggingHandle *l) { struct LoggingTimeStep *lts_cur; struct LoggingTimeStep *lts_next; struct LoggingPeer *log_p_cur; struct LoggingPeer *log_p_next; struct LoggingAddress *log_a_cur; struct LoggingAddress *log_a_next; if (NULL != l->logging_task) GNUNET_SCHEDULER_cancel(l->logging_task); l->logging_task = NULL; lts_next = l->head; while (NULL != (lts_cur = lts_next)) { lts_next = lts_cur->next; log_p_next = lts_cur->head; while (NULL != (log_p_cur = log_p_next)) { log_p_next = log_p_cur->next; log_a_next = log_p_cur->addr_head; while (NULL != (log_a_cur = log_a_next)) { log_a_next = log_a_cur->next; GNUNET_CONTAINER_DLL_remove(log_p_cur->addr_head, log_p_cur->addr_tail, log_a_cur); GNUNET_free(log_a_cur); } GNUNET_CONTAINER_DLL_remove(lts_cur->head, lts_cur->tail, log_p_cur); GNUNET_free(log_p_cur); } GNUNET_CONTAINER_DLL_remove(l->head, l->tail, lts_cur); GNUNET_free(lts_cur); } GNUNET_free(l); } /** * Property Generators */ static struct PropertyGenerator *prop_gen_head; static struct PropertyGenerator *prop_gen_tail; static double get_property(struct PropertyGenerator *pg) { struct GNUNET_TIME_Relative time_delta; double delta_value; double pref_value; /* Calculate the current preference value */ switch (pg->type) { case GNUNET_ATS_TEST_TG_CONSTANT: pref_value = pg->base_value; break; case GNUNET_ATS_TEST_TG_LINEAR: time_delta = GNUNET_TIME_absolute_get_duration(pg->time_start); /* Calculate point of time in the current period */ time_delta.rel_value_us = time_delta.rel_value_us % pg->duration_period.rel_value_us; delta_value = ((double)time_delta.rel_value_us / pg->duration_period.rel_value_us) * (pg->max_value - pg->base_value); if ((pg->max_value < pg->base_value) && ((pg->max_value - pg->base_value) > pg->base_value)) { /* This will cause an underflow */ GNUNET_break(0); } pref_value = pg->base_value + delta_value; break; case GNUNET_ATS_TEST_TG_RANDOM: delta_value = (double)GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 10000 * (pg->max_value - pg->base_value)) / 10000; pref_value = pg->base_value + delta_value; break; case GNUNET_ATS_TEST_TG_SINUS: time_delta = GNUNET_TIME_absolute_get_duration(pg->time_start); /* Calculate point of time in the current period */ time_delta.rel_value_us = time_delta.rel_value_us % pg->duration_period.rel_value_us; if ((pg->max_value - pg->base_value) > pg->base_value) { /* This will cause an underflow for second half of sinus period, * will be detected in general when experiments are loaded */ GNUNET_break(0); } delta_value = (pg->max_value - pg->base_value) * sin((2 * M_PI) / ((double)pg->duration_period.rel_value_us) * time_delta.rel_value_us); pref_value = pg->base_value + delta_value; break; default: pref_value = 0.0; break; } GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Current property value is %f\n", pref_value); return pref_value; } static void set_prop_task(void *cls) { struct PropertyGenerator *pg = cls; struct TestPeer *p; struct TestAddress *a; double prop_value; struct GNUNET_ATS_Information atsi; pg->set_task = NULL; if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains_value(sh->addresses, &pg->test_peer->peer_id, pg->test_address->ats_addr)) { GNUNET_break(0); GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Setting property generation for unknown address [%u:%u]\n", pg->peer, pg->address_id); return; } if (NULL == (p = find_peer_by_id(pg->peer))) { GNUNET_break(0); GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Setting property generation for unknown peer %u\n", pg->peer); return; } if (NULL == (a = find_address_by_id(p, pg->address_id))) { GNUNET_break(0); GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Setting property generation for unknown peer %u\n", pg->peer); return; } prop_value = get_property(pg); a->prop_abs[pg->ats_property] = prop_value; GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Setting property for peer [%u] address [%u] for %s to %f\n", pg->peer, pg->address_id, GNUNET_ATS_print_property_type(pg->ats_property), prop_value); atsi.type = htonl(pg->ats_property); atsi.value = htonl((uint32_t)prop_value); /* set performance here! */ sh->sf->s_bulk_start(sh->sf->cls); if (GNUNET_YES == opt_disable_normalization) { a->prop_abs[pg->ats_property] = prop_value; a->prop_norm[pg->ats_property] = prop_value; sh->sf->s_address_update_property(sh->sf->cls, a->ats_addr, pg->ats_property, prop_value, prop_value); } else GAS_normalization_update_property(pg->test_address->ats_addr, &atsi, 1); sh->sf->s_bulk_stop(sh->sf->cls); pg->set_task = GNUNET_SCHEDULER_add_delayed(pg->frequency, &set_prop_task, pg); } /** * Set ats_property to 0 to find all pgs */ static struct PropertyGenerator * find_prop_gen(unsigned int peer, unsigned int address, uint32_t ats_property) { struct PropertyGenerator *cur; for (cur = prop_gen_head; NULL != cur; cur = cur->next) if ((cur->peer == peer) && (cur->address_id == address)) { if ((cur->ats_property == ats_property) || (0 == ats_property)) return cur; } return NULL; } void GNUNET_ATS_solver_generate_property_stop(struct PropertyGenerator *pg) { GNUNET_CONTAINER_DLL_remove(prop_gen_head, prop_gen_tail, pg); if (NULL != pg->set_task) { GNUNET_SCHEDULER_cancel(pg->set_task); pg->set_task = NULL; } GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Removing old up preference generator peer [%u] address [%u] `%s'\n", pg->peer, pg->address_id, GNUNET_ATS_print_property_type(pg->ats_property)); GNUNET_free(pg); } /** * Generate between the source master and the partner and set property with a * value depending on the generator. * * @param peer source * @param address_id partner * @param test_peer the peer * @param test_address the address * @param type type of generator * @param base_value base value * @param value_rate maximum value * @param period duration of a period of generation (~ 1/frequency) * @param frequency how long to generate property * @param ats_property ATS property to generate * @return the property generator */ struct PropertyGenerator * GNUNET_ATS_solver_generate_property_start(unsigned int peer, unsigned int address_id, struct TestPeer *test_peer, struct TestAddress *test_address, enum GeneratorType type, long int base_value, long int value_rate, struct GNUNET_TIME_Relative period, struct GNUNET_TIME_Relative frequency, uint32_t ats_property) { struct PropertyGenerator *pg; pg = GNUNET_new(struct PropertyGenerator); GNUNET_CONTAINER_DLL_insert(prop_gen_head, prop_gen_tail, pg); pg->type = type; pg->peer = peer; pg->test_address = test_address; pg->test_peer = test_peer; pg->address_id = address_id; pg->ats_property = ats_property; pg->base_value = base_value; pg->max_value = value_rate; pg->duration_period = period; pg->frequency = frequency; pg->time_start = GNUNET_TIME_absolute_get(); switch (type) { case GNUNET_ATS_TEST_TG_CONSTANT: GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Setting up %s property generator peer [%u] address [%u] `%s'" \ "max %u Bips\n", print_generator_type(type), pg->peer, pg->address_id, GNUNET_ATS_print_property_type(ats_property), base_value); break; case GNUNET_ATS_TEST_TG_LINEAR: GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Setting up %s property generator peer [%u] address [%u] `%s' " \ "min %u Bips max %u Bips\n", print_generator_type(type), pg->peer, pg->address_id, GNUNET_ATS_print_property_type(ats_property), base_value, value_rate); break; case GNUNET_ATS_TEST_TG_SINUS: GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Setting up %s property generator peer [%u] address [%u] `%s' " \ "baserate %u Bips, amplitude %u Bps\n", print_generator_type(type), pg->peer, pg->address_id, GNUNET_ATS_print_property_type(ats_property), base_value, value_rate); break; case GNUNET_ATS_TEST_TG_RANDOM: GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Setting up %s property generator peer [%u] address [%u] `%s' " \ "min %u Bips max %u Bps\n", print_generator_type(type), pg->peer, pg->address_id, GNUNET_ATS_print_property_type(ats_property), base_value, value_rate); break; default: break; } pg->set_task = GNUNET_SCHEDULER_add_now(&set_prop_task, pg); return pg; } /** * Stop all preferences generators */ void GNUNET_ATS_solver_generate_property_stop_all() { struct PropertyGenerator *cur; struct PropertyGenerator *next; next = prop_gen_head; for (cur = next; NULL != cur; cur = next) { next = cur->next; GNUNET_ATS_solver_generate_property_stop(cur); } } /** * Preference Generators */ static struct PreferenceGenerator *pref_gen_head; static struct PreferenceGenerator *pref_gen_tail; static double get_preference(struct PreferenceGenerator *pg) { struct GNUNET_TIME_Relative time_delta; double delta_value; double pref_value; /* Calculate the current preference value */ switch (pg->type) { case GNUNET_ATS_TEST_TG_CONSTANT: pref_value = pg->base_value; break; case GNUNET_ATS_TEST_TG_LINEAR: time_delta = GNUNET_TIME_absolute_get_duration(pg->time_start); /* Calculate point of time in the current period */ time_delta.rel_value_us = time_delta.rel_value_us % pg->duration_period.rel_value_us; delta_value = ((double)time_delta.rel_value_us / pg->duration_period.rel_value_us) * (pg->max_value - pg->base_value); if ((pg->max_value < pg->base_value) && ((pg->max_value - pg->base_value) > pg->base_value)) { /* This will cause an underflow */ GNUNET_break(0); } pref_value = pg->base_value + delta_value; break; case GNUNET_ATS_TEST_TG_RANDOM: delta_value = (double)GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 10000 * (pg->max_value - pg->base_value)) / 10000; pref_value = pg->base_value + delta_value; break; case GNUNET_ATS_TEST_TG_SINUS: time_delta = GNUNET_TIME_absolute_get_duration(pg->time_start); /* Calculate point of time in the current period */ time_delta.rel_value_us = time_delta.rel_value_us % pg->duration_period.rel_value_us; if ((pg->max_value - pg->base_value) > pg->base_value) { /* This will cause an underflow for second half of sinus period, * will be detected in general when experiments are loaded */ GNUNET_break(0); } delta_value = (pg->max_value - pg->base_value) * sin((2 * M_PI) / ((double)pg->duration_period.rel_value_us) * time_delta.rel_value_us); pref_value = pg->base_value + delta_value; break; default: pref_value = 0.0; break; } GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Current preference value is %f\n", pref_value); return pref_value; } static void set_feedback_task(void *cls) { struct PreferenceGenerator *pg = cls; struct TestPeer *p; double feedback; uint32_t bw_acc_out; uint32_t bw_acc_in; uint32_t delay_acc_in; struct GNUNET_TIME_Relative dur; double p_new; pg->feedback_task = NULL; if (NULL == (p = find_peer_by_id(pg->peer))) { GNUNET_break(0); GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Setting feedback for unknown peer %u\n", pg->peer); return; } switch (pg->kind) { case GNUNET_ATS_PREFERENCE_BANDWIDTH: dur = GNUNET_TIME_absolute_get_duration(pg->feedback_last_bw_update); bw_acc_in = dur.rel_value_us * pg->last_assigned_bw_in + pg->feedback_bw_in_acc; pg->feedback_bw_in_acc = 0; bw_acc_out = dur.rel_value_us * pg->last_assigned_bw_out + pg->feedback_bw_out_acc; p_new = get_preference(pg); feedback = (p_new / pg->pref_bw_old) * (bw_acc_in + bw_acc_out) / (2 * GNUNET_TIME_absolute_get_duration(pg->feedback_last).rel_value_us); break; case GNUNET_ATS_PREFERENCE_LATENCY: dur = GNUNET_TIME_absolute_get_duration(pg->feedback_last_delay_update); delay_acc_in = dur.rel_value_us * pg->last_delay_value + pg->feedback_delay_acc; pg->feedback_delay_acc = 0; p_new = get_preference(pg); feedback = (p_new / pg->pref_latency_old) * (delay_acc_in) / (GNUNET_TIME_absolute_get_duration(pg->feedback_last).rel_value_us); break; default: GNUNET_break(0); feedback = 0.0; break; } GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Giving feedback for peer [%u] for client %p pref %s of %.3f\n", pg->peer, NULL + (pg->client_id), GNUNET_ATS_print_preference_type(pg->kind), feedback); sh->sf->s_feedback(sh->sf->cls, NULL + (pg->client_id), &p->peer_id, pg->feedback_frequency, pg->kind, feedback); pg->feedback_last = GNUNET_TIME_absolute_get(); pg->feedback_bw_out_acc = 0; pg->feedback_bw_in_acc = 0; pg->feedback_last_bw_update = GNUNET_TIME_absolute_get(); pg->feedback_delay_acc = 0; pg->feedback_last_delay_update = GNUNET_TIME_absolute_get(); pg->feedback_task = GNUNET_SCHEDULER_add_delayed(pg->feedback_frequency, &set_feedback_task, pg); } static void set_pref_task(void *cls) { struct PreferenceGenerator *pg = cls; struct TestPeer *p; double pref_value; pg->set_task = NULL; if (NULL == (p = find_peer_by_id(pg->peer))) { GNUNET_break(0); GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Setting preference for unknown peer %u\n", pg->peer); return; } pref_value = get_preference(pg); switch (pg->kind) { case GNUNET_ATS_PREFERENCE_BANDWIDTH: pg->pref_bw_old = pref_value; break; case GNUNET_ATS_PREFERENCE_LATENCY: pg->pref_latency_old = pref_value; break; default: break; } p->pref_abs[pg->kind] = pref_value; GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Setting preference for peer [%u] for client %p pref %s to %f\n", pg->peer, NULL + (pg->client_id), GNUNET_ATS_print_preference_type(pg->kind), pref_value); if (GNUNET_YES == opt_disable_normalization) { p->pref_abs[pg->kind] = pref_value; p->pref_norm[pg->kind] = pref_value; sh->sf->s_pref(sh->sf->cls, &p->peer_id, pg->kind, pref_value); } else update_preference(NULL + (pg->client_id), &p->peer_id, pg->kind, pref_value); pg->set_task = GNUNET_SCHEDULER_add_delayed(pg->frequency, &set_pref_task, pg); } static struct PreferenceGenerator * find_pref_gen(unsigned int peer, enum GNUNET_ATS_PreferenceKind kind) { struct PreferenceGenerator *cur; for (cur = pref_gen_head; NULL != cur; cur = cur->next) if (cur->peer == peer) { if ((cur->kind == kind) || (GNUNET_ATS_PREFERENCE_END == kind)) return cur; } return NULL; } void GNUNET_ATS_solver_generate_preferences_stop(struct PreferenceGenerator *pg) { GNUNET_CONTAINER_DLL_remove(pref_gen_head, pref_gen_tail, pg); if (NULL != pg->feedback_task) { GNUNET_SCHEDULER_cancel(pg->feedback_task); pg->feedback_task = NULL; } if (NULL != pg->set_task) { GNUNET_SCHEDULER_cancel(pg->set_task); pg->set_task = NULL; } GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Removing old up preference generator peer [%u] `%s'\n", pg->peer, GNUNET_ATS_print_preference_type(pg->kind)); GNUNET_free(pg); } static struct TestAddress* find_active_address(struct TestPeer *p) { struct TestAddress *cur; for (cur = p->addr_head; NULL != cur; cur = cur->next) if (GNUNET_YES == cur->ats_addr->active) return cur; return NULL; } /** * Generate between the source master and the partner and set property with a * value depending on the generator. * * @param peer source * @param address_id partner * @param client_id the client * @param type type of generator * @param base_value base value * @param value_rate maximum value * @param period duration of a period of generation (~ 1/frequency) * @param frequency how long to generate property * @param kind ATS preference to generate * @param feedback_frequency how often to give feedback * @return the preference generator */ struct PreferenceGenerator * GNUNET_ATS_solver_generate_preferences_start(unsigned int peer, unsigned int address_id, unsigned int client_id, enum GeneratorType type, long int base_value, long int value_rate, struct GNUNET_TIME_Relative period, struct GNUNET_TIME_Relative frequency, enum GNUNET_ATS_PreferenceKind kind, struct GNUNET_TIME_Relative feedback_frequency) { struct PreferenceGenerator *pg; struct TestPeer *p; if (NULL == (p = find_peer_by_id(peer))) { GNUNET_break(0); GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Starting preference for unknown peer %u\n", peer); return NULL; } pg = GNUNET_new(struct PreferenceGenerator); GNUNET_CONTAINER_DLL_insert(pref_gen_head, pref_gen_tail, pg); pg->type = type; pg->peer = peer; pg->client_id = client_id; pg->kind = kind; pg->base_value = base_value; pg->max_value = value_rate; pg->duration_period = period; pg->frequency = frequency; pg->time_start = GNUNET_TIME_absolute_get(); pg->feedback_frequency = feedback_frequency; switch (type) { case GNUNET_ATS_TEST_TG_CONSTANT: GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Setting up %s preference generator peer [%u] `%s' max %u Bips\n", print_generator_type(type), pg->peer, GNUNET_ATS_print_preference_type(kind), base_value); break; case GNUNET_ATS_TEST_TG_LINEAR: GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Setting up %s preference generator peer [%u] `%s' min %u Bips max %u Bips\n", print_generator_type(type), pg->peer, GNUNET_ATS_print_preference_type(kind), base_value, value_rate); break; case GNUNET_ATS_TEST_TG_SINUS: GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Setting up %s preference generator peer [%u] `%s' baserate %u Bips, amplitude %u Bps\n", print_generator_type(type), pg->peer, GNUNET_ATS_print_preference_type(kind), base_value, value_rate); break; case GNUNET_ATS_TEST_TG_RANDOM: GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Setting up %s preference generator peer [%u] `%s' min %u Bips max %u Bps\n", print_generator_type(type), pg->peer, GNUNET_ATS_print_preference_type(kind), base_value, value_rate); break; default: break; } pg->set_task = GNUNET_SCHEDULER_add_now(&set_pref_task, pg); if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us != feedback_frequency.rel_value_us) { struct TestAddress * addr = find_active_address(p); pg->last_assigned_bw_in = p->assigned_bw_in; pg->last_assigned_bw_out = p->assigned_bw_out; pg->feedback_bw_in_acc = 0; pg->feedback_bw_out_acc = 0; pg->last_delay_value = addr->prop_norm[GNUNET_ATS_QUALITY_NET_DELAY]; pg->feedback_delay_acc = 0; pg->feedback_last_bw_update = GNUNET_TIME_absolute_get(); pg->feedback_last_delay_update = GNUNET_TIME_absolute_get(); pg->feedback_last = GNUNET_TIME_absolute_get(); pg->feedback_task = GNUNET_SCHEDULER_add_delayed(feedback_frequency, &set_feedback_task, pg); } return pg; } /** * Stop all preferences generators */ void GNUNET_ATS_solver_generate_preferences_stop_all() { struct PreferenceGenerator *cur; struct PreferenceGenerator *next; next = pref_gen_head; for (cur = next; NULL != cur; cur = next) { next = cur->next; GNUNET_ATS_solver_generate_preferences_stop(cur); } } /** * Experiments */ static const char * print_op(enum OperationType op) { switch (op) { case SOLVER_OP_ADD_ADDRESS: return "ADD_ADDRESS"; case SOLVER_OP_DEL_ADDRESS: return "DEL_ADDRESS"; case SOLVER_OP_START_SET_PREFERENCE: return "START_SET_PREFERENCE"; case SOLVER_OP_STOP_SET_PREFERENCE: return "STOP_STOP_PREFERENCE"; case SOLVER_OP_START_SET_PROPERTY: return "START_SET_PROPERTY"; case SOLVER_OP_STOP_SET_PROPERTY: return "STOP_SET_PROPERTY"; case SOLVER_OP_START_REQUEST: return "START_REQUEST"; case SOLVER_OP_STOP_REQUEST: return "STOP_REQUEST"; default: break; } return ""; } static struct Experiment * create_experiment() { struct Experiment *e; e = GNUNET_new(struct Experiment); e->name = NULL; e->start = NULL; e->total_duration = GNUNET_TIME_UNIT_ZERO; return e; } static void free_experiment(struct Experiment *e) { struct Episode *cur; struct Episode *next; struct GNUNET_ATS_TEST_Operation *cur_o; struct GNUNET_ATS_TEST_Operation *next_o; next = e->start; for (cur = next; NULL != cur; cur = next) { next = cur->next; next_o = cur->head; for (cur_o = next_o; NULL != cur_o; cur_o = next_o) { next_o = cur_o->next; GNUNET_free_non_null(cur_o->address); GNUNET_free_non_null(cur_o->plugin); GNUNET_free(cur_o); } GNUNET_free(cur); } GNUNET_free_non_null(e->name); GNUNET_free_non_null(e->log_prefix); GNUNET_free_non_null(e->log_output_dir); GNUNET_free_non_null(e->cfg_file); GNUNET_free(e); } static int load_op_add_address(struct GNUNET_ATS_TEST_Operation *o, struct Episode *e, int op_counter, char *sec_name, const struct GNUNET_CONFIGURATION_Handle *cfg) { char *op_name; char *op_network; /* peer pid */ GNUNET_asprintf(&op_name, "op-%u-peer-id", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg, sec_name, op_name, &o->peer_id)) { fprintf(stderr, "Missing peer-id in operation %u `%s' in episode `%s'\n", op_counter, "ADD_ADDRESS", op_name); GNUNET_free(op_name); return GNUNET_SYSERR; } GNUNET_free(op_name); /* address pid */ GNUNET_asprintf(&op_name, "op-%u-address-id", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg, sec_name, op_name, &o->address_id)) { fprintf(stderr, "Missing address-id in operation %u `%s' in episode `%s'\n", op_counter, "ADD_ADDRESS", op_name); GNUNET_free(op_name); return GNUNET_SYSERR; } GNUNET_free(op_name); /* plugin */ GNUNET_asprintf(&op_name, "op-%u-plugin", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg, sec_name, op_name, &o->plugin)) { fprintf(stderr, "Missing plugin in operation %u `%s' in episode `%s'\n", op_counter, "ADD_ADDRESS", op_name); GNUNET_free(op_name); return GNUNET_SYSERR; } GNUNET_free(op_name); /* address */ GNUNET_asprintf(&op_name, "op-%u-address", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg, sec_name, op_name, &o->address)) { fprintf(stderr, "Missing address in operation %u `%s' in episode `%s'\n", op_counter, "ADD_ADDRESS", op_name); GNUNET_free(op_name); return GNUNET_SYSERR; } GNUNET_free(op_name); /* session */ GNUNET_asprintf(&op_name, "op-%u-address-session", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg, sec_name, op_name, &o->address_session)) { fprintf(stderr, "Missing address-session in operation %u `%s' in episode `%s'\n", op_counter, "ADD_ADDRESS", op_name); GNUNET_free(op_name); return GNUNET_SYSERR; } GNUNET_free(op_name); /* network */ GNUNET_asprintf(&op_name, "op-%u-address-network", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg, sec_name, op_name, &op_network)) { fprintf(stderr, "Missing address-network in operation %u `%s' in episode `%s'\n", op_counter, "ADD_ADDRESS", op_name); GNUNET_free(op_name); return GNUNET_SYSERR; } else { GNUNET_STRINGS_utf8_toupper(op_network, op_network); if (0 == strcmp(op_network, "UNSPECIFIED")) { o->address_network = GNUNET_NT_UNSPECIFIED; } else if (0 == strcmp(op_network, "LOOPBACK")) { o->address_network = GNUNET_NT_LOOPBACK; } else if (0 == strcmp(op_network, "LAN")) { o->address_network = GNUNET_NT_LAN; } else if (0 == strcmp(op_network, "WAN")) { o->address_network = GNUNET_NT_WAN; } else if (0 == strcmp(op_network, "WLAN")) { o->address_network = GNUNET_NT_WLAN; } else if (0 == strcmp(op_network, "BT")) { o->address_network = GNUNET_NT_BT; } else { fprintf(stderr, "Invalid address-network in operation %u `%s' in episode `%s': `%s'\n", op_counter, "ADD_ADDRESS", op_name, op_network); GNUNET_free(op_network); GNUNET_free(op_name); return GNUNET_SYSERR; } } GNUNET_free(op_network); GNUNET_free(op_name); GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Found operation %s: [%llu:%llu] address `%s' plugin `%s' \n", "ADD_ADDRESS", o->peer_id, o->address_id, o->address, o->plugin); return GNUNET_OK; } static int load_op_del_address(struct GNUNET_ATS_TEST_Operation *o, struct Episode *e, int op_counter, char *sec_name, const struct GNUNET_CONFIGURATION_Handle *cfg) { char *op_name; //char *op_network; /* peer pid */ GNUNET_asprintf(&op_name, "op-%u-peer-id", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg, sec_name, op_name, &o->peer_id)) { fprintf(stderr, "Missing peer-id in operation %u `%s' in episode `%s'\n", op_counter, "DEL_ADDRESS", op_name); GNUNET_free(op_name); return GNUNET_SYSERR; } GNUNET_free(op_name); /* address pid */ GNUNET_asprintf(&op_name, "op-%u-address-id", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg, sec_name, op_name, &o->address_id)) { fprintf(stderr, "Missing address-id in operation %u `%s' in episode `%s'\n", op_counter, "DEL_ADDRESS", op_name); GNUNET_free(op_name); return GNUNET_SYSERR; } GNUNET_free(op_name); #if 0 /* plugin */ GNUNET_asprintf(&op_name, "op-%u-plugin", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg, sec_name, op_name, &o->plugin)) { fprintf(stderr, "Missing plugin in operation %u `%s' in episode `%s'\n", op_counter, "DEL_ADDRESS", op_name); GNUNET_free(op_name); return GNUNET_SYSERR; } GNUNET_free(op_name); /* address */ GNUNET_asprintf(&op_name, "op-%u-address", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg, sec_name, op_name, &o->address)) { fprintf(stderr, "Missing address in operation %u `%s' in episode `%s'\n", op_counter, "DEL_ADDRESS", op_name); GNUNET_free(op_name); return GNUNET_SYSERR; } GNUNET_free(op_name); /* session */ GNUNET_asprintf(&op_name, "op-%u-address-session", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg, sec_name, op_name, &o->address_session)) { fprintf(stderr, "Missing address-session in operation %u `%s' in episode `%s'\n", op_counter, "DEL_ADDRESS", op_name); GNUNET_free(op_name); return GNUNET_SYSERR; } GNUNET_free(op_name); #endif GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Found operation %s: [%llu:%llu] address `%s' plugin `%s' \n", "DEL_ADDRESS", o->peer_id, o->address_id, o->address, o->plugin); return GNUNET_OK; } static enum GNUNET_ATS_Property parse_preference_string(const char * str) { int c = 0; char *props[GNUNET_ATS_PreferenceCount] = GNUNET_ATS_PreferenceTypeString; for (c = 0; c < GNUNET_ATS_PreferenceCount; c++) if (0 == strcmp(str, props[c])) return c; return 0; } static int load_op_start_set_preference(struct GNUNET_ATS_TEST_Operation *o, struct Episode *e, int op_counter, char *sec_name, const struct GNUNET_CONFIGURATION_Handle *cfg) { char *op_name; char *type; char *pref; /* peer pid */ GNUNET_asprintf(&op_name, "op-%u-peer-id", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg, sec_name, op_name, &o->peer_id)) { fprintf(stderr, "Missing peer-id in operation %u `%s' in episode `%s'\n", op_counter, "START_SET_PREFERENCE", op_name); GNUNET_free(op_name); return GNUNET_SYSERR; } GNUNET_free(op_name); /* address pid */ GNUNET_asprintf(&op_name, "op-%u-client-id", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg, sec_name, op_name, &o->client_id)) { fprintf(stderr, "Missing client-id in operation %u `%s' in episode `%s'\n", op_counter, "START_SET_PREFERENCE", op_name); GNUNET_free(op_name); return GNUNET_SYSERR; } GNUNET_free(op_name); /* generator */ GNUNET_asprintf(&op_name, "op-%u-gen-type", op_counter); if ((GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg, sec_name, op_name, &type))) { fprintf(stderr, "Missing type in operation %u `%s' in episode `%s'\n", op_counter, "START_SET_PREFERENCE", op_name); GNUNET_free(op_name); return GNUNET_SYSERR; } /* Load arguments for set_rate, start_send, set_preference */ if (0 == strcmp(type, "constant")) { o->gen_type = GNUNET_ATS_TEST_TG_CONSTANT; } else if (0 == strcmp(type, "linear")) { o->gen_type = GNUNET_ATS_TEST_TG_LINEAR; } else if (0 == strcmp(type, "sinus")) { o->gen_type = GNUNET_ATS_TEST_TG_SINUS; } else if (0 == strcmp(type, "random")) { o->gen_type = GNUNET_ATS_TEST_TG_RANDOM; } else { fprintf(stderr, "Invalid generator type %u `%s' in episode %u\n", op_counter, op_name, e->id); GNUNET_free(type); GNUNET_free(op_name); return GNUNET_SYSERR; } GNUNET_free(type); GNUNET_free(op_name); /* Get base rate */ GNUNET_asprintf(&op_name, "op-%u-base-rate", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg, sec_name, op_name, &o->base_rate)) { fprintf(stderr, "Missing base rate in operation %u `%s' in episode %u\n", op_counter, op_name, e->id); GNUNET_free(op_name); return GNUNET_SYSERR; } GNUNET_free(op_name); /* Get max rate */ GNUNET_asprintf(&op_name, "op-%u-max-rate", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg, sec_name, op_name, &o->max_rate)) { if ((GNUNET_ATS_TEST_TG_LINEAR == o->gen_type) || (GNUNET_ATS_TEST_TG_RANDOM == o->gen_type) || (GNUNET_ATS_TEST_TG_SINUS == o->gen_type)) { fprintf(stderr, "Missing max rate in operation %u `%s' in episode %u\n", op_counter, op_name, e->id); GNUNET_free(op_name); return GNUNET_SYSERR; } } GNUNET_free(op_name); /* Get period */ GNUNET_asprintf(&op_name, "op-%u-period", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time(cfg, sec_name, op_name, &o->period)) { o->period = e->duration; } GNUNET_free(op_name); /* Get frequency */ GNUNET_asprintf(&op_name, "op-%u-frequency", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time(cfg, sec_name, op_name, &o->frequency)) { fprintf(stderr, "Missing frequency in operation %u `%s' in episode %u\n", op_counter, op_name, e->id); GNUNET_free(op_name); return GNUNET_SYSERR; } GNUNET_free(op_name); /* Get preference */ GNUNET_asprintf(&op_name, "op-%u-pref", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg, sec_name, op_name, &pref)) { fprintf(stderr, "Missing preference in operation %u `%s' in episode %u\n", op_counter, op_name, e->id); GNUNET_free(op_name); return GNUNET_SYSERR; } if (0 == (o->pref_type = parse_preference_string(pref))) { fprintf(stderr, "Invalid preference in operation %u `%s' in episode %u\n", op_counter, op_name, e->id); GNUNET_free(op_name); GNUNET_free(pref); return GNUNET_SYSERR; } GNUNET_free(pref); GNUNET_free(op_name); /* Get feedback delay */ GNUNET_asprintf(&op_name, "op-%u-feedback_delay", op_counter); if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_time(cfg, sec_name, op_name, &o->feedback_delay)) { fprintf(stderr, "Using feedback delay %llu in operation %u `%s' in episode %u\n", (long long unsigned int)o->feedback_delay.rel_value_us, op_counter, op_name, e->id); } else o->feedback_delay = GNUNET_TIME_UNIT_FOREVER_REL; GNUNET_free(op_name); GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Found operation %s: [%llu:%llu]: %s = %llu\n", "START_SET_PREFERENCE", o->peer_id, o->address_id, GNUNET_ATS_print_preference_type(o->pref_type), o->base_rate); return GNUNET_OK; } static int load_op_stop_set_preference(struct GNUNET_ATS_TEST_Operation *o, struct Episode *e, int op_counter, char *sec_name, const struct GNUNET_CONFIGURATION_Handle *cfg) { char *op_name; char *pref; /* peer pid */ GNUNET_asprintf(&op_name, "op-%u-peer-id", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg, sec_name, op_name, &o->peer_id)) { fprintf(stderr, "Missing peer-id in operation %u `%s' in episode `%s'\n", op_counter, "STOP_SET_PREFERENCE", op_name); GNUNET_free(op_name); return GNUNET_SYSERR; } GNUNET_free(op_name); /* address pid */ GNUNET_asprintf(&op_name, "op-%u-address-id", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg, sec_name, op_name, &o->address_id)) { fprintf(stderr, "Missing address-id in operation %u `%s' in episode `%s'\n", op_counter, "STOP_SET_PREFERENCE", op_name); GNUNET_free(op_name); return GNUNET_SYSERR; } GNUNET_free(op_name); /* Get preference */ GNUNET_asprintf(&op_name, "op-%u-pref", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg, sec_name, op_name, &pref)) { fprintf(stderr, "Missing preference in operation %u `%s' in episode `%s'\n", op_counter, "STOP_SET_PREFERENCE", op_name); GNUNET_free(op_name); return GNUNET_SYSERR; } if (0 == (o->pref_type = parse_preference_string(pref))) { fprintf(stderr, "Invalid preference in operation %u `%s' in episode %u\n", op_counter, op_name, e->id); GNUNET_free(op_name); GNUNET_free(pref); return GNUNET_SYSERR; } GNUNET_free(pref); GNUNET_free(op_name); GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Found operation %s: [%llu:%llu]: %s\n", "STOP_SET_PREFERENCE", o->peer_id, o->address_id, GNUNET_ATS_print_preference_type(o->pref_type)); return GNUNET_OK; } static enum GNUNET_ATS_Property parse_property_string(const char *str) { enum GNUNET_ATS_Property c; for (c = 0; c < GNUNET_ATS_PropertyCount; c++) if (0 == strcmp(str, GNUNET_ATS_print_property_type(c))) return c; return 0; } static int load_op_start_set_property(struct GNUNET_ATS_TEST_Operation *o, struct Episode *e, int op_counter, char *sec_name, const struct GNUNET_CONFIGURATION_Handle *cfg) { char *op_name; char *type; char *prop; /* peer pid */ GNUNET_asprintf(&op_name, "op-%u-peer-id", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg, sec_name, op_name, &o->peer_id)) { fprintf(stderr, "Missing peer-id in operation %u `%s' in episode `%s'\n", op_counter, "START_SET_PROPERTY", op_name); GNUNET_free(op_name); return GNUNET_SYSERR; } GNUNET_free(op_name); /* address pid */ GNUNET_asprintf(&op_name, "op-%u-address-id", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg, sec_name, op_name, &o->address_id)) { fprintf(stderr, "Missing address-id in operation %u `%s' in episode `%s'\n", op_counter, "START_SET_PROPERTY", op_name); GNUNET_free(op_name); return GNUNET_SYSERR; } GNUNET_free(op_name); /* generator */ GNUNET_asprintf(&op_name, "op-%u-gen-type", op_counter); if ((GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg, sec_name, op_name, &type))) { fprintf(stderr, "Missing type in operation %u `%s' in episode `%s'\n", op_counter, "START_SET_PROPERTY", op_name); GNUNET_free(op_name); return GNUNET_SYSERR; } /* Load arguments for set_rate, start_send, set_preference */ if (0 == strcmp(type, "constant")) { o->gen_type = GNUNET_ATS_TEST_TG_CONSTANT; } else if (0 == strcmp(type, "linear")) { o->gen_type = GNUNET_ATS_TEST_TG_LINEAR; } else if (0 == strcmp(type, "sinus")) { o->gen_type = GNUNET_ATS_TEST_TG_SINUS; } else if (0 == strcmp(type, "random")) { o->gen_type = GNUNET_ATS_TEST_TG_RANDOM; } else { fprintf(stderr, "Invalid generator type %u `%s' in episode %u\n", op_counter, op_name, e->id); GNUNET_free(type); GNUNET_free(op_name); return GNUNET_SYSERR; } GNUNET_free(type); GNUNET_free(op_name); /* Get base rate */ GNUNET_asprintf(&op_name, "op-%u-base-rate", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg, sec_name, op_name, &o->base_rate)) { fprintf(stderr, "Missing base rate in operation %u `%s' in episode %u\n", op_counter, op_name, e->id); GNUNET_free(op_name); return GNUNET_SYSERR; } GNUNET_free(op_name); /* Get max rate */ GNUNET_asprintf(&op_name, "op-%u-max-rate", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg, sec_name, op_name, &o->max_rate)) { if ((GNUNET_ATS_TEST_TG_LINEAR == o->gen_type) || (GNUNET_ATS_TEST_TG_RANDOM == o->gen_type) || (GNUNET_ATS_TEST_TG_SINUS == o->gen_type)) { fprintf(stderr, "Missing max rate in operation %u `%s' in episode %u\n", op_counter, op_name, e->id); GNUNET_free(op_name); return GNUNET_SYSERR; } } GNUNET_free(op_name); /* Get period */ GNUNET_asprintf(&op_name, "op-%u-period", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time(cfg, sec_name, op_name, &o->period)) { o->period = e->duration; } GNUNET_free(op_name); /* Get frequency */ GNUNET_asprintf(&op_name, "op-%u-frequency", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time(cfg, sec_name, op_name, &o->frequency)) { fprintf(stderr, "Missing frequency in operation %u `%s' in episode %u\n", op_counter, op_name, e->id); GNUNET_free(op_name); return GNUNET_SYSERR; } GNUNET_free(op_name); /* Get preference */ GNUNET_asprintf(&op_name, "op-%u-property", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg, sec_name, op_name, &prop)) { fprintf(stderr, "Missing property in operation %u `%s' in episode %u\n", op_counter, op_name, e->id); GNUNET_free(op_name); GNUNET_free_non_null(prop); return GNUNET_SYSERR; } if (0 == (o->prop_type = parse_property_string(prop))) { fprintf(stderr, "Invalid property in operation %u `%s' in episode %u\n", op_counter, op_name, e->id); GNUNET_free(op_name); GNUNET_free(prop); return GNUNET_SYSERR; } GNUNET_free(prop); GNUNET_free(op_name); GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Found operation %s: [%llu:%llu] %s = %llu\n", "START_SET_PROPERTY", o->peer_id, o->address_id, GNUNET_ATS_print_property_type(o->prop_type), o->base_rate); return GNUNET_OK; } static int load_op_stop_set_property(struct GNUNET_ATS_TEST_Operation *o, struct Episode *e, int op_counter, char *sec_name, const struct GNUNET_CONFIGURATION_Handle *cfg) { char *op_name; char *pref; /* peer pid */ GNUNET_asprintf(&op_name, "op-%u-peer-id", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg, sec_name, op_name, &o->peer_id)) { fprintf(stderr, "Missing peer-id in operation %u `%s' in episode `%s'\n", op_counter, "STOP_SET_PROPERTY", op_name); GNUNET_free(op_name); return GNUNET_SYSERR; } GNUNET_free(op_name); /* address pid */ GNUNET_asprintf(&op_name, "op-%u-address-id", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg, sec_name, op_name, &o->address_id)) { fprintf(stderr, "Missing address-id in operation %u `%s' in episode `%s'\n", op_counter, "STOP_SET_PROPERTY", op_name); GNUNET_free(op_name); return GNUNET_SYSERR; } GNUNET_free(op_name); /* Get property */ GNUNET_asprintf(&op_name, "op-%u-property", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg, sec_name, op_name, &pref)) { fprintf(stderr, "Missing property in operation %u `%s' in episode `%s'\n", op_counter, "STOP_SET_PROPERTY", op_name); GNUNET_free(op_name); GNUNET_free_non_null(pref); return GNUNET_SYSERR; } if (0 == (o->prop_type = parse_property_string(pref))) { fprintf(stderr, "Invalid property in operation %u `%s' in episode %u\n", op_counter, op_name, e->id); GNUNET_free(op_name); GNUNET_free_non_null(pref); return GNUNET_SYSERR; } GNUNET_free(pref); GNUNET_free(op_name); GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Found operation %s: [%llu:%llu] %s\n", "STOP_SET_PROPERTY", o->peer_id, o->address_id, GNUNET_ATS_print_property_type(o->prop_type)); return GNUNET_OK; } static int load_op_start_request(struct GNUNET_ATS_TEST_Operation *o, struct Episode *e, int op_counter, char *sec_name, const struct GNUNET_CONFIGURATION_Handle *cfg) { char *op_name; /* peer pid */ GNUNET_asprintf(&op_name, "op-%u-peer-id", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg, sec_name, op_name, &o->peer_id)) { fprintf(stderr, "Missing peer-id in operation %u `%s' in episode `%s'\n", op_counter, "START_REQUEST", op_name); GNUNET_free(op_name); return GNUNET_SYSERR; } GNUNET_free(op_name); return GNUNET_OK; } static int load_op_stop_request(struct GNUNET_ATS_TEST_Operation *o, struct Episode *e, int op_counter, char *sec_name, const struct GNUNET_CONFIGURATION_Handle *cfg) { char *op_name; /* peer pid */ GNUNET_asprintf(&op_name, "op-%u-peer-id", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg, sec_name, op_name, &o->peer_id)) { fprintf(stderr, "Missing peer-id in operation %u `%s' in episode `%s'\n", op_counter, "STOP_REQUEST", op_name); GNUNET_free(op_name); return GNUNET_SYSERR; } GNUNET_free(op_name); return GNUNET_OK; } static int load_episode(struct Experiment *e, struct Episode *cur, struct GNUNET_CONFIGURATION_Handle *cfg) { struct GNUNET_ATS_TEST_Operation *o; char *sec_name; char *op_name; char *op; int op_counter = 0; int res; GNUNET_log(GNUNET_ERROR_TYPE_INFO, "=== Parsing episode %u\n", cur->id); GNUNET_asprintf(&sec_name, "episode-%u", cur->id); while (1) { /* Load operation */ GNUNET_asprintf(&op_name, "op-%u-operation", op_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg, sec_name, op_name, &op)) { GNUNET_free(op_name); break; } o = GNUNET_new(struct GNUNET_ATS_TEST_Operation); GNUNET_log(GNUNET_ERROR_TYPE_INFO, "==== Parsing operation %u: `%s'\n", cur->id, op_name); /* operations = set_rate, start_send, stop_send, set_preference */ if (0 == strcmp(op, "address_add")) { o->type = SOLVER_OP_ADD_ADDRESS; res = load_op_add_address(o, cur, op_counter, sec_name, cfg); } else if (0 == strcmp(op, "address_del")) { o->type = SOLVER_OP_DEL_ADDRESS; res = load_op_del_address(o, cur, op_counter, sec_name, cfg); } else if (0 == strcmp(op, "start_set_property")) { o->type = SOLVER_OP_START_SET_PROPERTY; res = load_op_start_set_property(o, cur, op_counter, sec_name, cfg); } else if (0 == strcmp(op, "stop_set_property")) { o->type = SOLVER_OP_STOP_SET_PROPERTY; res = load_op_stop_set_property(o, cur, op_counter, sec_name, cfg); } else if (0 == strcmp(op, "start_set_preference")) { o->type = SOLVER_OP_START_SET_PREFERENCE; res = load_op_start_set_preference(o, cur, op_counter, sec_name, cfg); } else if (0 == strcmp(op, "stop_set_preference")) { o->type = SOLVER_OP_STOP_SET_PREFERENCE; res = load_op_stop_set_preference(o, cur, op_counter, sec_name, cfg); } else if (0 == strcmp(op, "start_request")) { o->type = SOLVER_OP_START_REQUEST; res = load_op_start_request(o, cur, op_counter, sec_name, cfg); } else if (0 == strcmp(op, "stop_request")) { o->type = SOLVER_OP_STOP_REQUEST; res = load_op_stop_request(o, cur, op_counter, sec_name, cfg); } else { fprintf(stderr, "Invalid operation %u `%s' in episode %u\n", op_counter, op, cur->id); res = GNUNET_SYSERR; } GNUNET_free(op); GNUNET_free(op_name); if (GNUNET_SYSERR == res) { GNUNET_free(o); GNUNET_free(sec_name); return GNUNET_SYSERR; } GNUNET_CONTAINER_DLL_insert_tail(cur->head, cur->tail, o); op_counter++; } GNUNET_free(sec_name); return GNUNET_OK; } static int load_episodes(struct Experiment *e, struct GNUNET_CONFIGURATION_Handle *cfg) { int e_counter = 0; char *sec_name; struct GNUNET_TIME_Relative e_duration; struct Episode *cur; struct Episode *last; e_counter = 0; last = NULL; while (1) { GNUNET_asprintf(&sec_name, "episode-%u", e_counter); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time(cfg, sec_name, "duration", &e_duration)) { GNUNET_free(sec_name); break; } cur = GNUNET_new(struct Episode); cur->duration = e_duration; cur->id = e_counter; if (GNUNET_OK != load_episode(e, cur, cfg)) { GNUNET_free(sec_name); GNUNET_free(cur); return GNUNET_SYSERR; } GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Found episode %u with duration %s \n", e_counter, GNUNET_STRINGS_relative_time_to_string(cur->duration, GNUNET_YES)); /* Update experiment */ e->num_episodes++; e->total_duration = GNUNET_TIME_relative_add(e->total_duration, cur->duration); /* Put in linked list */ if (NULL == last) e->start = cur; else last->next = cur; GNUNET_free(sec_name); e_counter++; last = cur; } return e_counter; } static void timeout_experiment(void *cls) { struct Experiment *e = cls; e->experiment_timeout_task = NULL; fprintf(stderr, "Experiment timeout!\n"); if (NULL != e->episode_timeout_task) { GNUNET_SCHEDULER_cancel(e->episode_timeout_task); e->episode_timeout_task = NULL; } e->e_done_cb(e, GNUNET_TIME_absolute_get_duration(e->start_time), GNUNET_SYSERR); } struct ATS_Address * create_ats_address(const struct GNUNET_PeerIdentity *peer, const char *plugin_name, const void *plugin_addr, size_t plugin_addr_len, uint32_t session_id, uint32_t network) { struct ATS_Address *aa = NULL; aa = GNUNET_malloc(sizeof(struct ATS_Address) + plugin_addr_len + strlen(plugin_name) + 1); aa->atsi = GNUNET_new(struct GNUNET_ATS_Information); aa->atsi[0].type = htonl(GNUNET_ATS_NETWORK_TYPE); aa->atsi[0].value = htonl(network); aa->atsi_count = 1; aa->peer = *peer; aa->addr_len = plugin_addr_len; aa->addr = &aa[1]; aa->plugin = (char *)&aa[1] + plugin_addr_len; GNUNET_memcpy(&aa[1], plugin_addr, plugin_addr_len); GNUNET_memcpy(aa->plugin, plugin_name, strlen(plugin_name) + 1); aa->session_id = session_id; return aa; } static void enforce_add_address(struct GNUNET_ATS_TEST_Operation *op) { struct TestPeer *p; struct TestAddress *a; int c; if (NULL == (p = find_peer_by_id(op->peer_id))) { p = GNUNET_new(struct TestPeer); p->id = op->peer_id; p->assigned_bw_in = 0; p->assigned_bw_out = 0; memset(&p->peer_id, op->peer_id, sizeof(p->peer_id)); for (c = 0; c < GNUNET_ATS_PreferenceCount; c++) { p->pref_abs[c] = DEFAULT_ABS_PREFERENCE; p->pref_norm[c] = DEFAULT_REL_PREFERENCE; } GNUNET_CONTAINER_DLL_insert(peer_head, peer_tail, p); } if (NULL != (find_address_by_id(p, op->address_id))) { GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Duplicate address %u for peer %u\n", op->address_id, op->peer_id); return; } a = GNUNET_new(struct TestAddress); a->aid = op->address_id; a->network = op->address_network; a->ats_addr = create_ats_address(&p->peer_id, op->plugin, op->address, strlen(op->address) + 1, op->address_session, op->address_network); memset(&p->peer_id, op->peer_id, sizeof(p->peer_id)); GNUNET_CONTAINER_DLL_insert_tail(p->addr_head, p->addr_tail, a); for (c = 0; c < GNUNET_ATS_PropertyCount; c++) a->prop_norm[c] = DEFAULT_REL_QUALITY; GNUNET_CONTAINER_multipeermap_put(sh->addresses, &p->peer_id, a->ats_addr, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Adding address %u for peer %u in network `%s'\n", op->address_id, op->peer_id, GNUNET_NT_to_string(a->network)); sh->sf->s_add(sh->sf->cls, a->ats_addr, op->address_network); } static void enforce_del_address(struct GNUNET_ATS_TEST_Operation *op) { struct TestPeer *p; struct TestAddress *a; struct PropertyGenerator *pg; if (NULL == (p = find_peer_by_id(op->peer_id))) { GNUNET_break(0); GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Deleting address for unknown peer %u\n", op->peer_id); return; } if (NULL == (a = find_address_by_id(p, op->address_id))) { GNUNET_break(0); GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Deleting address for unknown peer %u\n", op->peer_id); return; } while (NULL != (pg = find_prop_gen(p->id, a->aid, 0))) { GNUNET_ATS_solver_generate_property_stop(pg); } GNUNET_assert(GNUNET_YES == GNUNET_CONTAINER_multipeermap_remove(sh->addresses, &p->peer_id, a->ats_addr)); GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Removing address %u for peer %u\n", op->address_id, op->peer_id); sh->sf->s_del(sh->sf->cls, a->ats_addr); if (NULL != l) { GNUNET_ATS_solver_logging_now(l); } GNUNET_CONTAINER_DLL_remove(p->addr_head, p->addr_tail, a); GNUNET_free_non_null(a->ats_addr->atsi); GNUNET_free(a->ats_addr); GNUNET_free(a); } static void enforce_start_property(struct GNUNET_ATS_TEST_Operation *op) { struct PropertyGenerator *pg; struct TestPeer *p; struct TestAddress *a; if (NULL != (pg = find_prop_gen(op->peer_id, op->address_id, op->prop_type))) { GNUNET_ATS_solver_generate_property_stop(pg); GNUNET_free(pg); } if (NULL == (p = find_peer_by_id(op->peer_id))) { GNUNET_break(0); GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Starting property generation for unknown peer %u\n", op->peer_id); return; } if (NULL == (a = find_address_by_id(p, op->address_id))) { GNUNET_break(0); GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Setting property for unknown address %u\n", op->peer_id); return; } GNUNET_ATS_solver_generate_property_start(op->peer_id, op->address_id, p, a, op->gen_type, op->base_rate, op->max_rate, op->period, op->frequency, op->prop_type); } static void enforce_stop_property(struct GNUNET_ATS_TEST_Operation *op) { struct PropertyGenerator *pg = find_prop_gen(op->peer_id, op->address_id, op->prop_type); if (NULL != pg) { GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Stopping preference generation for peer %u address %u\n", op->peer_id, op->address_id); GNUNET_ATS_solver_generate_property_stop(pg); } else { GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Cannot find preference generator for peer %u address %u\n", op->peer_id, op->address_id); GNUNET_break(0); } } static void enforce_start_preference(struct GNUNET_ATS_TEST_Operation *op) { struct PreferenceGenerator *pg; if (NULL != (pg = find_pref_gen(op->peer_id, op->pref_type))) { GNUNET_ATS_solver_generate_preferences_stop(pg); GNUNET_free(pg); } if (NULL == (find_peer_by_id(op->peer_id))) { GNUNET_break(0); GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Starting preference generation for unknown peer %u\n", op->peer_id); return; } GNUNET_ATS_solver_generate_preferences_start(op->peer_id, op->address_id, op->client_id, op->gen_type, op->base_rate, op->max_rate, op->period, op->frequency, op->pref_type, op->frequency); } static void enforce_stop_preference(struct GNUNET_ATS_TEST_Operation *op) { struct PreferenceGenerator *pg = find_pref_gen(op->peer_id, op->pref_type); if (NULL != pg) { GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Stopping property generation for peer %u address %u\n", op->peer_id, op->address_id); GNUNET_ATS_solver_generate_preferences_stop(pg); } else { GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Cannot find preference generator for peer %u address %u\n", op->peer_id, op->address_id); GNUNET_break(0); } } static void enforce_start_request(struct GNUNET_ATS_TEST_Operation *op) { struct TestPeer *p; if (NULL == (p = find_peer_by_id(op->peer_id))) { GNUNET_break(0); GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Requesting address for unknown peer %u\n", op->peer_id); return; } GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Requesting address for peer %u\n", op->peer_id); p->is_requested = GNUNET_YES; sh->sf->s_get(sh->sf->cls, &p->peer_id); } static void enforce_stop_request(struct GNUNET_ATS_TEST_Operation *op) { struct TestPeer *p; if (NULL == (p = find_peer_by_id(op->peer_id))) { GNUNET_break(0); GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Requesting address for unknown peer %u\n", op->peer_id); return; } GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Stop requesting address for peer %u\n", op->peer_id); p->is_requested = GNUNET_NO; p->assigned_bw_in = 0; p->assigned_bw_out = 0; sh->sf->s_get_stop(sh->sf->cls, &p->peer_id); if (NULL != l) { GNUNET_ATS_solver_logging_now(l); } } static void enforce_episode(struct Episode *ep) { struct GNUNET_ATS_TEST_Operation *cur; for (cur = ep->head; NULL != cur; cur = cur->next) { switch (cur->type) { case SOLVER_OP_ADD_ADDRESS: fprintf(stderr, "Enforcing operation: %s [%llu:%llu]\n", print_op(cur->type), cur->peer_id, cur->address_id); enforce_add_address(cur); break; case SOLVER_OP_DEL_ADDRESS: fprintf(stderr, "Enforcing operation: %s [%llu:%llu]\n", print_op(cur->type), cur->peer_id, cur->address_id); enforce_del_address(cur); break; case SOLVER_OP_START_SET_PROPERTY: fprintf(stderr, "Enforcing operation: %s [%llu:%llu] == %llu\n", print_op(cur->type), cur->peer_id, cur->address_id, cur->base_rate); enforce_start_property(cur); break; case SOLVER_OP_STOP_SET_PROPERTY: fprintf(stderr, "Enforcing operation: %s [%llu:%llu] == %llu\n", print_op(cur->type), cur->peer_id, cur->address_id, cur->base_rate); enforce_stop_property(cur); break; case SOLVER_OP_START_SET_PREFERENCE: fprintf(stderr, "Enforcing operation: %s [%llu:%llu] == %llu\n", print_op(cur->type), cur->peer_id, cur->address_id, cur->base_rate); enforce_start_preference(cur); break; case SOLVER_OP_STOP_SET_PREFERENCE: fprintf(stderr, "Enforcing operation: %s [%llu:%llu] == %llu\n", print_op(cur->type), cur->peer_id, cur->address_id, cur->base_rate); enforce_stop_preference(cur); break; case SOLVER_OP_START_REQUEST: fprintf(stderr, "Enforcing operation: %s [%llu]\n", print_op(cur->type), cur->peer_id); enforce_start_request(cur); break; case SOLVER_OP_STOP_REQUEST: fprintf(stderr, "Enforcing operation: %s [%llu]\n", print_op(cur->type), cur->peer_id); enforce_stop_request(cur); break; default: break; } } } static void timeout_episode(void *cls) { struct Experiment *e = cls; e->episode_timeout_task = NULL; if (NULL != e->ep_done_cb) e->ep_done_cb(e->cur); /* Scheduling next */ e->cur = e->cur->next; if (NULL == e->cur) { /* done */ fprintf(stderr, "Last episode done!\n"); if (NULL != e->experiment_timeout_task) { GNUNET_SCHEDULER_cancel(e->experiment_timeout_task); e->experiment_timeout_task = NULL; } e->e_done_cb(e, GNUNET_TIME_absolute_get_duration(e->start_time), GNUNET_OK); return; } fprintf(stderr, "Running episode %u with timeout %s\n", e->cur->id, GNUNET_STRINGS_relative_time_to_string(e->cur->duration, GNUNET_YES)); e->episode_timeout_task = GNUNET_SCHEDULER_add_delayed(e->cur->duration, &timeout_episode, e); enforce_episode(e->cur); } void GNUNET_ATS_solvers_experimentation_run(struct Experiment *e, GNUNET_ATS_TESTING_EpisodeDoneCallback ep_done_cb, GNUNET_ATS_TESTING_ExperimentDoneCallback e_done_cb) { fprintf(stderr, "Running experiment `%s' with timeout %s\n", e->name, GNUNET_STRINGS_relative_time_to_string(e->max_duration, GNUNET_YES)); e->e_done_cb = e_done_cb; e->ep_done_cb = ep_done_cb; e->start_time = GNUNET_TIME_absolute_get(); /* Start total time out */ e->experiment_timeout_task = GNUNET_SCHEDULER_add_delayed(e->max_duration, &timeout_experiment, e); /* Start */ if (NULL == e->start) { GNUNET_break(0); return; } e->cur = e->start; fprintf(stderr, "Running episode %u with timeout %s\n", e->cur->id, GNUNET_STRINGS_relative_time_to_string(e->cur->duration, GNUNET_YES)); e->episode_timeout_task = GNUNET_SCHEDULER_add_delayed(e->cur->duration, &timeout_episode, e); enforce_episode(e->cur); } void GNUNET_ATS_solvers_experimentation_stop(struct Experiment *e) { if (NULL != e->experiment_timeout_task) { GNUNET_SCHEDULER_cancel(e->experiment_timeout_task); e->experiment_timeout_task = NULL; } if (NULL != e->episode_timeout_task) { GNUNET_SCHEDULER_cancel(e->episode_timeout_task); e->episode_timeout_task = NULL; } if (NULL != e->cfg) { GNUNET_CONFIGURATION_destroy(e->cfg); e->cfg = NULL; } free_experiment(e); } struct Experiment * GNUNET_ATS_solvers_experimentation_load(char *filename) { struct Experiment *e; struct GNUNET_CONFIGURATION_Handle *cfg; e = NULL; cfg = GNUNET_CONFIGURATION_create(); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load(cfg, filename)) { fprintf(stderr, "Failed to load `%s'\n", filename); GNUNET_CONFIGURATION_destroy(cfg); return NULL; } e = create_experiment(); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg, "experiment", "name", &e->name)) { fprintf(stderr, "Invalid %s \n", "name"); free_experiment(e); return NULL; } else GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Experiment name: `%s'\n", e->name); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg, "experiment", "log_prefix", &e->log_prefix)) { fprintf(stderr, "Invalid %s \n", "log_prefix"); free_experiment(e); return NULL; } else GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Experiment logging prefix: `%s'\n", e->log_prefix); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_filename(cfg, "experiment", "log_output_dir", &e->log_output_dir)) { e->log_output_dir = NULL; } else GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Experiment logging output directory: `%s'\n", e->log_output_dir); if (GNUNET_SYSERR == (e->log_append_time_stamp = GNUNET_CONFIGURATION_get_value_yesno(cfg, "experiment", "log_append_time_stamp"))) e->log_append_time_stamp = GNUNET_YES; GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Experiment logging append timestamp: `%s'\n", (GNUNET_YES == e->log_append_time_stamp) ? "yes" : "no"); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_filename(cfg, "experiment", "cfg_file", &e->cfg_file)) { fprintf(stderr, "Invalid %s \n", "cfg_file"); free_experiment(e); return NULL; } else { GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Experiment configuration: `%s'\n", e->cfg_file); e->cfg = GNUNET_CONFIGURATION_create(); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load(e->cfg, e->cfg_file)) { fprintf(stderr, "Invalid configuration %s \n", "cfg_file"); free_experiment(e); return NULL; } } if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time(cfg, "experiment", "log_freq", &e->log_freq)) { fprintf(stderr, "Invalid %s \n", "log_freq"); free_experiment(e); return NULL; } else GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Experiment logging frequency: `%s'\n", GNUNET_STRINGS_relative_time_to_string(e->log_freq, GNUNET_YES)); if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time(cfg, "experiment", "max_duration", &e->max_duration)) { fprintf(stderr, "Invalid %s", "max_duration"); free_experiment(e); return NULL; } else GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Experiment duration: `%s'\n", GNUNET_STRINGS_relative_time_to_string(e->max_duration, GNUNET_YES)); if (GNUNET_SYSERR == load_episodes(e, cfg)) { GNUNET_ATS_solvers_experimentation_stop(e); GNUNET_CONFIGURATION_destroy(cfg); e = NULL; fprintf(stderr, "Failed to load experiment\n"); return NULL; } GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Loaded %u episodes with total duration %s\n", e->num_episodes, GNUNET_STRINGS_relative_time_to_string(e->total_duration, GNUNET_YES)); GNUNET_CONFIGURATION_destroy(cfg); return e; } /** * Solver */ static int free_all_it(void *cls, const struct GNUNET_PeerIdentity *key, void *value) { struct ATS_Address *address = value; GNUNET_break(GNUNET_OK == GNUNET_CONTAINER_multipeermap_remove(sh->env.addresses, key, value)); GNUNET_free(address); return GNUNET_OK; } void GNUNET_ATS_solvers_solver_stop(struct SolverHandle *sh) { GNUNET_STATISTICS_destroy((struct GNUNET_STATISTICS_Handle *)sh->env.stats, GNUNET_NO); GNUNET_PLUGIN_unload(sh->plugin, sh->sf); sh->sf = NULL; GAS_normalization_stop(); GNUNET_CONTAINER_multipeermap_iterate(sh->addresses, &free_all_it, NULL); GNUNET_CONTAINER_multipeermap_destroy(sh->addresses); GNUNET_free(sh->plugin); GNUNET_free(sh); } /** * Load quotas for networks from configuration * * @param cfg configuration handle * @param out_dest where to write outbound quotas * @param in_dest where to write inbound quotas * @param dest_length length of inbound and outbound arrays * @return number of networks loaded */ unsigned int GNUNET_ATS_solvers_load_quotas(const struct GNUNET_CONFIGURATION_Handle *cfg, unsigned long long *out_dest, unsigned long long *in_dest, int dest_length) { char * entry_in = NULL; char * entry_out = NULL; char * quota_out_str; char * quota_in_str; int c; int res; for (c = 0; (c < GNUNET_NT_COUNT) && (c < dest_length); c++) { in_dest[c] = 0; out_dest[c] = 0; GNUNET_asprintf(&entry_out, "%s_QUOTA_OUT", GNUNET_NT_to_string(c)); GNUNET_asprintf(&entry_in, "%s_QUOTA_IN", GNUNET_NT_to_string(c)); /* quota out */ if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, "ats", entry_out, "a_out_str)) { res = GNUNET_NO; if (0 == strcmp(quota_out_str, BIG_M_STRING)) { out_dest[c] = GNUNET_ATS_MaxBandwidth; res = GNUNET_YES; } if ((GNUNET_NO == res) && (GNUNET_OK == GNUNET_STRINGS_fancy_size_to_bytes(quota_out_str, &out_dest[c]))) res = GNUNET_YES; if ((GNUNET_NO == res) && (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "ats", entry_out, &out_dest[c]))) res = GNUNET_YES; if (GNUNET_NO == res) { GNUNET_log(GNUNET_ERROR_TYPE_ERROR, _("Could not load quota for network `%s': `%s', assigning default bandwidth %llu\n"), GNUNET_NT_to_string(c), quota_out_str, GNUNET_ATS_DefaultBandwidth); out_dest[c] = GNUNET_ATS_DefaultBandwidth; } else { GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Outbound quota configure for network `%s' is %llu\n", GNUNET_NT_to_string(c), out_dest[c]); } GNUNET_free(quota_out_str); } else { GNUNET_log(GNUNET_ERROR_TYPE_WARNING, _("No outbound quota configured for network `%s', assigning default bandwidth %llu\n"), GNUNET_NT_to_string(c), GNUNET_ATS_DefaultBandwidth); out_dest[c] = GNUNET_ATS_DefaultBandwidth; } /* quota in */ if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, "ats", entry_in, "a_in_str)) { res = GNUNET_NO; if (0 == strcmp(quota_in_str, BIG_M_STRING)) { in_dest[c] = GNUNET_ATS_MaxBandwidth; res = GNUNET_YES; } if ((GNUNET_NO == res) && (GNUNET_OK == GNUNET_STRINGS_fancy_size_to_bytes(quota_in_str, &in_dest[c]))) res = GNUNET_YES; if ((GNUNET_NO == res) && (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "ats", entry_in, &in_dest[c]))) res = GNUNET_YES; if (GNUNET_NO == res) { GNUNET_log(GNUNET_ERROR_TYPE_ERROR, _("Could not load quota for network `%s': `%s', assigning default bandwidth %llu\n"), GNUNET_NT_to_string(c), quota_in_str, GNUNET_ATS_DefaultBandwidth); in_dest[c] = GNUNET_ATS_DefaultBandwidth; } else { GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Inbound quota configured for network `%s' is %llu\n", GNUNET_NT_to_string(c), in_dest[c]); } GNUNET_free(quota_in_str); } else { GNUNET_log(GNUNET_ERROR_TYPE_WARNING, _("No outbound quota configure for network `%s', assigning default bandwidth %llu\n"), GNUNET_NT_to_string(c), GNUNET_ATS_DefaultBandwidth); out_dest[c] = GNUNET_ATS_DefaultBandwidth; } GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Loaded quota for network `%s' (in/out): %llu %llu\n", GNUNET_NT_to_string(c), in_dest[c], out_dest[c]); GNUNET_free(entry_out); GNUNET_free(entry_in); } return GNUNET_NT_COUNT; } /** * Information callback for the solver * * @param cls the closure * @param op the solver operation * @param stat status of the solver operation * @param add additional solver information */ static void solver_info_cb(void *cls, enum GAS_Solver_Operation op, enum GAS_Solver_Status stat, enum GAS_Solver_Additional_Information add) { char *add_info; switch (add) { case GAS_INFO_NONE: add_info = "GAS_INFO_NONE"; break; case GAS_INFO_FULL: add_info = "GAS_INFO_MLP_FULL"; break; case GAS_INFO_UPDATED: add_info = "GAS_INFO_MLP_UPDATED"; break; case GAS_INFO_PROP_ALL: add_info = "GAS_INFO_PROP_ALL"; break; case GAS_INFO_PROP_SINGLE: add_info = "GAS_INFO_PROP_SINGLE"; break; default: add_info = "INVALID"; break; } switch (op) { case GAS_OP_SOLVE_START: GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Solver notifies `%s' with result `%s' `%s'\n", "GAS_OP_SOLVE_START", (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL", add_info); return; case GAS_OP_SOLVE_STOP: GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_STOP", (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL", add_info); return; case GAS_OP_SOLVE_SETUP_START: GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_SETUP_START", (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL"); return; case GAS_OP_SOLVE_SETUP_STOP: GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_SETUP_STOP", (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL"); return; case GAS_OP_SOLVE_MLP_LP_START: GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_LP_START", (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL"); return; case GAS_OP_SOLVE_MLP_LP_STOP: GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_LP_STOP", (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL"); return; case GAS_OP_SOLVE_MLP_MLP_START: GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_MLP_START", (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL"); return; case GAS_OP_SOLVE_MLP_MLP_STOP: GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_MLP_STOP", (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL"); return; case GAS_OP_SOLVE_UPDATE_NOTIFICATION_START: GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_UPDATE_NOTIFICATION_START", (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL"); return; case GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP: GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP", (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL"); return; default: break; } } static void solver_bandwidth_changed_cb(void *cls, struct ATS_Address *address) { struct GNUNET_TIME_Relative duration; struct TestPeer *p; static struct PreferenceGenerator *pg; uint32_t delta; if ((0 == address->assigned_bw_out) && (0 == address->assigned_bw_in)) { GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Solver notified to disconnect peer `%s'\n", GNUNET_i2s(&address->peer)); } p = find_peer_by_pid(&address->peer); if (NULL == p) return; p->assigned_bw_out = address->assigned_bw_out; p->assigned_bw_in = address->assigned_bw_in; for (pg = pref_gen_head; NULL != pg; pg = pg->next) { if (pg->peer == p->id) { duration = GNUNET_TIME_absolute_get_duration(pg->feedback_last_bw_update); delta = duration.rel_value_us * pg->last_assigned_bw_out; pg->feedback_bw_out_acc += delta; delta = duration.rel_value_us * pg->last_assigned_bw_in; pg->feedback_bw_in_acc += delta; pg->last_assigned_bw_in = address->assigned_bw_in; pg->last_assigned_bw_out = address->assigned_bw_out; pg->feedback_last_bw_update = GNUNET_TIME_absolute_get(); } } GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Bandwidth changed addresses %s %p to %u Bps out / %u Bps in\n", GNUNET_i2s(&address->peer), address, address->assigned_bw_out, address->assigned_bw_in); if (NULL != l) GNUNET_ATS_solver_logging_now(l); return; } const double * get_preferences_cb(void *cls, const struct GNUNET_PeerIdentity *id) { struct TestPeer *p; if (GNUNET_YES == opt_disable_normalization) { if (NULL == (p = find_peer_by_pid(id))) return NULL; return p->pref_abs; } else return GAS_preference_get_by_peer(NULL, id); } struct SolverHandle * GNUNET_ATS_solvers_solver_start(enum GNUNET_ATS_Solvers type) { struct SolverHandle *sh; char * solver_str; switch (type) { case GNUNET_ATS_SOLVER_PROPORTIONAL: solver_str = "proportional"; break; case GNUNET_ATS_SOLVER_MLP: solver_str = "mlp"; break; case GNUNET_ATS_SOLVER_RIL: solver_str = "ril"; break; default: GNUNET_break(0); return NULL; break; } sh = GNUNET_new(struct SolverHandle); GNUNET_asprintf(&sh->plugin, "libgnunet_plugin_ats_%s", solver_str); sh->addresses = GNUNET_CONTAINER_multipeermap_create(128, GNUNET_NO); /* setup environment */ sh->env.cfg = e->cfg; sh->env.stats = GNUNET_STATISTICS_create("ats", e->cfg); sh->env.addresses = sh->addresses; sh->env.bandwidth_changed_cb = &solver_bandwidth_changed_cb; sh->env.get_preferences = &get_preferences_cb; sh->env.network_count = GNUNET_NT_COUNT; sh->env.info_cb = &solver_info_cb; sh->env.network_count = GNUNET_NT_COUNT; /* start normalization */ GAS_normalization_start(); /* load quotas */ if (GNUNET_NT_COUNT != GNUNET_ATS_solvers_load_quotas(e->cfg, sh->env.out_quota, sh->env.in_quota, GNUNET_NT_COUNT)) { GNUNET_break(0); GNUNET_free(sh->plugin); GNUNET_free(sh); end_now(); return NULL; } sh->sf = GNUNET_PLUGIN_load(sh->plugin, &sh->env); if (NULL == sh->sf) { fprintf(stderr, "Failed to load solver `%s'\n", sh->plugin); GNUNET_break(0); GNUNET_free(sh->plugin); GNUNET_free(sh); end_now(); return NULL; } return sh; } static void done() { struct TestPeer *cur; struct TestPeer *next; struct TestAddress *cur_a; struct TestAddress *next_a; /* Stop logging */ GNUNET_ATS_solver_logging_stop(l); /* Stop all preference generation */ GNUNET_ATS_solver_generate_preferences_stop_all(); /* Stop all property generation */ GNUNET_ATS_solver_generate_property_stop_all(); if (opt_print) { GNUNET_log(GNUNET_ERROR_TYPE_INFO, "== Printing log information \n"); GNUNET_ATS_solver_logging_eval(l); } if (opt_save) { GNUNET_log(GNUNET_ERROR_TYPE_INFO, "== Saving log information \n"); GNUNET_ATS_solver_logging_write_to_disk(l, e->log_append_time_stamp, e->log_output_dir); } if (NULL != l) { GNUNET_ATS_solver_logging_free(l); l = NULL; } /* Clean up experiment */ if (NULL != e) { GNUNET_ATS_solvers_experimentation_stop(e); e = NULL; } next = peer_head; while (NULL != (cur = next)) { next = cur->next; GNUNET_CONTAINER_DLL_remove(peer_head, peer_tail, cur); next_a = cur->addr_head; while (NULL != (cur_a = next_a)) { next_a = cur_a->next; GNUNET_CONTAINER_DLL_remove(cur->addr_head, cur->addr_tail, cur_a); GNUNET_free(cur_a); } GNUNET_free(cur); } if (NULL != sh) { GNUNET_ATS_solvers_solver_stop(sh); sh = NULL; } /* Shutdown */ end_now(); } static void experiment_done_cb(struct Experiment *e, struct GNUNET_TIME_Relative duration, int success) { if (GNUNET_OK == success) GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Experiment done successful in %s\n", GNUNET_STRINGS_relative_time_to_string(duration, GNUNET_YES)); else GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Experiment failed \n"); GNUNET_SCHEDULER_add_now(&done, NULL); } static void episode_done_cb(struct Episode *ep) { GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Episode %u done\n", ep->id); } /** * Do shutdown */ static void end_now() { if (NULL != e) { GNUNET_ATS_solvers_experimentation_stop(e); e = NULL; } if (NULL != sh) { GNUNET_ATS_solvers_solver_stop(sh); sh = NULL; } } static void run(void *cls, char * const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg) { enum GNUNET_ATS_Solvers solver; int c; if (NULL == opt_exp_file) { fprintf(stderr, "No experiment given ...\n"); res = 1; end_now(); return; } if (NULL == opt_solver) { fprintf(stderr, "No solver given ...\n"); res = 1; end_now(); return; } if (0 == strcmp(opt_solver, "mlp")) { solver = GNUNET_ATS_SOLVER_MLP; } else if (0 == strcmp(opt_solver, "proportional")) { solver = GNUNET_ATS_SOLVER_PROPORTIONAL; } else if (0 == strcmp(opt_solver, "ril")) { solver = GNUNET_ATS_SOLVER_RIL; } else { fprintf(stderr, "No solver given ..."); res = 1; end_now(); return; } for (c = 0; c < GNUNET_ATS_PropertyCount; c++) default_properties[c] = DEFAULT_REL_QUALITY; for (c = 0; c < GNUNET_ATS_PreferenceCount; c++) default_preferences[c] = DEFAULT_REL_PREFERENCE; /* load experiment */ GNUNET_log(GNUNET_ERROR_TYPE_INFO, "=== Loading experiment\n"); e = GNUNET_ATS_solvers_experimentation_load(opt_exp_file); if (NULL == e) { fprintf(stderr, "Failed to load experiment ...\n"); res = 1; end_now(); return; } /* load solver */ GNUNET_log(GNUNET_ERROR_TYPE_INFO, "=== Loading solver\n"); sh = GNUNET_ATS_solvers_solver_start(solver); if (NULL == sh) { fprintf(stderr, "Failed to start solver ...\n"); end_now(); res = 1; return; } /* start logging */ GNUNET_log(GNUNET_ERROR_TYPE_INFO, "=== Start logging \n"); l = GNUNET_ATS_solver_logging_start(e->log_freq); /* run experiment */ GNUNET_log(GNUNET_ERROR_TYPE_INFO, "=== Running experiment \n"); GNUNET_ATS_solvers_experimentation_run(e, episode_done_cb, experiment_done_cb); /* WAIT */ } /** * Main function of the benchmark * * @param argc argument count * @param argv argument values */ int main(int argc, char *argv[]) { opt_exp_file = NULL; opt_solver = NULL; opt_log = GNUNET_NO; opt_save = GNUNET_NO; res = 0; static struct GNUNET_GETOPT_CommandLineOption options[] = { GNUNET_GETOPT_option_string('s', "solver", gettext_noop("solver to use"), &opt_solver), GNUNET_GETOPT_option_string('e', "experiment" gettext_noop("experiment to use"), &opt_exp_file), GNUNET_GETOPT_option_verbose(&opt_verbose), GNUNET_GETOPT_option_flag('p', "print", gettext_noop("print logging"), &opt_print), GNUNET_GETOPT_option_flag('f', "file", gettext_noop("save logging to disk"), &opt_save), GNUNET_GETOPT_option_flag('d', "dn", gettext_noop("disable normalization"), &opt_disable_normalization), GNUNET_GETOPT_OPTION_END }; GNUNET_PROGRAM_run(argc, argv, "gnunet-ats-solver-eval", NULL, options, &run, argv[0]); return res; } /* end of file ats-testing-experiment.c*/