X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Frps%2Fgnunet-rps-profiler.c;h=36a167203978d9fdc532dd9bf776e04b5d9b5c3b;hb=31bef70568177a32929331e73a18e852bee7bd08;hp=02259d628bb7d29a39e2582288ef02c83399cd55;hpb=08159b18571f395aace0cfa11562517109900305;p=oweals%2Fgnunet.git diff --git a/src/rps/gnunet-rps-profiler.c b/src/rps/gnunet-rps-profiler.c index 02259d628..36a167203 100644 --- a/src/rps/gnunet-rps-profiler.c +++ b/src/rps/gnunet-rps-profiler.c @@ -14,6 +14,8 @@ 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 rps/test_rps.c @@ -83,14 +85,61 @@ enum STAT_TYPE STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL, /* 6 */ STAT_TYPE_ISSUED_PUSH_SEND, /* 7 */ STAT_TYPE_ISSUED_PULL_REQ, /* 8 */ - STAT_TYPE_ISSUED_PULL_REP, /* 9 */ - STAT_TYPE_SENT_PUSH_SEND, /* 10 */ - STAT_TYPE_SENT_PULL_REQ, /* 11 */ - STAT_TYPE_SENT_PULL_REP, /* 12 */ - STAT_TYPE_RECV_PUSH_SEND, /* 13 */ - STAT_TYPE_RECV_PULL_REQ, /* 14 */ - STAT_TYPE_RECV_PULL_REP, /* 15 */ - STAT_TYPE_MAX, /* 16 */ + STAT_TYPE_ISSUED_PULL_REQ_MH, /* 9 */ + STAT_TYPE_ISSUED_PULL_REP, /* 10 */ + STAT_TYPE_SENT_PUSH_SEND, /* 11 */ + STAT_TYPE_SENT_PULL_REQ, /* 12 */ + STAT_TYPE_SENT_PULL_REQ_MH, /* 13 */ + STAT_TYPE_SENT_PULL_REP, /* 14 */ + STAT_TYPE_RECV_PUSH_SEND, /* 15 */ + STAT_TYPE_RECV_PULL_REQ, /* 16 */ + STAT_TYPE_RECV_PULL_REQ_MH, /* 17 */ + STAT_TYPE_RECV_PULL_REP, /* 18 */ + STAT_TYPE_RECV_PULL_REP_MH, /* 19 */ + STAT_TYPE_VIEW_SIZE, /* 20 */ + STAT_TYPE_KNOWN_PEERS, /* 21 */ + STAT_TYPE_VALID_PEERS, /* 22 */ + STAT_TYPE_LEARND_PEERS, /* 23 */ + STAT_TYPE_PENDING_ONLINE_CHECKS, /* 24 */ + STAT_TYPE_UNREQUESTED_PULL_REPLIES, /* 25 */ + STAT_TYPE_PEERS_IN_PUSH_MAP, /* 26 */ + STAT_TYPE_PEERS_IN_PULL_MAP, /* 27 */ + STAT_TYPE_PEERS_IN_VIEW, /* 28 */ + STAT_TYPE_VIEW_SIZE_AIM, /* 29 */ + STAT_TYPE_MAX, /* 30 */ +}; + +static char* stat_type_strings[] = { + "# rounds", + "# rounds blocked", + "# rounds blocked - too many pushes", + "# rounds blocked - no pushes", + "# rounds blocked - no pull replies", + "# rounds blocked - too many pushes, no pull replies", + "# rounds blocked - no pushes, no pull replies", + "# push send issued", + "# pull request send issued", + "# pull request send issued (multi-hop peer)", + "# pull reply send issued", + "# pushes sent", + "# pull requests sent", + "# pull requests sent (multi-hop peer)", + "# pull replys sent", + "# push message received", + "# pull request message received", + "# pull request message received (multi-hop peer)", + "# pull reply messages received", + "# pull reply messages received (multi-hop peer)", + "view size", + "# known peers", + "# valid peers", + "# learnd peers", + "# pending online checks", + "# unrequested pull replies", + "# peers in push map at end of round", + "# peers in pull map at end of round", + "# peers in view at end of round", + "view size aim", }; struct STATcls @@ -109,123 +158,187 @@ struct STATcls */ enum STAT_TYPE stat_str_2_type (const char *stat_str) { - if (0 == strncmp ("# rounds blocked - no pull replies", stat_str, strlen ("# rounds blocked - no pull replies"))) + if (0 == strncmp (stat_type_strings[STAT_TYPE_BLOCKS_NO_PULL], + stat_str, + strlen (stat_type_strings[STAT_TYPE_BLOCKS_NO_PULL]))) { return STAT_TYPE_BLOCKS_NO_PULL; } - else if (0 == strncmp ("# rounds blocked - too many pushes, no pull replies", stat_str, strlen ("# rounds blocked - too many pushes, no pull replies"))) + else if (0 == strncmp (stat_type_strings[STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL], + stat_str, + strlen (stat_type_strings[STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL]))) { return STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL; } - else if (0 == strncmp ("# rounds blocked - too many pushes", stat_str, strlen ("# rounds blocked - too many pushes"))) + else if (0 == strncmp (stat_type_strings[STAT_TYPE_BLOCKS_MANY_PUSH], + stat_str, + strlen (stat_type_strings[STAT_TYPE_BLOCKS_MANY_PUSH]))) { return STAT_TYPE_BLOCKS_MANY_PUSH; } - else if (0 == strncmp ("# rounds blocked - no pushes, no pull replies", stat_str, strlen ("# rounds blocked - no pushes, no pull replies"))) + else if (0 == strncmp (stat_type_strings[STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL], + stat_str, + strlen (stat_type_strings[STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL]))) { return STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL; } - else if (0 == strncmp ("# rounds blocked - no pushes", stat_str, strlen ("# rounds blocked - no pushes"))) + else if (0 == strncmp (stat_type_strings[STAT_TYPE_BLOCKS_NO_PUSH], + stat_str, + strlen (stat_type_strings[STAT_TYPE_BLOCKS_NO_PUSH]))) { return STAT_TYPE_BLOCKS_NO_PUSH; } - else if (0 == strncmp ("# rounds blocked", stat_str, strlen ("# rounds blocked"))) + else if (0 == strncmp (stat_type_strings[STAT_TYPE_BLOCKS], + stat_str, + strlen (stat_type_strings[STAT_TYPE_BLOCKS]))) { return STAT_TYPE_BLOCKS; } - else if (0 == strncmp ("# rounds", stat_str, strlen ("# rounds"))) + else if (0 == strncmp (stat_type_strings[STAT_TYPE_ROUNDS], + stat_str, + strlen (stat_type_strings[STAT_TYPE_ROUNDS]))) { return STAT_TYPE_ROUNDS; } - else if (0 == strncmp ("# push send issued", stat_str, strlen ("# push send issued"))) + else if (0 == strncmp (stat_type_strings[STAT_TYPE_ISSUED_PUSH_SEND], + stat_str, + strlen (stat_type_strings[STAT_TYPE_ISSUED_PUSH_SEND]))) { return STAT_TYPE_ISSUED_PUSH_SEND; } - else if (0 == strncmp ("# pull request send issued", stat_str, strlen ("# pull request send issued"))) + else if (0 == strncmp (stat_type_strings[STAT_TYPE_ISSUED_PULL_REQ], + stat_str, + strlen (stat_type_strings[STAT_TYPE_ISSUED_PULL_REQ]))) { return STAT_TYPE_ISSUED_PULL_REQ; } - else if (0 == strncmp ("# pull reply send issued", stat_str, strlen ("# pull reply send issued"))) + else if (0 == strncmp (stat_type_strings[STAT_TYPE_ISSUED_PULL_REQ_MH], + stat_str, + strlen (stat_type_strings[STAT_TYPE_ISSUED_PULL_REQ_MH]))) + { + return STAT_TYPE_ISSUED_PULL_REQ_MH; + } + else if (0 == strncmp (stat_type_strings[STAT_TYPE_ISSUED_PULL_REP], + stat_str, + strlen (stat_type_strings[STAT_TYPE_ISSUED_PULL_REP]))) { return STAT_TYPE_ISSUED_PULL_REP; } - else if (0 == strncmp ("# pushes sent", stat_str, strlen ("# pushes sent"))) + else if (0 == strncmp (stat_type_strings[STAT_TYPE_SENT_PUSH_SEND], + stat_str, + strlen (stat_type_strings[STAT_TYPE_SENT_PUSH_SEND]))) { return STAT_TYPE_SENT_PUSH_SEND; } - else if (0 == strncmp ("# pull requests sent", stat_str, strlen ("# pull requests sent"))) + else if (0 == strncmp (stat_type_strings[STAT_TYPE_SENT_PULL_REQ], + stat_str, + strlen (stat_type_strings[STAT_TYPE_SENT_PULL_REQ]))) { return STAT_TYPE_SENT_PULL_REQ; } - else if (0 == strncmp ("# pull replys sent", stat_str, strlen ("# pull replys sent"))) + else if (0 == strncmp (stat_type_strings[STAT_TYPE_SENT_PULL_REQ_MH], + stat_str, + strlen (stat_type_strings[STAT_TYPE_SENT_PULL_REQ_MH]))) + { + return STAT_TYPE_SENT_PULL_REQ_MH; + } + else if (0 == strncmp (stat_type_strings[STAT_TYPE_SENT_PULL_REP], + stat_str, + strlen (stat_type_strings[STAT_TYPE_SENT_PULL_REP]))) { return STAT_TYPE_SENT_PULL_REP; } - else if (0 == strncmp ("# push message received", stat_str, strlen ("# push message received"))) + else if (0 == strncmp (stat_type_strings[STAT_TYPE_RECV_PUSH_SEND], + stat_str, + strlen (stat_type_strings[STAT_TYPE_RECV_PUSH_SEND]))) { return STAT_TYPE_RECV_PUSH_SEND; } - else if (0 == strncmp ("# pull request message received", stat_str, strlen ("# pull request message received"))) + else if (0 == strncmp (stat_type_strings[STAT_TYPE_RECV_PULL_REQ], + stat_str, + strlen (stat_type_strings[STAT_TYPE_RECV_PULL_REQ]))) { return STAT_TYPE_RECV_PULL_REQ; } - else if (0 == strncmp ("# pull reply messages received", stat_str, strlen ("# pull reply messages received"))) + else if (0 == strncmp (stat_type_strings[STAT_TYPE_RECV_PULL_REQ_MH], + stat_str, + strlen (stat_type_strings[STAT_TYPE_RECV_PULL_REQ_MH]))) + { + return STAT_TYPE_RECV_PULL_REQ_MH; + } + else if (0 == strncmp (stat_type_strings[STAT_TYPE_RECV_PULL_REP], + stat_str, + strlen (stat_type_strings[STAT_TYPE_RECV_PULL_REP]))) { return STAT_TYPE_RECV_PULL_REP; } - return STAT_TYPE_MAX; -} - - -/** - * @brief Converts #STAT_TYPE enum to the equivalent string representation that - * is stored with the statistics service. - * - * @param stat_type #STAT_TYPE enum - * - * @return string representation that matches statistics value - */ -char* stat_type_2_str (enum STAT_TYPE stat_type) -{ - switch (stat_type) - { - case STAT_TYPE_ROUNDS: - return "# rounds"; - case STAT_TYPE_BLOCKS: - return "# rounds blocked"; - case STAT_TYPE_BLOCKS_MANY_PUSH: - return "# rounds blocked - too many pushes"; - case STAT_TYPE_BLOCKS_NO_PUSH: - return "# rounds blocked - no pushes"; - case STAT_TYPE_BLOCKS_NO_PULL: - return "# rounds blocked - no pull replies"; - case STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL: - return "# rounds blocked - too many pushes, no pull replies"; - case STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL: - return "# rounds blocked - no pushes, no pull replies"; - case STAT_TYPE_ISSUED_PUSH_SEND: - return "# push send issued"; - case STAT_TYPE_ISSUED_PULL_REQ: - return "# pull request send issued"; - case STAT_TYPE_ISSUED_PULL_REP: - return "# pull reply send issued"; - case STAT_TYPE_SENT_PUSH_SEND: - return "# pushes sent"; - case STAT_TYPE_SENT_PULL_REQ: - return "# pull requests sent"; - case STAT_TYPE_SENT_PULL_REP: - return "# pull replys sent"; - case STAT_TYPE_RECV_PUSH_SEND: - return "# push message received"; - case STAT_TYPE_RECV_PULL_REQ: - return "# pull request message received"; - case STAT_TYPE_RECV_PULL_REP: - return "# pull reply messages received"; - case STAT_TYPE_MAX: - default: - return "ERROR"; - ; + else if (0 == strncmp (stat_type_strings[STAT_TYPE_RECV_PULL_REP_MH], + stat_str, + strlen (stat_type_strings[STAT_TYPE_RECV_PULL_REP_MH]))) + { + return STAT_TYPE_RECV_PULL_REP_MH; + } + else if (0 == strncmp (stat_type_strings[STAT_TYPE_VIEW_SIZE], + stat_str, + strlen (stat_type_strings[STAT_TYPE_VIEW_SIZE]))) + { + return STAT_TYPE_VIEW_SIZE; + } + else if (0 == strncmp (stat_type_strings[STAT_TYPE_KNOWN_PEERS], + stat_str, + strlen (stat_type_strings[STAT_TYPE_KNOWN_PEERS]))) + { + return STAT_TYPE_KNOWN_PEERS; + } + else if (0 == strncmp (stat_type_strings[STAT_TYPE_VALID_PEERS], + stat_str, + strlen (stat_type_strings[STAT_TYPE_VALID_PEERS]))) + { + return STAT_TYPE_VALID_PEERS; + } + else if (0 == strncmp (stat_type_strings[STAT_TYPE_LEARND_PEERS], + stat_str, + strlen (stat_type_strings[STAT_TYPE_LEARND_PEERS]))) + { + return STAT_TYPE_LEARND_PEERS; + } + else if (0 == strncmp (stat_type_strings[STAT_TYPE_PENDING_ONLINE_CHECKS], + stat_str, + strlen (stat_type_strings[STAT_TYPE_PENDING_ONLINE_CHECKS]))) + { + return STAT_TYPE_PENDING_ONLINE_CHECKS; + } + else if (0 == strncmp (stat_type_strings[STAT_TYPE_UNREQUESTED_PULL_REPLIES], + stat_str, + strlen (stat_type_strings[STAT_TYPE_UNREQUESTED_PULL_REPLIES]))) + { + return STAT_TYPE_UNREQUESTED_PULL_REPLIES; + } + else if (0 == strncmp (stat_type_strings[STAT_TYPE_PEERS_IN_PUSH_MAP], + stat_str, + strlen (stat_type_strings[STAT_TYPE_PEERS_IN_PUSH_MAP]))) + { + return STAT_TYPE_PEERS_IN_PUSH_MAP; + } + else if (0 == strncmp (stat_type_strings[STAT_TYPE_PEERS_IN_PULL_MAP], + stat_str, + strlen (stat_type_strings[STAT_TYPE_PEERS_IN_PULL_MAP]))) + { + return STAT_TYPE_PEERS_IN_PULL_MAP; + } + else if (0 == strncmp (stat_type_strings[STAT_TYPE_PEERS_IN_VIEW], + stat_str, + strlen (stat_type_strings[STAT_TYPE_PEERS_IN_VIEW]))) + { + return STAT_TYPE_PEERS_IN_VIEW; } + else if (0 == strncmp (stat_type_strings[STAT_TYPE_VIEW_SIZE_AIM], + stat_str, + strlen (stat_type_strings[STAT_TYPE_VIEW_SIZE_AIM]))) + { + return STAT_TYPE_VIEW_SIZE_AIM; + } + return STAT_TYPE_MAX; } @@ -476,11 +589,6 @@ static struct GNUNET_PeerIdentity *rps_peer_ids; */ static struct GNUNET_PeerIdentity *target_peer; -/** - * ID of the peer that requests for the evaluation. - */ -static struct RPSPeer *eval_peer; - /** * Number of online peers. */ @@ -883,6 +991,9 @@ static int check_statistics_collect_completed () return GNUNET_YES; } +static void +rps_disconnect_adapter (void *cls, + void *op_result); static void cancel_pending_req (struct PendingRequest *pending_req) @@ -912,6 +1023,7 @@ cancel_request (struct PendingReply *pending_rep) rps_peer->num_pending_reps--; GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cancelling rps get reply\n"); + GNUNET_assert (NULL != pending_rep->req_handle); GNUNET_RPS_request_cancel (pending_rep->req_handle); GNUNET_free (pending_rep); } @@ -919,24 +1031,15 @@ cancel_request (struct PendingReply *pending_rep) void clean_peer (unsigned peer_index) { - struct PendingReply *pending_rep; struct PendingRequest *pending_req; - pending_rep = rps_peers[peer_index].pending_rep_head; - while (NULL != (pending_rep = rps_peers[peer_index].pending_rep_head)) - { - cancel_request (pending_rep); - } - pending_req = rps_peers[peer_index].pending_req_head; while (NULL != (pending_req = rps_peers[peer_index].pending_req_head)) { cancel_pending_req (pending_req); } - if (NULL != rps_peers[peer_index].rps_handle) - { - GNUNET_RPS_disconnect (rps_peers[peer_index].rps_handle); - rps_peers[peer_index].rps_handle = NULL; - } + pending_req = rps_peers[peer_index].pending_req_head; + rps_disconnect_adapter (&rps_peers[peer_index], + &rps_peers[peer_index].rps_handle); for (unsigned stat_type = STAT_TYPE_ROUNDS; stat_type < STAT_TYPE_MAX; stat_type++) @@ -946,7 +1049,7 @@ clean_peer (unsigned peer_index) GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "(%u) did not yet receive stat value for `%s'\n", rps_peers[peer_index].index, - stat_type_2_str (stat_type)); + stat_type_strings[stat_type]); GNUNET_STATISTICS_get_cancel ( rps_peers[peer_index].h_stat_get[stat_type]); } @@ -966,6 +1069,7 @@ shutdown_op (void *cls) { unsigned int i; struct OpListEntry *entry; + (void) cls; GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Shutdown task scheduled, going down.\n"); @@ -1000,11 +1104,14 @@ shutdown_op (void *cls) { clean_peer (i); } + close_all_files(); } static void trigger_shutdown (void *cls) { + (void) cls; + GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Shutdown was triggerd by timeout, going down.\n"); shutdown_task = NULL; @@ -1019,11 +1126,12 @@ static void post_test_op (void *cls) { unsigned int i; + (void) cls; post_test_task = NULL; post_test = GNUNET_YES; - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, - "Post test task scheduled.\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Executing post test op.\n"); if (NULL != churn_task) { GNUNET_SCHEDULER_cancel (churn_task); @@ -1031,10 +1139,15 @@ post_test_op (void *cls) } for (i = 0; i < num_peers; i++) { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Executing post test op. (peer %" PRIu32 ")\n", + rps_peers[i].index); if (NULL != rps_peers[i].op) { GNUNET_TESTBED_operation_done (rps_peers[i].op); rps_peers[i].op = NULL; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Cancelled testbed operation\n"); } if (NULL != cur_test_run.post_test) { @@ -1086,6 +1199,7 @@ info_cb (void *cb_cls, const char *emsg) { struct OpListEntry *entry = (struct OpListEntry *) cb_cls; + (void) op; if (GNUNET_YES == in_shutdown || GNUNET_YES == post_test) { @@ -1244,11 +1358,16 @@ stat_disconnect_adapter (void *cls, void *op_result) * operation has executed successfully. */ static void -stat_complete_cb (void *cls, struct GNUNET_TESTBED_Operation *op, - void *ca_result, const char *emsg ) +stat_complete_cb (void *cls, + struct GNUNET_TESTBED_Operation *op, + void *ca_result, + const char *emsg ) { //struct GNUNET_STATISTICS_Handle *sh = ca_result; //struct RPSPeer *peer = (struct RPSPeer *) cls; + (void) cls; + (void) op; + (void) ca_result; if (NULL != emsg) { @@ -1277,6 +1396,7 @@ rps_disconnect_adapter (void *cls, { struct RPSPeer *peer = cls; struct GNUNET_RPS_Handle *h = op_result; + struct PendingReply *pending_rep; GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "disconnect_adapter (%u)\n", @@ -1284,8 +1404,16 @@ rps_disconnect_adapter (void *cls, GNUNET_assert (NULL != peer); if (NULL != peer->rps_handle) { + while (NULL != (pending_rep = peer->pending_rep_head)) + { + cancel_request (pending_rep); + } GNUNET_assert (h == peer->rps_handle); - GNUNET_RPS_disconnect (h); + if (NULL != h) + { + GNUNET_RPS_disconnect (h); + h = NULL; + } peer->rps_handle = NULL; } } @@ -1553,6 +1681,7 @@ churn_cb (void *cls, { // FIXME struct OpListEntry *entry = cls; + (void) op; if (GNUNET_YES == in_shutdown || GNUNET_YES == post_test) { @@ -1688,6 +1817,7 @@ churn (void *cls) double prob_go_offline; double portion_go_online; double portion_go_offline; + (void) cls; if (GNUNET_YES == in_shutdown || GNUNET_YES == post_test) { @@ -1752,12 +1882,7 @@ churn (void *cls) */ static void profiler_init_peer (struct RPSPeer *rps_peer) { - if (num_peers - 1 == rps_peer->index) - { - rps_peer->num_ids_to_request = cur_test_run.num_requests; - } else { - rps_peer->num_ids_to_request = 0; - } + rps_peer->num_ids_to_request = cur_test_run.num_requests; GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "peer shall request %i peers\n", rps_peer->num_ids_to_request); } @@ -1777,19 +1902,33 @@ profiler_reply_handle (void *cls, { struct RPSPeer *rps_peer; struct RPSPeer *rcv_rps_peer; - char *file_name; - char *file_name_dh; - char *file_name_dhr; - char *file_name_dhru; + char file_name_buf[128]; + char file_name_dh_buf[128]; + char file_name_dhr_buf[128]; + char file_name_dhru_buf[128]; + char *file_name = file_name_buf; + char *file_name_dh = file_name_dh_buf; + char *file_name_dhr = file_name_dhr_buf; + char *file_name_dhru = file_name_dhru_buf; unsigned int i; struct PendingReply *pending_rep = (struct PendingReply *) cls; + pending_rep->req_handle = NULL; GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "profiler_reply_handle()\n"); rps_peer = pending_rep->rps_peer; - file_name = "/tmp/rps/received_ids"; - file_name_dh = "/tmp/rps/diehard_input"; - file_name_dhr = "/tmp/rps/diehard_input_raw"; - file_name_dhru = "/tmp/rps/diehard_input_raw_aligned"; + (void) GNUNET_asprintf (&file_name, + "/tmp/rps/received_ids-%u", + rps_peer->index); + + (void) GNUNET_asprintf (&file_name_dh, + "/tmp/rps/diehard_input-%u", + rps_peer->index); + (void) GNUNET_asprintf (&file_name_dhr, + "/tmp/rps/diehard_input_raw-%u", + rps_peer->index); + (void) GNUNET_asprintf (&file_name_dhru, + "/tmp/rps/diehard_input_raw_aligned-%u", + rps_peer->index); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%s] got %" PRIu64 " peers:\n", GNUNET_i2s (rps_peer->peer_id), @@ -1808,6 +1947,7 @@ profiler_reply_handle (void *cls, tofile (file_name_dh, "%" PRIu32 "\n", (uint32_t) rcv_rps_peer->index); +#ifdef TO_FILE to_file_raw (file_name_dhr, (char *) &rcv_rps_peer->index, sizeof (uint32_t)); @@ -1815,6 +1955,7 @@ profiler_reply_handle (void *cls, (char *) &rcv_rps_peer->index, sizeof (uint32_t), bits_needed); +#endif /* TO_FILE */ } default_reply_handle (cls, n, recv_peers); } @@ -1845,7 +1986,7 @@ profiler_cb (struct RPSPeer *rps_peer) /* Only request peer ids at one peer. * (It's the before-last because last one is target of the focussed attack.) */ - if (eval_peer == rps_peer) + if (0 < rps_peer->num_ids_to_request) schedule_missing_requests (rps_peer); } @@ -1858,7 +1999,7 @@ profiler_cb (struct RPSPeer *rps_peer) * #GNUNET_NO to stop iteration with no error, * #GNUNET_SYSERR to abort iteration with error! */ -int +static int file_name_cb (void *cls, const char *filename) { if (NULL != strstr (filename, "sampler_el")) @@ -1867,6 +2008,7 @@ file_name_cb (void *cls, const char *filename) struct GNUNET_CRYPTO_AuthKey auth_key; const char *key_char; uint32_t i; + (void) cls; key_char = filename + 20; /* Length of "/tmp/rps/sampler_el-" */ tofile (filename, "--------------------------\n"); @@ -1889,14 +2031,16 @@ file_name_cb (void *cls, const char *filename) * * Compute all perfect samples. */ -int +static int profiler_eval (void) { +#ifdef TO_FILE /* Compute perfect sample for each sampler element */ if (-1 == GNUNET_DISK_directory_scan ("/tmp/rps/", file_name_cb, NULL)) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Scan of directory failed\n"); } +#endif /* TO_FILE */ return evaluate (); } @@ -1914,8 +2058,8 @@ static uint32_t binom (uint32_t n, uint32_t k) { //GNUNET_assert (n >= k); if (k > n) return 0; - if (0 > n) return 0; - if (0 > k) return 0; + /* if (0 > n) return 0; - always false */ + /* if (0 > k) return 0; - always false */ if (0 == k) return 1; return fac (n) / @@ -2259,7 +2403,7 @@ void view_update_cb (void *cls, "%" PRIu64 " %" PRIu32 "", rps_peer->index, view_size); - for (int i = 0; i < view_size; i++) + for (uint64_t i = 0; i < view_size; i++) { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\t%s\n", GNUNET_i2s (&peers[i])); @@ -2312,14 +2456,24 @@ void write_final_stats (void){ for (uint32_t i = 0; i < num_peers; i++) { - to_file ("/tmp/rps/final_stats.dat", - "%" PRIu32 " " /* index */ - "%s %" /* id */ - PRIu64 " %" /* rounds */ - PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" /* blocking */ - PRIu64 " %" PRIu64 " %" PRIu64 " %" /* issued */ - PRIu64 " %" PRIu64 " %" PRIu64 " %" /* sent */ - PRIu64 " %" PRIu64 " %" PRIu64 /* recv */, + to_file ("/tmp/rps/final_stats.csv", + "%" PRIu32 ", " /* index */ + "%s, %" /* id */ + PRIu64 ", %" /* rounds */ + PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" /* blocking */ + PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" /* issued */ + PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" /* sent */ + PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" /* recv */ + PRIu64 ", %" /* view size */ + PRIu64 ", %" /* known peers */ + PRIu64 ", %" /* valid peers */ + PRIu64 ", %" /* learned peers */ + PRIu64 ", %" /* pending online checks */ + PRIu64 ", %" /* unrequested pull replies */ + PRIu64 ", %" /* peers in push map */ + PRIu64 ", %" /* peers in pull map */ + PRIu64 ", %" /* peers in view */ + PRIu64 "\n"/* view size aim */, i, GNUNET_i2s (rps_peers[i].peer_id), rps_peers[i].stats[STAT_TYPE_ROUNDS], @@ -2331,14 +2485,28 @@ void write_final_stats (void){ rps_peers[i].stats[STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL], rps_peers[i].stats[STAT_TYPE_ISSUED_PUSH_SEND], rps_peers[i].stats[STAT_TYPE_ISSUED_PULL_REQ], + rps_peers[i].stats[STAT_TYPE_ISSUED_PULL_REQ_MH], rps_peers[i].stats[STAT_TYPE_ISSUED_PULL_REP], rps_peers[i].stats[STAT_TYPE_SENT_PUSH_SEND], rps_peers[i].stats[STAT_TYPE_SENT_PULL_REQ], + rps_peers[i].stats[STAT_TYPE_SENT_PULL_REQ_MH], rps_peers[i].stats[STAT_TYPE_SENT_PULL_REP], rps_peers[i].stats[STAT_TYPE_RECV_PUSH_SEND], rps_peers[i].stats[STAT_TYPE_RECV_PULL_REQ], - rps_peers[i].stats[STAT_TYPE_RECV_PULL_REP]); - for (uint32_t stat_type = STAT_TYPE_ROUNDS; + rps_peers[i].stats[STAT_TYPE_RECV_PULL_REQ_MH], + rps_peers[i].stats[STAT_TYPE_RECV_PULL_REP_MH], + rps_peers[i].stats[STAT_TYPE_RECV_PULL_REP], + rps_peers[i].stats[STAT_TYPE_VIEW_SIZE], + rps_peers[i].stats[STAT_TYPE_KNOWN_PEERS], + rps_peers[i].stats[STAT_TYPE_VALID_PEERS], + rps_peers[i].stats[STAT_TYPE_LEARND_PEERS], + rps_peers[i].stats[STAT_TYPE_PENDING_ONLINE_CHECKS], + rps_peers[i].stats[STAT_TYPE_UNREQUESTED_PULL_REPLIES], + rps_peers[i].stats[STAT_TYPE_PEERS_IN_PUSH_MAP], + rps_peers[i].stats[STAT_TYPE_PEERS_IN_PULL_MAP], + rps_peers[i].stats[STAT_TYPE_PEERS_IN_VIEW], + rps_peers[i].stats[STAT_TYPE_VIEW_SIZE_AIM]); + for (enum STAT_TYPE stat_type = STAT_TYPE_ROUNDS; stat_type < STAT_TYPE_MAX; stat_type++) { @@ -2349,9 +2517,19 @@ void write_final_stats (void){ "SUM %" PRIu64 " %" /* rounds */ PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" /* blocking */ - PRIu64 " %" PRIu64 " %" PRIu64 " %" /* issued */ - PRIu64 " %" PRIu64 " %" PRIu64 " %" /* sent */ - PRIu64 " %" PRIu64 " %" PRIu64 /* recv */, + PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" /* issued */ + PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" /* sent */ + PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" /* recv */ + PRIu64 ", %" /* view size */ + PRIu64 ", %" /* known peers */ + PRIu64 ", %" /* valid peers */ + PRIu64 ", %" /* learned peers */ + PRIu64 ", %" /* pending online checks */ + PRIu64 ", %" /* unrequested pull replies */ + PRIu64 ", %" /* peers in push map */ + PRIu64 ", %" /* peers in pull map */ + PRIu64 ", %" /* peers in view */ + PRIu64 "\n"/* view size aim */, sums[STAT_TYPE_ROUNDS], sums[STAT_TYPE_BLOCKS], sums[STAT_TYPE_BLOCKS_MANY_PUSH], @@ -2361,13 +2539,27 @@ void write_final_stats (void){ sums[STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL], sums[STAT_TYPE_ISSUED_PUSH_SEND], sums[STAT_TYPE_ISSUED_PULL_REQ], + sums[STAT_TYPE_ISSUED_PULL_REQ_MH], sums[STAT_TYPE_ISSUED_PULL_REP], sums[STAT_TYPE_SENT_PUSH_SEND], sums[STAT_TYPE_SENT_PULL_REQ], + sums[STAT_TYPE_SENT_PULL_REQ_MH], sums[STAT_TYPE_SENT_PULL_REP], sums[STAT_TYPE_RECV_PUSH_SEND], sums[STAT_TYPE_RECV_PULL_REQ], - sums[STAT_TYPE_RECV_PULL_REP]); + sums[STAT_TYPE_RECV_PULL_REQ_MH], + sums[STAT_TYPE_RECV_PULL_REP], + sums[STAT_TYPE_RECV_PULL_REP_MH], + sums[STAT_TYPE_VIEW_SIZE], + sums[STAT_TYPE_KNOWN_PEERS], + sums[STAT_TYPE_VALID_PEERS], + sums[STAT_TYPE_LEARND_PEERS], + sums[STAT_TYPE_PENDING_ONLINE_CHECKS], + sums[STAT_TYPE_UNREQUESTED_PULL_REPLIES], + sums[STAT_TYPE_PEERS_IN_PUSH_MAP], + sums[STAT_TYPE_PEERS_IN_PULL_MAP], + sums[STAT_TYPE_PEERS_IN_VIEW], + sums[STAT_TYPE_VIEW_SIZE_AIM]); } /** @@ -2440,72 +2632,21 @@ stat_iterator (void *cls, { const struct STATcls *stat_cls = (const struct STATcls *) cls; struct RPSPeer *rps_peer = (struct RPSPeer *) stat_cls->rps_peer; + enum STAT_TYPE stat_type; + (void) subsystem; + (void) is_persistent; GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got stat value: %s - %" PRIu64 "\n", - //stat_type_2_str (stat_cls->stat_type), name, value); to_file (rps_peer->file_name_stats, "%s: %" PRIu64 "\n", name, value); - switch (stat_str_2_type (name)) - { - case STAT_TYPE_ROUNDS: - rps_peer->stats[STAT_TYPE_ROUNDS] = value; - break; - case STAT_TYPE_BLOCKS: - rps_peer->stats[STAT_TYPE_BLOCKS] = value; - break; - case STAT_TYPE_BLOCKS_MANY_PUSH: - rps_peer->stats[STAT_TYPE_BLOCKS_MANY_PUSH] = value; - break; - case STAT_TYPE_BLOCKS_NO_PUSH: - rps_peer->stats[STAT_TYPE_BLOCKS_NO_PUSH] = value; - break; - case STAT_TYPE_BLOCKS_NO_PULL: - rps_peer->stats[STAT_TYPE_BLOCKS_NO_PULL] = value; - break; - case STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL: - rps_peer->stats[STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL] = value; - break; - case STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL: - rps_peer->stats[STAT_TYPE_BLOCKS] = value; - break; - case STAT_TYPE_ISSUED_PUSH_SEND: - rps_peer->stats[STAT_TYPE_ISSUED_PUSH_SEND] = value; - break; - case STAT_TYPE_ISSUED_PULL_REQ: - rps_peer->stats[STAT_TYPE_ISSUED_PULL_REQ] = value; - break; - case STAT_TYPE_ISSUED_PULL_REP: - rps_peer->stats[STAT_TYPE_ISSUED_PULL_REP] = value; - break; - case STAT_TYPE_SENT_PUSH_SEND: - rps_peer->stats[STAT_TYPE_SENT_PUSH_SEND] = value; - break; - case STAT_TYPE_SENT_PULL_REQ: - rps_peer->stats[STAT_TYPE_SENT_PULL_REQ] = value; - break; - case STAT_TYPE_SENT_PULL_REP: - rps_peer->stats[STAT_TYPE_SENT_PULL_REP] = value; - break; - case STAT_TYPE_RECV_PUSH_SEND: - rps_peer->stats[STAT_TYPE_RECV_PUSH_SEND] = value; - break; - case STAT_TYPE_RECV_PULL_REQ: - rps_peer->stats[STAT_TYPE_RECV_PULL_REQ] = value; - break; - case STAT_TYPE_RECV_PULL_REP: - rps_peer->stats[STAT_TYPE_RECV_PULL_REP] = value; - break; - case STAT_TYPE_MAX: - default: - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, - "Unknown statistics string: %s\n", - name); - break; - } + stat_type = stat_str_2_type (name); + GNUNET_assert (STAT_TYPE_ROUNDS <= stat_type && + STAT_TYPE_MAX > stat_type); + rps_peer->stats[stat_type] = value; return GNUNET_OK; } @@ -2533,17 +2674,17 @@ void post_profiler (struct RPSPeer *rps_peer) stat_cls->stat_type = stat_type; rps_peer->file_name_stats = store_prefix_file_name (rps_peer->peer_id, "stats"); - rps_peer->h_stat_get[stat_type] = GNUNET_STATISTICS_get ( - rps_peer->stats_h, - "rps", - stat_type_2_str (stat_type), - post_test_shutdown_ready_cb, - stat_iterator, - (struct STATcls *) stat_cls); + rps_peer->h_stat_get[stat_type] = + GNUNET_STATISTICS_get (rps_peer->stats_h, + "rps", + stat_type_strings [stat_type], + post_test_shutdown_ready_cb, + stat_iterator, + (struct STATcls *) stat_cls); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Requested statistics for %s (peer %" PRIu32 ")\n", - stat_type_2_str (stat_type), - rps_peer->index); + "Requested statistics for %s (peer %" PRIu32 ")\n", + stat_type_strings [stat_type], + rps_peer->index); } } } @@ -2576,6 +2717,9 @@ test_run (void *cls, { unsigned int i; struct OpListEntry *entry; + (void) cls; + (void) h; + (void) links_failed; GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "RUN was called\n"); @@ -2589,6 +2733,7 @@ test_run (void *cls, GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tnum_peers: %" PRIu32 "\n", num_peers); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tpeers: %p\n", peers); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tlinks_succeeded: %u\n", links_succeeded); + ok = 1; GNUNET_SCHEDULER_shutdown (); return; } @@ -2667,11 +2812,14 @@ test_run (void *cls, */ static void run (void *cls, - char *const *args, - const char *cfgfile, - const struct GNUNET_CONFIGURATION_Handle *cfg) + char *const *args, + const char *cfgfile, + const struct GNUNET_CONFIGURATION_Handle *cfg) { //int ret_value; + (void) cls; + (void) args; + (void) cfgfile; /* Defaults for tests */ churn_task = NULL; @@ -2702,13 +2850,27 @@ run (void *cls, BIT(STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL) | BIT(STAT_TYPE_ISSUED_PUSH_SEND) | BIT(STAT_TYPE_ISSUED_PULL_REQ) | + BIT(STAT_TYPE_ISSUED_PULL_REQ_MH) | BIT(STAT_TYPE_ISSUED_PULL_REP) | BIT(STAT_TYPE_SENT_PUSH_SEND) | BIT(STAT_TYPE_SENT_PULL_REQ) | + BIT(STAT_TYPE_SENT_PULL_REQ_MH) | BIT(STAT_TYPE_SENT_PULL_REP) | BIT(STAT_TYPE_RECV_PUSH_SEND) | BIT(STAT_TYPE_RECV_PULL_REQ) | - BIT(STAT_TYPE_RECV_PULL_REP); + BIT(STAT_TYPE_RECV_PULL_REQ_MH) | + BIT(STAT_TYPE_RECV_PULL_REP) | + BIT(STAT_TYPE_RECV_PULL_REP_MH) | + BIT(STAT_TYPE_VIEW_SIZE) | + BIT(STAT_TYPE_KNOWN_PEERS) | + BIT(STAT_TYPE_VALID_PEERS) | + BIT(STAT_TYPE_LEARND_PEERS) | + BIT(STAT_TYPE_PENDING_ONLINE_CHECKS) | + BIT(STAT_TYPE_UNREQUESTED_PULL_REPLIES) | + BIT(STAT_TYPE_PEERS_IN_PUSH_MAP) | + BIT(STAT_TYPE_PEERS_IN_PULL_MAP) | + BIT(STAT_TYPE_PEERS_IN_VIEW) | + BIT(STAT_TYPE_VIEW_SIZE_AIM); cur_test_run.have_collect_view = COLLECT_VIEW; /* 'Clean' directory */ @@ -2761,10 +2923,6 @@ run (void *cls, if ( (2 == mal_type) || (3 == mal_type)) target_peer = &rps_peer_ids[num_peers - 2]; - if (profiler_eval == cur_test_run.eval_cb) - eval_peer = &rps_peers[num_peers - 1]; /* FIXME: eval_peer could be a - malicious peer if not careful - with the malicious portion */ ok = 1; GNUNET_TESTBED_run (NULL,