X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fats%2Fperf_ats_solver.c;h=6fbf547ac2f6a0218a407f72aaf8a01dc2f91a11;hb=a35ab677ed4396f271cfd3fea2051044a6a8b5d7;hp=d4723534d2c635ea147b700c3e3fb3b0aa1b537f;hpb=37e57b03d34d2ef7df9459c5ab0758b9aacdc55f;p=oweals%2Fgnunet.git diff --git a/src/ats/perf_ats_solver.c b/src/ats/perf_ats_solver.c index d4723534d..6fbf547ac 100644 --- a/src/ats/perf_ats_solver.c +++ b/src/ats/perf_ats_solver.c @@ -38,47 +38,6 @@ #define DEFAULT_ADDRESSES 10 #define DEFAULT_ATS_COUNT 2 -#define GNUPLOT_PROP_TEMPLATE "#!/usr/bin/gnuplot \n" \ -"set datafile separator ';' \n" \ -"set title \"Execution time Proportional solver \" \n" \ -"set xlabel \"Number of peers\" \n" \ -"set ylabel \"Execution time in us\" \n" \ -"set grid \n" - -#define GNUPLOT_PROP_UPDATE_TEMPLATE "#!/usr/bin/gnuplot \n" \ -"set datafile separator ';' \n" \ -"set title \"Execution time Proportional solver with updated problem\" \n" \ -"set xlabel \"Number of peers\" \n" \ -"set ylabel \"Execution time in us\" \n" \ -"set grid \n" - -#define GNUPLOT_MLP_TEMPLATE "#!/usr/bin/gnuplot \n" \ -"set datafile separator ';' \n" \ -"set title \"Execution time MLP solver \" \n" \ -"set xlabel \"Number of peers\" \n" \ -"set ylabel \"Execution time in us\" \n" \ -"set grid \n" - -#define GNUPLOT_MLP_UPDATE_TEMPLATE "#!/usr/bin/gnuplot \n" \ -"set datafile separator ';' \n" \ -"set title \"Execution time MLP solver with updated problem\" \n" \ -"set xlabel \"Number of peers\" \n" \ -"set ylabel \"Execution time in us\" \n" \ -"set grid \n" - -#define GNUPLOT_RIL_TEMPLATE "#!/usr/bin/gnuplot \n" \ -"set datafile separator ';' \n" \ -"set title \"Execution time RIL solver \" \n" \ -"set xlabel \"Number of peers\" \n" \ -"set ylabel \"Execution time in us\" \n" \ -"set grid \n" - -#define GNUPLOT_RIL_UPDATE_TEMPLATE "#!/usr/bin/gnuplot \n" \ -"set datafile separator ';' \n" \ -"set title \"Execution time RIL solver with updated problem\" \n" \ -"set xlabel \"Number of peers\" \n" \ -"set ylabel \"Execution time in us\" \n" \ -"set grid \n" /** * Handle for ATS address component @@ -110,13 +69,24 @@ struct PerfHandle * */ struct GNUNET_ATS_PluginEnvironment env; - struct Result *head; - - struct Result *tail; + /** + * Array for results for each iteration with length iterations + */ + struct Iteration *iterations_results; + /** + * The current result + */ struct Result *current_result; + /** + * Current number of peers benchmarked + */ int current_p; + + /** + * Current number of addresses benchmarked + */ int current_a; /** @@ -152,13 +122,23 @@ struct PerfHandle /** * Create gnuplot file */ - int create_plot; + int create_datafile; /** * Measure updates */ int measure_updates; + /** + * Number of iterations + */ + int total_iterations; + + /** + * Current iteration + */ + int current_iteration; + /** * Is a bulk operation running? */ @@ -168,43 +148,156 @@ struct PerfHandle * Is a bulk operation running? */ int expecting_solution; + + /** + * Was the problem just updates? + */ + int performed_update; }; +/** + * Data structure to store results for a single iteration + */ +struct Iteration +{ + struct Result **results_array; + + struct Result **update_results_array; +}; + + +/** + * Result for a solver calculcation + */ struct Result { + /** + * Previous element in the linked list + */ struct Result *prev; + + /** + * Next element in the linked list + */ struct Result *next; + /** + * Number of peers this solution included + */ int peers; + + /** + * Number of addresses per peer this solution included + */ int addresses; + + /** + * Is this an update or a full solution + */ int update; + /** + * Was the solution valid or did the solver fail + */ + int valid; + + /** + * Result of the solver + */ enum GAS_Solver_Additional_Information info; - struct GNUNET_TIME_Relative d_setup; - struct GNUNET_TIME_Relative d_lp; - struct GNUNET_TIME_Relative d_mlp; - struct GNUNET_TIME_Relative d_total; + /** + * Duration of setting up the problem in the solver + */ + struct GNUNET_TIME_Relative d_setup_full; + /** + * Duration of solving the LP problem in the solver + * MLP solver only + */ + struct GNUNET_TIME_Relative d_lp_full; + + /** + * Duration of solving the MLP problem in the solver + * MLP solver only + */ + struct GNUNET_TIME_Relative d_mlp_full; + + /** + * Duration of solving whole problem in the solver + */ + struct GNUNET_TIME_Relative d_total_full; + + /** + * Start time of setting up the problem in the solver + */ struct GNUNET_TIME_Absolute s_setup; + + /** + * Start time of solving the LP problem in the solver + * MLP solver only + */ struct GNUNET_TIME_Absolute s_lp; + + /** + * Start time of solving the MLP problem in the solver + * MLP solver only + */ struct GNUNET_TIME_Absolute s_mlp; + + /** + * Start time of solving whole problem in the solver + */ struct GNUNET_TIME_Absolute s_total; + /** + * End time of setting up the problem in the solver + */ struct GNUNET_TIME_Absolute e_setup; + + /** + * End time of solving the LP problem in the solver + * MLP solver only + */ struct GNUNET_TIME_Absolute e_lp; + + /** + * End time of solving the MLP problem in the solver + * MLP solver only + */ struct GNUNET_TIME_Absolute e_mlp; + + /** + * End time of solving whole problem in the solver + */ struct GNUNET_TIME_Absolute e_total; }; +/** + * Peer used for the benchmarking + */ struct PerfPeer { + /** + * Peer identitity + */ struct GNUNET_PeerIdentity id; + /** + * Head of linked list of addresses used with this peer + */ struct ATS_Address *head; + + /** + * Head of linked list of addresses used with this peer + */ struct ATS_Address *tail; }; + +/** + * ATS performance handle + */ static struct PerfHandle ph; /** @@ -214,11 +307,8 @@ static int ret; /** - * ATS information + * Do shutdown */ -//static struct GNUNET_ATS_Information ats[2]; - - static void end_now (int res) { @@ -227,23 +317,20 @@ end_now (int res) GNUNET_STATISTICS_destroy (ph.stat, GNUNET_NO); ph.stat = NULL; } - /* - if (NULL != addresses) - { - GNUNET_CONTAINER_multihashmap_iterate (addresses, &addr_it, NULL); - GNUNET_CONTAINER_multihashmap_destroy (addresses); - addresses = NULL ; - }*/ - if (NULL != ph.peers) - { - GNUNET_free(ph.peers); - } + + GNUNET_free_non_null (ph.peers); + GNUNET_free_non_null (ph.iterations_results); GAS_normalization_stop (); ret = res; } +/** + * Create a peer used for benchmarking + * + * @param cp the number of the peer + */ static void perf_create_peer (int cp) { @@ -255,34 +342,45 @@ perf_create_peer (int cp) } - +/** + * Perform an update for an address + * + * @param cur the address to update + */ static void perf_update_address (struct ATS_Address *cur) { int r_type; - int r_val; + int abs_val; + double rel_val; r_type = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 2); switch (r_type) { case 0: - r_val = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 100); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Updating peer `%s' address %p type %s val %u\n", - GNUNET_i2s (&cur->peer), cur, "GNUNET_ATS_QUALITY_NET_DELAY", r_val); + abs_val = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 100); + rel_val = (100 + (double) abs_val) / 100; + + GNUNET_log(GNUNET_ERROR_TYPE_INFO, + "Updating peer `%s' address %p type %s abs val %u rel val %.3f\n", + GNUNET_i2s (&cur->peer), cur, + "GNUNET_ATS_QUALITY_NET_DELAY", + abs_val, rel_val); ph.env.sf.s_address_update_property (ph.solver, cur, GNUNET_ATS_QUALITY_NET_DELAY, - r_val, (double) (100 + r_val / 100)); + abs_val, rel_val); break; case 1: - r_val = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 10); + abs_val = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 10); + rel_val = (100 + (double) abs_val) / 100; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Updating peer `%s' address %p type %s val %u\n", - GNUNET_i2s (&cur->peer), cur, "GNUNET_ATS_QUALITY_NET_DISTANCE", r_val); + GNUNET_log(GNUNET_ERROR_TYPE_INFO, + "Updating peer `%s' address %p type %s abs val %u rel val %.3f\n", + GNUNET_i2s (&cur->peer), cur, "GNUNET_ATS_QUALITY_NET_DISTANCE", + abs_val, rel_val); ph.env.sf.s_address_update_property (ph.solver, cur, GNUNET_ATS_QUALITY_NET_DISTANCE, - r_val, (double) (100 + r_val) / 100); + abs_val, rel_val); break; default: break; @@ -291,29 +389,29 @@ perf_update_address (struct ATS_Address *cur) } - static void -bandwidth_changed_cb (void *cls, struct ATS_Address *address) +bandwidth_changed_cb (void *cls, + struct ATS_Address *address) { - if (0 == ntohl(address->assigned_bw_out.value__) && - 0 == ntohl(address->assigned_bw_in.value__)) + if ( (0 == address->assigned_bw_out) && (0 == address->assigned_bw_in) ) return; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Bandwidth changed addresses %s %p to %llu Bps out / %llu Bps in\n", - GNUNET_i2s (&address->peer), - address, - ntohl(address->assigned_bw_out.value__), - ntohl(address->assigned_bw_in.value__)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "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 (GNUNET_YES == ph.bulk_running) GNUNET_break (0); return; } + const double * get_preferences_cb (void *cls, const struct GNUNET_PeerIdentity *id) { - return GAS_normalization_get_preferences (id); + return GAS_normalization_get_preferences_by_peer (id); } @@ -335,17 +433,31 @@ perf_address_initial_update (void *solver, struct GNUNET_CONTAINER_MultiPeerMap * addresses, struct ATS_Address *address) { + double delay; + double distance; + uint32_t random = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 100); + delay = (100 + (double) random) / 100; ph.env.sf.s_address_update_property (solver, address, GNUNET_ATS_QUALITY_NET_DELAY, - 100, - (double) (100 + GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 100)) - / 100); + 100, delay); + + random = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 100); + distance = (100 + (double) random) / 100; ph.env.sf.s_address_update_property (solver, address, - GNUNET_ATS_QUALITY_NET_DISTANCE, 10, - (double) (100 + GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 100)) - / 100); + GNUNET_ATS_QUALITY_NET_DISTANCE, 10, distance); + + GNUNET_log(GNUNET_ERROR_TYPE_INFO, + "Initial update address %p : %.2f %.2f\n", address, delay, distance); } +/** + * Update a certain percentage of peers + * + * @param cp the current number of peers + * @param ca the current number of addresses + * @param percentage_peers the percentage of peers to update + */ + static void perf_update_all_addresses (unsigned int cp, unsigned int ca, unsigned int percentage_peers) { @@ -391,14 +503,19 @@ perf_update_all_addresses (unsigned int cp, unsigned int ca, unsigned int percen { if (c_cur_a == r) perf_update_address (cur_address); - c_cur_a ++; } } } } - +/** + * Create an address for a peer + * + * @param cp index of the peer + * @param ca index of the address + * @return the address + */ static struct ATS_Address * perf_create_address (int cp, int ca) { @@ -411,6 +528,14 @@ perf_create_address (int cp, int ca) return a; } + +/** + * Information callback for the solver + * + * @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, @@ -443,7 +568,7 @@ solver_info_cb (void *cls, switch (op) { case GAS_OP_SOLVE_START: - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Solver notifies `%s' with result `%s' `%s'\n", "GAS_OP_SOLVE_START", (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL", add_info); if (GNUNET_NO == ph.expecting_solution) @@ -455,27 +580,43 @@ solver_info_cb (void *cls, if ((GAS_STAT_SUCCESS == stat) && (NULL == ph.current_result)) { + tmp = GNUNET_new (struct Result); /* Create new result */ - tmp = GNUNET_malloc (sizeof (struct Result)); - ph.current_result = tmp; - GNUNET_CONTAINER_DLL_insert_tail(ph.head, ph.tail, tmp); + if ((add == GAS_INFO_UPDATED) || (GNUNET_YES == ph.performed_update)) + { + ph.current_result = tmp; + //fprintf (stderr,"UPDATE %u %u\n",ph.current_iteration-1, ph.current_p); + ph.iterations_results[ph.current_iteration-1].update_results_array[ph.current_p] = tmp; + } + else + { + ph.current_result = tmp; + //fprintf (stderr,"FULL %u %u\n",ph.current_iteration-1, ph.current_p); + ph.iterations_results[ph.current_iteration-1].results_array[ph.current_p] = tmp; + } + ph.current_result->addresses = ph.current_a; ph.current_result->peers = ph.current_p; ph.current_result->s_total = GNUNET_TIME_absolute_get(); - ph.current_result->d_total = GNUNET_TIME_UNIT_FOREVER_REL; - ph.current_result->d_setup = GNUNET_TIME_UNIT_FOREVER_REL; - ph.current_result->d_lp = GNUNET_TIME_UNIT_FOREVER_REL; - ph.current_result->d_mlp = GNUNET_TIME_UNIT_FOREVER_REL; + ph.current_result->d_total_full = GNUNET_TIME_UNIT_FOREVER_REL; + ph.current_result->d_setup_full = GNUNET_TIME_UNIT_FOREVER_REL; + ph.current_result->d_lp_full = GNUNET_TIME_UNIT_FOREVER_REL; + ph.current_result->d_mlp_full = GNUNET_TIME_UNIT_FOREVER_REL; ph.current_result->info = add; - if (add == GAS_INFO_UPDATED) + if ((add == GAS_INFO_UPDATED) || (GNUNET_YES == ph.performed_update)) + { ph.current_result->update = GNUNET_YES; + } else + { ph.current_result->update = GNUNET_NO; + } + } return; case GAS_OP_SOLVE_STOP: - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_STOP", + GNUNET_log(GNUNET_ERROR_TYPE_INFO, + "Solver notifies `%s' with result `%s', `%s'\n", "GAS_OP_SOLVE_STOP", (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL", add_info); if ((GNUNET_NO == ph.expecting_solution) || (NULL == ph.current_result)) { @@ -483,18 +624,24 @@ solver_info_cb (void *cls, GNUNET_break (0); return; } + + if (GAS_STAT_SUCCESS == stat) + ph.current_result->valid = GNUNET_YES; + else + ph.current_result->valid = GNUNET_NO; + if (NULL != ph.current_result) { /* Finalize result */ ph.current_result->e_total = GNUNET_TIME_absolute_get (); - ph.current_result->d_total = GNUNET_TIME_absolute_get_difference ( + ph.current_result->d_total_full = GNUNET_TIME_absolute_get_difference ( ph.current_result->s_total, ph.current_result->e_total); } ph.current_result = NULL; return; case GAS_OP_SOLVE_SETUP_START: - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_SETUP_START", (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL"); if ((GNUNET_NO == ph.expecting_solution) || (NULL == ph.current_result)) @@ -502,11 +649,17 @@ solver_info_cb (void *cls, GNUNET_break(0); return; } + + if (GAS_STAT_SUCCESS == stat) + ph.current_result->valid = GNUNET_YES; + else + ph.current_result->valid = GNUNET_NO; + ph.current_result->s_setup = GNUNET_TIME_absolute_get (); return; case GAS_OP_SOLVE_SETUP_STOP: - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_SETUP_STOP", (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL"); if ((GNUNET_NO == ph.expecting_solution) || (NULL == ph.current_result)) @@ -514,13 +667,19 @@ solver_info_cb (void *cls, GNUNET_break(0); return; } + + if (GAS_STAT_SUCCESS == stat) + ph.current_result->valid = GNUNET_YES; + else + ph.current_result->valid = GNUNET_NO; + ph.current_result->e_setup = GNUNET_TIME_absolute_get (); - ph.current_result->d_setup = GNUNET_TIME_absolute_get_difference ( + ph.current_result->d_setup_full = GNUNET_TIME_absolute_get_difference ( ph.current_result->s_setup, ph.current_result->e_setup); return; case GAS_OP_SOLVE_MLP_LP_START: - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_LP_START", (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL"); if ((GNUNET_NO == ph.expecting_solution) || (NULL == ph.current_result)) @@ -528,10 +687,16 @@ solver_info_cb (void *cls, GNUNET_break(0); return; } + + if (GAS_STAT_SUCCESS == stat) + ph.current_result->valid = GNUNET_YES; + else + ph.current_result->valid = GNUNET_NO; + ph.current_result->s_lp = GNUNET_TIME_absolute_get (); return; case GAS_OP_SOLVE_MLP_LP_STOP: - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_LP_STOP", (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL"); if ((GNUNET_NO == ph.expecting_solution) || (NULL == ph.current_result)) @@ -539,13 +704,19 @@ solver_info_cb (void *cls, GNUNET_break(0); return; } + + if (GAS_STAT_SUCCESS == stat) + ph.current_result->valid = GNUNET_YES; + else + ph.current_result->valid = GNUNET_NO; + ph.current_result->e_lp = GNUNET_TIME_absolute_get (); - ph.current_result->d_lp = GNUNET_TIME_absolute_get_difference ( + ph.current_result->d_lp_full = GNUNET_TIME_absolute_get_difference ( ph.current_result->s_lp, ph.current_result->e_lp); return; case GAS_OP_SOLVE_MLP_MLP_START: - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_MLP_START", (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL"); if ((GNUNET_NO == ph.expecting_solution) || (NULL == ph.current_result)) @@ -553,10 +724,16 @@ solver_info_cb (void *cls, GNUNET_break(0); return; } + + if (GAS_STAT_SUCCESS == stat) + ph.current_result->valid = GNUNET_YES; + else + ph.current_result->valid = GNUNET_NO; + ph.current_result->s_mlp = GNUNET_TIME_absolute_get (); return; case GAS_OP_SOLVE_MLP_MLP_STOP: - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_MLP_STOP", (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL"); if ((GNUNET_NO == ph.expecting_solution) || (NULL == ph.current_result)) @@ -564,250 +741,279 @@ solver_info_cb (void *cls, GNUNET_break(0); return; } + + if (GAS_STAT_SUCCESS == stat) + ph.current_result->valid = GNUNET_YES; + else + ph.current_result->valid = GNUNET_NO; + ph.current_result->e_mlp = GNUNET_TIME_absolute_get (); - ph.current_result->d_mlp = GNUNET_TIME_absolute_get_difference ( + ph.current_result->d_mlp_full = GNUNET_TIME_absolute_get_difference ( ph.current_result->s_mlp, ph.current_result->e_mlp); return; case GAS_OP_SOLVE_UPDATE_NOTIFICATION_START: - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + GNUNET_log(GNUNET_ERROR_TYPE_INFO, "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, + GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP", (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL"); + if (GAS_STAT_SUCCESS != stat) + { + GNUNET_log(GNUNET_ERROR_TYPE_ERROR, + "Solver `%s' failed to update problem with %u peers and %u address!\n", + ph.ats_string, ph.current_p, ph.current_a); + } + return; default: break; } } +/** + * Evaluate results for a specific iteration + * + * @param iteration the iteration to evaluate + */ static void -write_gnuplot_script (char * data_fn, int full) +evaluate (int iteration) { - struct GNUNET_DISK_FileHandle *f; - char * gfn; - char *data; - char *template; - - /* Write header */ - switch (ph.ats_mode) { - case MODE_PROPORTIONAL: - if (GNUNET_YES == full) - template = GNUPLOT_PROP_TEMPLATE; - else - template = GNUPLOT_PROP_UPDATE_TEMPLATE; - break; - case MODE_MLP: - if (GNUNET_YES == full) - template = GNUPLOT_MLP_TEMPLATE; - else - template = GNUPLOT_MLP_UPDATE_TEMPLATE; - break; - case MODE_RIL: - if (GNUNET_YES == full) - template = GNUPLOT_RIL_TEMPLATE; - else - template = GNUPLOT_RIL_UPDATE_TEMPLATE; - break; - default: + struct Result *cur; + int cp; + + for (cp = ph.N_peers_start; cp <= ph.N_peers_end; cp ++) + { + cur = ph.iterations_results[ph.current_iteration-1].results_array[cp]; + if (0 == cp) + continue; + if (NULL == cur) + { GNUNET_break (0); - return; - } + fprintf (stderr, + "Missing result for %u peers\n", cp); + } - if (GNUNET_YES == full) - GNUNET_asprintf (&gfn, "perf_%s_full_%u_%u_%u.gnuplot", ph.ats_string, ph.N_peers_start, ph.N_peers_end, ph.N_address); - else - GNUNET_asprintf (&gfn, "perf_%s_update_%u_%u_%u.gnuplot", ph.ats_string, ph.N_peers_start, ph.N_peers_end, ph.N_address); - f = GNUNET_DISK_file_open (gfn, - GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE, - GNUNET_DISK_PERM_USER_EXEC | GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE); - if (NULL == f) - { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot open gnuplot file `%s'\n", gfn); - GNUNET_free (gfn); - return; - } + if (GNUNET_NO == cur->valid) + { + fprintf (stderr, + "Total time to solve %s for %u peers %u addresses: %s\n", + (GNUNET_YES == cur->update) ? "updated" : "full", + cur->peers, cur->addresses, "Failed to solve!"); + continue; + } - if (GNUNET_SYSERR == GNUNET_DISK_file_write(f, template, strlen(template))) - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot write data to plot file `%s'\n", gfn); - data = NULL; - if (MODE_PROPORTIONAL == ph.ats_mode) - { - GNUNET_asprintf (&data, "plot '%s' using 1:%u with lines title 'Total time to solve'\n" \ - "pause -1", - data_fn, 3); - } - else if (MODE_MLP == ph.ats_mode) - { - GNUNET_asprintf (&data, "plot '%s' using 1:%u with lines title 'Total time to solve',\\\n" \ - "'%s' using 1:%u with lines title 'Time to setup',\\\n" - "'%s' using 1:%u with lines title 'Time to solve LP',\\\n" - "'%s' using 1:%u with lines title 'Total time to solve MLP'\n" \ - "pause -1", - data_fn, 3, - data_fn, 4, - data_fn, 5, - data_fn, 6); - } - else if (MODE_RIL == ph.ats_mode) - { - GNUNET_asprintf (&data, "plot '%s' using 1:%u with lines title 'Total time to solve'\n" \ - "pause -1", - data_fn, 3); - } + if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us != cur->d_total_full.rel_value_us) + { + fprintf (stderr, + "Total time to solve %s for %u peers %u addresses: %llu us\n", + (GNUNET_YES == cur->update) ? "updated" : "full", + cur->peers, cur->addresses, + (unsigned long long) cur->d_total_full.rel_value_us); + } - if ((NULL != data) && (GNUNET_SYSERR == GNUNET_DISK_file_write(f, data, strlen(data)))) - { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot write data to plot file `%s'\n", gfn); - GNUNET_free (data); - } - if (GNUNET_SYSERR == GNUNET_DISK_file_close(f)) - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot close gnuplot file `%s'\n", gfn); - else - GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Data successfully written to plot file `%s'\n", gfn); - GNUNET_free (gfn); + if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us != cur->d_setup_full.rel_value_us) + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "Total time to setup %s %u peers %u addresses: %llu us\n", + (GNUNET_YES == cur->update) ? "updated" : "full", + cur->peers, cur->addresses, + (unsigned long long) cur->d_setup_full.rel_value_us); + } -} + if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us != cur->d_lp_full.rel_value_us) + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "Total time to solve %s LP for %u peers %u addresses: %llu us\n", + (GNUNET_YES == cur->update) ? "updated" : "full", + cur->peers, + cur->addresses, + (unsigned long long )cur->d_lp_full.rel_value_us); + } + if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us != cur->d_mlp_full.rel_value_us) + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "Total time to solve %s MLP for %u peers %u addresses: %llu us\n", + (GNUNET_YES == cur->update) ? "updated" : "full", + cur->peers, cur->addresses, + (unsigned long long )cur->d_mlp_full.rel_value_us); + } + } + +} +/** + * Evaluate average results for all iterations + */ static void -evaluate () +write_all_iterations (void) { + int c_iteration; + int c_peer; + struct GNUNET_DISK_FileHandle *f_full; struct GNUNET_DISK_FileHandle *f_update; char * data_fn_full; char * data_fn_update; char * data; - struct Result *cur; - struct Result *next; - char * str_d_total; - char * str_d_setup; - char * str_d_lp; - char * str_d_mlp; f_full = NULL; f_update = NULL; data_fn_full = NULL; - if (ph.create_plot) + if (GNUNET_NO == ph.create_datafile) + return; + + GNUNET_asprintf (&data_fn_full, + "perf_%s_full_%u-%u_%u_%u.data", + ph.ats_string, + ph.total_iterations, + ph.N_peers_start, + ph.N_peers_end, + ph.N_address); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Using data file `%s'\n", + data_fn_full); + + f_full = GNUNET_DISK_file_open (data_fn_full, + GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE, + GNUNET_DISK_PERM_USER_EXEC | GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE); + if (NULL == f_full) { - GNUNET_asprintf (&data_fn_full, "perf_%s_full_%u_%u_%u.data", ph.ats_string, ph.N_peers_start, ph.N_peers_end, ph.N_address); - f_full = GNUNET_DISK_file_open (data_fn_full, - GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE, - GNUNET_DISK_PERM_USER_EXEC | GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE); - if (NULL == f_full) - { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot open gnuplot file `%s'\n", data_fn_full); - GNUNET_free (data_fn_full); - return; - } - data = "#peers;addresses;time total in us;#time setup in us;#time lp in us;#time mlp in us;\n"; - if (GNUNET_SYSERR == GNUNET_DISK_file_write(f_full, data, strlen(data))) - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot write data to log file `%s'\n", data_fn_full); - write_gnuplot_script (data_fn_full, GNUNET_YES); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Cannot open data file `%s'\n", + data_fn_full); + GNUNET_free (data_fn_full); + return; } + data = "#peers;addresses;time total in us;#time setup in us;#time lp in us;#time mlp in us;\n"; + if (GNUNET_SYSERR == GNUNET_DISK_file_write(f_full, data, strlen(data))) + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Cannot write data to log file `%s'\n", + data_fn_full); + data_fn_update = NULL; - if ((ph.create_plot) && (GNUNET_YES == ph.measure_updates)) + if (GNUNET_YES == ph.measure_updates) { - GNUNET_asprintf (&data_fn_update, "perf_%s_update_%u_%u_%u.data", ph.ats_string, ph.N_peers_start, ph.N_peers_end, ph.N_address); + GNUNET_asprintf (&data_fn_update, "perf_%s_update_%u-%u_%u_%u.data", + ph.ats_string, + ph.total_iterations, + ph.N_peers_start, + ph.N_peers_end, + ph.N_address); f_update = GNUNET_DISK_file_open (data_fn_update, GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_PERM_USER_EXEC | GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE); if (NULL == f_update) { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot open gnuplot file `%s'\n", data_fn_update); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Cannot open gnuplot file `%s'\n", data_fn_update); GNUNET_free (data_fn_update); + if (NULL != f_full) + GNUNET_DISK_file_close (f_full); + GNUNET_free (data_fn_full); return; } + + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Using update data file `%s'\n", + data_fn_update); + data = "#peers;addresses;time total in us;#time setup in us;#time lp in us;#time mlp in us;\n"; - if (GNUNET_SYSERR == GNUNET_DISK_file_write(f_update, data, strlen(data))) - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot write data to log file `%s'\n", data_fn_update); - write_gnuplot_script (data_fn_update, GNUNET_NO); + if (GNUNET_SYSERR == GNUNET_DISK_file_write (f_update, data, strlen(data))) + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Cannot write data to log file `%s'\n", + data_fn_update); } - next = ph.head; - while (NULL != (cur = next)) + for (c_peer = ph.N_peers_start; c_peer <= ph.N_peers_end; c_peer ++) { - next = cur->next; - str_d_total = NULL; - str_d_setup = NULL; - str_d_lp = NULL; - str_d_mlp = NULL; - - /* Print log */ - if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us != cur->d_total.rel_value_us) - { - fprintf (stderr, "Total time to solve %s for %u peers %u addresses: %llu us\n", - (GNUNET_YES == cur->update) ? "updated" : "full", - cur->peers, cur->addresses, (unsigned long long )cur->d_total.rel_value_us); - GNUNET_asprintf(&str_d_total, "%llu", (unsigned long long )cur->d_total.rel_value_us); - } - else - GNUNET_asprintf(&str_d_total, "-1"); - if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us != cur->d_setup.rel_value_us) + char * data_str; + char * data_tmp; + char * data_upd_str; + char * data_upd_tmp; + GNUNET_asprintf(&data_str, "%u;%u",c_peer, ph.N_address); + if (ph.measure_updates) + GNUNET_asprintf(&data_upd_str, "%u;%u",c_peer, ph.N_address); + for (c_iteration = 0; c_iteration < ph.total_iterations; c_iteration ++) { - fprintf (stderr, "Total time to setup %s %u peers %u addresses: %llu us\n", - (GNUNET_YES == cur->update) ? "updated" : "full", - cur->peers, cur->addresses, (unsigned long long )cur->d_setup.rel_value_us); - GNUNET_asprintf(&str_d_setup, "%llu", (unsigned long long )cur->d_setup.rel_value_us); - } - else - GNUNET_asprintf(&str_d_setup, "-1"); - if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us != cur->d_lp.rel_value_us) - { - fprintf (stderr, "Total time to solve %s LP for %u peers %u addresses: %llu us\n", - (GNUNET_YES == cur->update) ? "updated" : "full", - cur->peers, cur->addresses, (unsigned long long )cur->d_lp.rel_value_us); - GNUNET_asprintf(&str_d_lp, "%llu", (unsigned long long )cur->d_lp.rel_value_us); - } - else - GNUNET_asprintf(&str_d_lp, "-1"); - if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us != cur->d_mlp.rel_value_us) - { - fprintf (stderr, "Total time to solve %s MLP for %u peers %u addresses: %llu us\n", - (GNUNET_YES == cur->update) ? "updated" : "full", - cur->peers, cur->addresses, (unsigned long long )cur->d_mlp.rel_value_us); - GNUNET_asprintf(&str_d_mlp, "%llu", (unsigned long long )cur->d_mlp.rel_value_us); - } - else - GNUNET_asprintf(&str_d_mlp, "-1"); + struct Result *cur_full_res; + struct Result *cur_upd_res; - data = NULL; - if (GNUNET_YES == ph.create_plot) - { - GNUNET_asprintf(&data,"%u;%u;%s;%s;%s;%s\n", - cur->peers, cur->addresses, - str_d_total, - str_d_setup, - str_d_lp, - str_d_mlp); - if (cur->update == GNUNET_NO) + + //fprintf (stderr, "P: %u I: %u == %p \n", c_peer, c_iteration, cur_res); + cur_full_res = ph.iterations_results[c_iteration].results_array[c_peer]; + if (c_peer == 0) + continue; + if (NULL == cur_full_res) + continue; + + if (ph.measure_updates) { - if (GNUNET_SYSERR == GNUNET_DISK_file_write(f_full, data, strlen(data))) - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot write data to log file `%s'\n", data_fn_full); + cur_upd_res = ph.iterations_results[c_iteration].update_results_array[c_peer]; + data_upd_tmp = GNUNET_strdup (data_upd_str); + GNUNET_free (data_upd_str); + if (GNUNET_YES == cur_full_res->valid) + { + GNUNET_asprintf (&data_upd_str, "%s;%llu", data_upd_tmp, + (NULL == cur_upd_res) ? 0 : cur_upd_res->d_total_full.rel_value_us); + } + else + { + GNUNET_asprintf (&data_upd_str, "%s;", data_upd_tmp); + } + GNUNET_free (data_upd_tmp); + } - if ((cur->update == GNUNET_YES) && (NULL != f_update)) + + //fprintf (stderr, "P: %u I: %u: P %i A %i\n", c_peer, c_iteration, cur_res->peers, cur_res->addresses); + //fprintf (stderr, "D total: %llu\n", (long long unsigned int) cur_res->d_total.rel_value_us); + + data_tmp = GNUNET_strdup (data_str); + GNUNET_free (data_str); + if (GNUNET_YES == cur_full_res->valid) { - if (GNUNET_SYSERR == GNUNET_DISK_file_write(f_update, data, strlen(data))) - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot write data to log file `%s'\n", data_fn_update); + GNUNET_asprintf (&data_str, "%s;%llu", data_tmp, + cur_full_res->d_total_full.rel_value_us); } - GNUNET_free (data); + else + { + GNUNET_asprintf (&data_str, "%s;", data_tmp); + } + + GNUNET_free (data_tmp); } - GNUNET_free_non_null (str_d_total); - GNUNET_free_non_null (str_d_setup); - GNUNET_free_non_null (str_d_lp); - GNUNET_free_non_null (str_d_mlp); + data_tmp = GNUNET_strdup (data_str); + GNUNET_free (data_str); + GNUNET_asprintf (&data_str, "%s\n", data_tmp); + GNUNET_free (data_tmp); - GNUNET_CONTAINER_DLL_remove (ph.head, ph.tail, cur); - GNUNET_free (cur); + fprintf (stderr, "Result full solution: %s\n", data_str); + if (GNUNET_SYSERR == GNUNET_DISK_file_write (f_full, data_str, strlen(data_str))) + GNUNET_break (0); + GNUNET_free (data_str); + + if (ph.measure_updates) + { + data_upd_tmp = GNUNET_strdup (data_upd_str); + GNUNET_free (data_upd_str); + GNUNET_asprintf (&data_upd_str, "%s\n", data_upd_tmp); + GNUNET_free (data_upd_tmp); + + fprintf (stderr, "Result updated solution: `%s'\n", data_upd_str); + if (GNUNET_SYSERR == GNUNET_DISK_file_write (f_update, data_upd_str, strlen(data_upd_str))) + GNUNET_break (0); + GNUNET_free (data_upd_str); + } } if ((NULL != f_full) && (GNUNET_SYSERR == GNUNET_DISK_file_close (f_full))) @@ -821,8 +1027,12 @@ evaluate () GNUNET_free_non_null (data_fn_update); } +/** + * Run a performance iteration + */ + static void -perf_run () +perf_run_iteration (void) { struct ATS_Address *cur; struct ATS_Address *next; @@ -831,17 +1041,20 @@ perf_run () int count_p = ph.N_peers_end; int count_a = ph.N_address; struct ATS_Address * cur_addr; + uint32_t net; - + ph.iterations_results[ph.current_iteration-1].results_array = GNUNET_malloc ((count_p + 1) * sizeof (struct Result *)); + if (ph.measure_updates) + ph.iterations_results[ph.current_iteration-1].update_results_array = GNUNET_malloc ((count_p + 1) * sizeof (struct Result *)); ph.peers = GNUNET_malloc ((count_p) * sizeof (struct PerfPeer)); - for (cp = 0; cp < count_p; cp++) perf_create_peer (cp); GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "Added %u peers\n", cp); + "Iteration %u of %u, added %u peers\n", ph.current_iteration, ph.total_iterations, cp); for (cp = 0; cp < count_p; cp++) { + fprintf (stderr,"%u..", cp); if (GNUNET_NO == ph.bulk_running) { ph.bulk_running = GNUNET_YES; @@ -852,11 +1065,25 @@ perf_run () { cur_addr = perf_create_address (cp, ca); /* Add address */ - ph.env.sf.s_add (ph.solver, cur_addr, GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_ATS_NetworkTypeCount)); + + /* Random network selection */ + //net = 1 + GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_ATS_NetworkTypeCount - 1); + /* Random equally distributed network selection */ + net = 1 + (ca % (GNUNET_ATS_NetworkTypeCount - 1)); + /* fprintf (stderr, "Network: %u `%s'\n", + * mod_net , GNUNET_ATS_print_network_type(mod_net)); */ + + cur_addr->atsi = GNUNET_new (struct GNUNET_ATS_Information); + cur_addr->atsi_count = 1; + cur_addr->atsi[0].type = htonl (GNUNET_ATS_NETWORK_TYPE); + cur_addr->atsi[0].value = htonl (net); + ph.env.sf.s_add (ph.solver, cur_addr, net); + ph.current_a = ca + 1; perf_address_initial_update (ph.solver, ph.addresses, cur_addr); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Adding address for peer %u address %u\n", cp, ca); + GNUNET_log(GNUNET_ERROR_TYPE_INFO, + "Adding address for peer %u address %u in network %s\n", cp, ca, + GNUNET_ATS_print_network_type(net)); } /* Notify solver about request */ ph.env.sf.s_get (ph.solver, &ph.peers[cp].id); @@ -871,9 +1098,7 @@ perf_run () ph.env.sf.s_bulk_stop (ph.solver); } else - { GNUNET_break (0); - } /* Problem is solved by the solver here due to unlocking */ ph.expecting_solution = GNUNET_NO; @@ -886,6 +1111,7 @@ perf_run () "Updating problem with %u peers and %u addresses\n", cp + 1, ca); ph.expecting_solution = GNUNET_YES; + ph.performed_update = GNUNET_YES; if (GNUNET_NO == ph.bulk_running) { ph.bulk_running = GNUNET_YES; @@ -895,12 +1121,13 @@ perf_run () ph.bulk_running = GNUNET_NO; ph.env.sf.s_bulk_stop (ph.solver); /* Problem is solved by the solver here due to unlocking */ + ph.performed_update = GNUNET_NO; ph.expecting_solution = GNUNET_NO; } GNUNET_assert (GNUNET_NO == ph.bulk_running); } } - + fprintf (stderr,"\n"); GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Done, cleaning up addresses\n"); if (GNUNET_NO == ph.bulk_running) @@ -920,13 +1147,14 @@ perf_run () ph.env.sf.s_del (ph.solver, cur, GNUNET_NO); next = cur->next; GNUNET_CONTAINER_DLL_remove(ph.peers[cp].head, ph.peers[cp].tail, cur); - GNUNET_free(cur); + GNUNET_free_non_null (cur->atsi); + GNUNET_free (cur); } - } - GNUNET_free(ph.peers); - evaluate (); + GNUNET_log(GNUNET_ERROR_TYPE_INFO, + "Iteration done\n"); + GNUNET_free(ph.peers); } @@ -944,6 +1172,7 @@ run (void *cls, char * const *args, const char *cfgfile, unsigned long long quotas_in[GNUNET_ATS_NetworkTypeCount]; unsigned long long quotas_out[GNUNET_ATS_NetworkTypeCount]; int c; + int c2; /* Extract test name */ if (NULL == (sep = (strstr (src_filename,".c")))) @@ -1000,12 +1229,13 @@ run (void *cls, char * const *args, const char *cfgfile, if (0 == ph.N_address) ph.N_address = DEFAULT_ADDRESSES; + if (ph.N_peers_start != ph.N_peers_end) - fprintf (stderr, "Benchmarking solver `%s' with %u to %u peers and %u addresses\n", - ph.ats_string, ph.N_peers_start, ph.N_peers_end, ph.N_address); + fprintf (stderr, "Benchmarking solver `%s' with %u to %u peers and %u addresses in %u iterations\n", + ph.ats_string, ph.N_peers_start, ph.N_peers_end, ph.N_address, ph.total_iterations); else - fprintf (stderr, "Benchmarking solver `%s' with %u peers and %u addresses\n", - ph.ats_string, ph.N_peers_end, ph.N_address); + fprintf (stderr, "Benchmarking solver `%s' with %u peers and %u addresses in %u iterations\n", + ph.ats_string, ph.N_peers_end, ph.N_address, ph.total_iterations); if (0 == ph.opt_update_percent) ph.opt_update_percent = DEFAULT_UPDATE_PERCENTAGE; @@ -1026,6 +1256,9 @@ run (void *cls, char * const *args, const char *cfgfile, return; } + /* Create array of DLL to store results for iterations */ + ph.iterations_results = GNUNET_malloc (sizeof (struct Iteration) * ph.total_iterations); + /* Load solver */ ph.env.cfg = solver_cfg; ph.stat = GNUNET_STATISTICS_create ("ats", cfg); @@ -1061,17 +1294,48 @@ run (void *cls, char * const *args, const char *cfgfile, return; } - /* Do work */ - perf_run (); + /* Do the benchmark */ + for (ph.current_iteration = 1; ph.current_iteration <= ph.total_iterations; ph.current_iteration++) + { + fprintf (stderr, "Iteration %u of %u starting\n", ph.current_iteration, ph.total_iterations); + perf_run_iteration (); + evaluate (ph.current_iteration); + fprintf (stderr, "Iteration %u of %u done\n", ph.current_iteration, ph.total_iterations); + } + if (ph.create_datafile) + write_all_iterations (); /* Unload solver*/ GNUNET_log(GNUNET_ERROR_TYPE_INFO, _("Unloading solver `%s'\n"), ph.ats_string); GNUNET_PLUGIN_unload (plugin, ph.solver); GNUNET_free (plugin); + for (c = 0; c < ph.total_iterations; c++ ) + { + for (c2 = ph.N_peers_start; c2 < ph.N_peers_end; c2++ ) + { + if (0 == c2) + continue; + if (ph.measure_updates) + GNUNET_free_non_null (ph.iterations_results[c].update_results_array[c2]); + GNUNET_free (ph.iterations_results[c].results_array[c2]); + } + if (ph.measure_updates) + GNUNET_free (ph.iterations_results[c].update_results_array); + GNUNET_free(ph.iterations_results[c].results_array); + } + GNUNET_free (ph.iterations_results); + GNUNET_CONFIGURATION_destroy (solver_cfg); + GNUNET_STATISTICS_destroy (ph.stat, GNUNET_NO); ph.solver = NULL; } +/** + * Main function of the benchmark + * + * @param argc argument count + * @param argv argument values + */ int main (int argc, char *argv[]) { @@ -1081,8 +1345,9 @@ main (int argc, char *argv[]) ph.N_peers_end = 0; ph.N_address = 0; ph.ats_string = NULL; - ph.create_plot = GNUNET_NO; + ph.create_datafile = GNUNET_NO; ph.measure_updates = GNUNET_NO; + ph.total_iterations = 1; static struct GNUNET_GETOPT_CommandLineOption options[] = { { 'a', "addresses", NULL, @@ -1094,12 +1359,15 @@ main (int argc, char *argv[]) { 'e', "end", NULL, gettext_noop ("end with peer"), 1, &GNUNET_GETOPT_set_uint, &ph.N_peers_end }, + { 'i', "iterations", NULL, + gettext_noop ("number of iterations used for averaging (default: 1)"), + 1, &GNUNET_GETOPT_set_uint, &ph.total_iterations }, { 'p', "percentage", NULL, gettext_noop ("update a fix percentage of addresses"), 1, &GNUNET_GETOPT_set_uint, &ph.opt_update_percent }, - { 'g', "gnuplot", NULL, - gettext_noop ("create GNUplot file"), - 0, &GNUNET_GETOPT_set_one, &ph.create_plot}, + { 'd', "data", NULL, + gettext_noop ("create data file"), + 0, &GNUNET_GETOPT_set_one, &ph.create_datafile}, { 'u', "update", NULL, gettext_noop ("measure updates"), 0, &GNUNET_GETOPT_set_one, &ph.measure_updates}, @@ -1107,7 +1375,6 @@ main (int argc, char *argv[]) }; GNUNET_PROGRAM_run (argc, argv, argv[0], NULL, options, &run, argv[0]); - return ret; }