You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+ SPDX-License-Identifier: AGPL3.0-or-later
*/
/**
* @file rps/test_rps.c
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
*/
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;
}
*/
static struct GNUNET_PeerIdentity *target_peer;
-/**
- * ID of the peer that requests for the evaluation.
- */
-static struct RPSPeer *eval_peer;
-
/**
* Number of online peers.
*/
return GNUNET_YES;
}
+static void
+rps_disconnect_adapter (void *cls,
+ void *op_result);
static void
cancel_pending_req (struct PendingRequest *pending_req)
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);
}
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++)
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]);
}
{
unsigned int i;
struct OpListEntry *entry;
+ (void) cls;
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Shutdown task scheduled, going down.\n");
{
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;
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);
}
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)
{
const char *emsg)
{
struct OpListEntry *entry = (struct OpListEntry *) cb_cls;
+ (void) op;
if (GNUNET_YES == in_shutdown || GNUNET_YES == post_test)
{
* 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)
{
{
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",
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;
}
}
{
// FIXME
struct OpListEntry *entry = cls;
+ (void) op;
if (GNUNET_YES == in_shutdown || GNUNET_YES == post_test)
{
double prob_go_offline;
double portion_go_online;
double portion_go_offline;
+ (void) cls;
if (GNUNET_YES == in_shutdown || GNUNET_YES == post_test)
{
*/
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);
}
{
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),
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));
(char *) &rcv_rps_peer->index,
sizeof (uint32_t),
bits_needed);
+#endif /* TO_FILE */
}
default_reply_handle (cls, n, recv_peers);
}
/* 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);
}
* #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"))
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");
*
* 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 ();
}
{
//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)
/
"%" 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]));
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],
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++)
{
"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],
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]);
}
/**
{
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;
}
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);
}
}
}
{
unsigned int i;
struct OpListEntry *entry;
+ (void) cls;
+ (void) h;
+ (void) links_failed;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "RUN was called\n");
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;
}
*/
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;
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 */
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,
projects / oweals / gnunet.git / blobdiff