GNUnet  0.11.x
Data Structures | Macros | Typedefs | Enumerations | Functions | Variables
gnunet-rps-profiler.c File Reference
#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_testbed_service.h"
#include "gnunet_rps_service.h"
#include "rps-test_util.h"
#include "gnunet-service-rps_sampler_elem.h"
#include <inttypes.h>
Include dependency graph for gnunet-rps-profiler.c:

Go to the source code of this file.

Data Structures

struct  STATcls
 
struct  OpListEntry
 Operation map entry. More...
 
struct  PendingReply
 A pending reply: A request was sent and the reply is pending. More...
 
struct  PendingRequest
 A pending request: A request was not made yet but is scheduled for later. More...
 
struct  RPSPeer
 Information we track for each peer. More...
 
struct  SingleTestRun
 Structure to define a single test. More...
 

Macros

#define BIT(n)   (1 << (n))
 
#define tofile(file_name, ...)
 This function is used to facilitate writing important information to disk. More...
 

Typedefs

typedef void(* InitPeer) (struct RPSPeer *rps_peer)
 Called to initialise the given RPSPeer. More...
 
typedef void(* PreTest) (struct RPSPeer *rps_peer, struct GNUNET_RPS_Handle *h)
 Called directly after connecting to the service. More...
 
typedef void(* MainTest) (struct RPSPeer *rps_peer)
 Executes functions to test the api/service for a given peer. More...
 
typedef void(* ReplyHandle) (void *cls, uint64_t n, const struct GNUNET_PeerIdentity *recv_peers)
 Callback called once the requested random peers are available. More...
 
typedef void(* PostTest) (struct RPSPeer *peer)
 Called directly before disconnecting from the service. More...
 
typedef int(* EvaluationCallback) (void)
 Function called after disconnect to evaluate test success. More...
 

Enumerations

enum  STAT_TYPE {
  STAT_TYPE_ROUNDS, STAT_TYPE_BLOCKS, STAT_TYPE_BLOCKS_MANY_PUSH, STAT_TYPE_BLOCKS_NO_PUSH,
  STAT_TYPE_BLOCKS_NO_PULL, STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL, STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL, STAT_TYPE_ISSUED_PUSH_SEND,
  STAT_TYPE_ISSUED_PUSH_SEND_MH, STAT_TYPE_ISSUED_PULL_REQ, STAT_TYPE_ISSUED_PULL_REQ_MH, STAT_TYPE_ISSUED_PULL_REP,
  STAT_TYPE_SENT_PUSH_SEND, STAT_TYPE_SENT_PULL_REQ, STAT_TYPE_SENT_PULL_REQ_MH, STAT_TYPE_SENT_PULL_REP,
  STAT_TYPE_RECV_PUSH_SEND, STAT_TYPE_RECV_PUSH_SEND_MH, STAT_TYPE_RECV_PULL_REQ, STAT_TYPE_RECV_PULL_REQ_MH,
  STAT_TYPE_RECV_PULL_REP, STAT_TYPE_RECV_PULL_REP_MH, STAT_TYPE_VIEW_SIZE, STAT_TYPE_KNOWN_PEERS,
  STAT_TYPE_VALID_PEERS, STAT_TYPE_LEARND_PEERS, STAT_TYPE_PENDING_ONLINE_CHECKS, STAT_TYPE_UNREQUESTED_PULL_REPLIES,
  STAT_TYPE_PEERS_IN_PUSH_MAP, STAT_TYPE_PEERS_IN_PULL_MAP, STAT_TYPE_PEERS_IN_VIEW, STAT_TYPE_VIEW_SIZE_AIM,
  STAT_TYPE_MAX
}
 
enum  PEER_ONLINE_DELTA { PEER_GO_ONLINE = 1, PEER_GO_OFFLINE = -1 }
 Indicates whether peer should go off- or online. More...
 
enum  OPTION_CHURN { HAVE_CHURN, HAVE_NO_CHURN }
 Do we have Churn? More...
 
enum  OPTION_QUICK_QUIT { HAVE_QUICK_QUIT, HAVE_NO_QUICK_QUIT }
 Is it ok to quit the test before the timeout? More...
 
enum  OPTION_COLLECT_STATISTICS { COLLECT_STATISTICS, NO_COLLECT_STATISTICS }
 Do we collect statistics at the end? More...
 
enum  OPTION_COLLECT_VIEW { COLLECT_VIEW, NO_COLLECT_VIEW }
 Do we collect views during run? More...
 

Functions

enum STAT_TYPE stat_str_2_type (const char *stat_str)
 Converts string representation to the corresponding STAT_TYPE enum. More...
 
static void tofile_ (const char *file_name, const char *line)
 Append arguments to file. More...
 
static int evaluate (void)
 Write the ids and their according index in the given array to a file Unused. More...
 
static struct OpListEntrymake_oplist_entry ()
 Creates an oplist entry and adds it to the oplist DLL. More...
 
static int check_statistics_collect_completed_single_peer (const struct RPSPeer *rps_peer)
 Checks if given peer already received its statistics value from the statistics service. More...
 
static int check_statistics_collect_completed ()
 Checks if all peers already received their statistics value from the statistics service. More...
 
static void rps_disconnect_adapter (void *cls, void *op_result)
 Adapter function called to destroy connection to RPS service. More...
 
static void cancel_pending_req (struct PendingRequest *pending_req)
 
static void cancel_request (struct PendingReply *pending_rep)
 
void clean_peer (unsigned peer_index)
 
static void shutdown_op (void *cls)
 Task run on timeout to shut everything down. More...
 
static void trigger_shutdown (void *cls)
 
static void post_test_op (void *cls)
 Task run after duration to collect statistics and potentially shut down. More...
 
void info_cb (void *cb_cls, struct GNUNET_TESTBED_Operation *op, const struct GNUNET_TESTBED_PeerInformation *pinfo, const char *emsg)
 Get the id of peer i. More...
 
static void rps_connect_complete_cb (void *cls, struct GNUNET_TESTBED_Operation *op, void *ca_result, const char *emsg)
 Callback to be called when RPS service connect operation is completed. More...
 
static void * rps_connect_adapter (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
 Adapter function called to establish a connection to the RPS service. More...
 
static void * stat_connect_adapter (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
 Called to open a connection to the peer's statistics. More...
 
static void stat_disconnect_adapter (void *cls, void *op_result)
 Called to disconnect from peer's statistics service. More...
 
static void stat_complete_cb (void *cls, struct GNUNET_TESTBED_Operation *op, void *ca_result, const char *emsg)
 Called after successfully opening a connection to a peer's statistics service; we register statistics monitoring for CORE and NSE here. More...
 
static void default_reply_handle (void *cls, uint64_t n, const struct GNUNET_PeerIdentity *recv_peers)
 Callback to call on receipt of a reply. More...
 
static void profiler_reply_handle_info (void *cls, const struct GNUNET_PeerIdentity *recv_peer, double probability, uint32_t num_observed)
 Callback to call on receipt of a reply. More...
 
static void request_peers (void *cls)
 Request random peers. More...
 
void schedule_missing_requests (struct RPSPeer *rps_peer)
 Schedule requests for peer rps_peer that have neither been scheduled, nor issued, nor replied. More...
 
void cancel_pending_req_rep (struct RPSPeer *rps_peer)
 
static void churn (void *cls)
 Initialise only non-mal RPSPeers. More...
 
static void churn_cb (void *cls, struct GNUNET_TESTBED_Operation *op, const char *emsg)
 Callback to be called when RPS service is started or stopped at peers. More...
 
static void manage_service_wrapper (unsigned int i, unsigned int j, enum PEER_ONLINE_DELTA delta, double prob_go_on_off)
 Set the rps-service up or down for a specific peer. More...
 
static void profiler_init_peer (struct RPSPeer *rps_peer)
 Initialise given RPSPeer. More...
 
static void profiler_reply_handle (void *cls, uint64_t n, const struct GNUNET_PeerIdentity *recv_peers)
 Callback to call on receipt of a reply. More...
 
static void profiler_cb (struct RPSPeer *rps_peer)
 
static int file_name_cb (void *cls, const char *filename)
 Function called from profiler_eval with a filename. More...
 
static int profiler_eval (void)
 This is run after the test finished. More...
 
static int is_in_view (uint32_t a, uint32_t b)
 is b in view of a? More...
 
static uint32_t get_idx_of_pid (const struct GNUNET_PeerIdentity *pid)
 
static uint32_t count_containing_views (uint32_t a, uint32_t b)
 Counts number of peers in view of a that have b in their view. More...
 
static void compute_probabilities (uint32_t peer_idx)
 Computes the probability for each other peer to be selected by the sampling process based on the views of all peers. More...
 
static uint32_t count_peer_in_views_2 (uint32_t peer_idx)
 This counts the number of peers in which views a given peer occurs. More...
 
static uint32_t cumulated_view_sizes ()
 
static void count_peer_in_views (uint32_t *count_peers)
 
void compute_diversity ()
 
void print_view_sizes ()
 
void all_views_updated_cb ()
 
void view_update_cb (void *cls, uint64_t view_size, const struct GNUNET_PeerIdentity *peers)
 
static void pre_profiler (struct RPSPeer *rps_peer, struct GNUNET_RPS_Handle *h)
 
void write_final_stats (void)
 
void post_test_shutdown_ready_cb (void *cls, int success)
 Continuation called by GNUNET_STATISTICS_get() functions. More...
 
int stat_iterator (void *cls, const char *subsystem, const char *name, uint64_t value, int is_persistent)
 Callback function to process statistic values. More...
 
void post_profiler (struct RPSPeer *rps_peer)
 
static void test_run (void *cls, struct GNUNET_TESTBED_RunHandle *h, unsigned int n_peers, struct GNUNET_TESTBED_Peer **peers, unsigned int links_succeeded, unsigned int links_failed)
 Actual "main" function for the testcase. More...
 
static void run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 Entry point for the testcase, sets up the testbed. More...
 
int main (int argc, char *argv[])
 Entry point for the testcase, sets up the testbed. More...
 

Variables

static uint32_t num_peers
 How many peers do we start? More...
 
static unsigned bits_needed
 numer of bits required to represent the largest peer id More...
 
static struct GNUNET_TIME_Relative duration
 How long do we run the test? More...
 
static struct GNUNET_TIME_Relative timeout
 When do we do a hard shutdown? More...
 
static unsigned int mal_type = 0
 Portion of malicious peers. More...
 
static struct GNUNET_TESTBED_Peer ** testbed_peers
 Handles to all of the running peers. More...
 
static char * stat_type_strings []
 
static struct OpListEntryoplist_head
 OpList DLL head. More...
 
static struct OpListEntryoplist_tail
 OpList DLL tail. More...
 
static struct RPSPeerrps_peers
 Information for all the peers. More...
 
static struct GNUNET_CONTAINER_MultiPeerMappeer_map
 Peermap to get the index of a given peer ID quick. More...
 
static struct GNUNET_PeerIdentityrps_peer_ids
 IDs of the peers. More...
 
static struct GNUNET_PeerIdentitytarget_peer
 ID of the targeted peer. More...
 
static unsigned int num_peers_online
 Number of online peers. More...
 
static unsigned int view_sizes
 The added sizes of the peer's views. More...
 
static int ok
 Return value from 'main'. More...
 
static struct GNUNET_SCHEDULER_Taskpost_test_task
 Identifier for the task that runs after the test to collect results. More...
 
static struct GNUNET_SCHEDULER_Taskshutdown_task
 Identifier for the shutdown task. More...
 
static struct GNUNET_SCHEDULER_Taskchurn_task
 Identifier for the churn task that runs periodically. More...
 
struct SingleTestRun cur_test_run
 
static int post_test
 Did we finish the test? More...
 
static int in_shutdown
 Are we shutting down? More...
 

Macro Definition Documentation

◆ BIT

#define BIT (   n)    (1 << (n))

Definition at line 39 of file gnunet-rps-profiler.c.

Referenced by post_profiler(), post_test_shutdown_ready_cb(), and run().

◆ tofile

#define tofile (   file_name,
  ... 
)
Value:
do { \
char tmp_buf[512]; \
int size; \
size = GNUNET_snprintf (tmp_buf, sizeof(tmp_buf), __VA_ARGS__); \
if (0 > size) \
"Failed to create tmp_buf\n"); \
tofile_ (file_name, tmp_buf); \
} while (0);
static void tofile_(const char *file_name, const char *line)
Append arguments to file.
static char * file_name
Dump file name.
int GNUNET_snprintf(char *buf, size_t size, const char *format,...) __attribute__((format(printf
Like snprintf, just aborts if the buffer is of insufficient size.
static unsigned int size
Size of the "table".
Definition: peer.c:67

This function is used to facilitate writing important information to disk.

Definition at line 922 of file gnunet-rps-profiler.c.

Referenced by file_name_cb(), info_cb(), profiler_reply_handle(), and profiler_reply_handle_info().

Typedef Documentation

◆ InitPeer

typedef void(* InitPeer) (struct RPSPeer *rps_peer)

Called to initialise the given RPSPeer.

Definition at line 669 of file gnunet-rps-profiler.c.

◆ PreTest

typedef void(* PreTest) (struct RPSPeer *rps_peer, struct GNUNET_RPS_Handle *h)

Called directly after connecting to the service.

Parameters
rps_peerSpecific peer the function is called on
hthe handle to the rps service

Definition at line 677 of file gnunet-rps-profiler.c.

◆ MainTest

typedef void(* MainTest) (struct RPSPeer *rps_peer)

Executes functions to test the api/service for a given peer.

Called from within rps_connect_complete_cb () Implemented by #churn_test_cb, profiler_cb, #mal_cb, #single_req_cb, #delay_req_cb, #seed_big_cb, #single_peer_seed_cb, #seed_cb, #req_cancel_cb

Parameters
rps_peerthe peer the task runs on

Definition at line 688 of file gnunet-rps-profiler.c.

◆ ReplyHandle

typedef void(* ReplyHandle) (void *cls, uint64_t n, const struct GNUNET_PeerIdentity *recv_peers)

Callback called once the requested random peers are available.

Definition at line 693 of file gnunet-rps-profiler.c.

◆ PostTest

typedef void(* PostTest) (struct RPSPeer *peer)

Called directly before disconnecting from the service.

Definition at line 700 of file gnunet-rps-profiler.c.

◆ EvaluationCallback

typedef int(* EvaluationCallback) (void)

Function called after disconnect to evaluate test success.

Definition at line 705 of file gnunet-rps-profiler.c.

Enumeration Type Documentation

◆ STAT_TYPE

enum STAT_TYPE
Enumerator
STAT_TYPE_ROUNDS 
STAT_TYPE_BLOCKS 
STAT_TYPE_BLOCKS_MANY_PUSH 
STAT_TYPE_BLOCKS_NO_PUSH 
STAT_TYPE_BLOCKS_NO_PULL 
STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL 
STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL 
STAT_TYPE_ISSUED_PUSH_SEND 
STAT_TYPE_ISSUED_PUSH_SEND_MH 
STAT_TYPE_ISSUED_PULL_REQ 
STAT_TYPE_ISSUED_PULL_REQ_MH 
STAT_TYPE_ISSUED_PULL_REP 
STAT_TYPE_SENT_PUSH_SEND 
STAT_TYPE_SENT_PULL_REQ 
STAT_TYPE_SENT_PULL_REQ_MH 
STAT_TYPE_SENT_PULL_REP 
STAT_TYPE_RECV_PUSH_SEND 
STAT_TYPE_RECV_PUSH_SEND_MH 
STAT_TYPE_RECV_PULL_REQ 
STAT_TYPE_RECV_PULL_REQ_MH 
STAT_TYPE_RECV_PULL_REP 
STAT_TYPE_RECV_PULL_REP_MH 
STAT_TYPE_VIEW_SIZE 
STAT_TYPE_KNOWN_PEERS 
STAT_TYPE_VALID_PEERS 
STAT_TYPE_LEARND_PEERS 
STAT_TYPE_PENDING_ONLINE_CHECKS 
STAT_TYPE_UNREQUESTED_PULL_REPLIES 
STAT_TYPE_PEERS_IN_PUSH_MAP 
STAT_TYPE_PEERS_IN_PULL_MAP 
STAT_TYPE_PEERS_IN_VIEW 
STAT_TYPE_VIEW_SIZE_AIM 
STAT_TYPE_MAX 

Definition at line 77 of file gnunet-rps-profiler.c.

78 {
79  STAT_TYPE_ROUNDS, /* 0 */
80  STAT_TYPE_BLOCKS, /* 1 */
91  STAT_TYPE_SENT_PUSH_SEND, /* 12 */
92  STAT_TYPE_SENT_PULL_REQ, /* 13 */
94  STAT_TYPE_SENT_PULL_REP, /* 15 */
95  STAT_TYPE_RECV_PUSH_SEND, /* 16 */
97  STAT_TYPE_RECV_PULL_REQ, /* 18 */
99  STAT_TYPE_RECV_PULL_REP, /* 20 */
101  STAT_TYPE_VIEW_SIZE, /* 22 */
102  STAT_TYPE_KNOWN_PEERS, /* 23 */
103  STAT_TYPE_VALID_PEERS, /* 24 */
104  STAT_TYPE_LEARND_PEERS, /* 25 */
109  STAT_TYPE_PEERS_IN_VIEW, /* 30 */
110  STAT_TYPE_VIEW_SIZE_AIM, /* 31 */
111  STAT_TYPE_MAX, /* 32 */
112 };

◆ PEER_ONLINE_DELTA

Indicates whether peer should go off- or online.

Enumerator
PEER_GO_ONLINE 

Indicates peer going online.

PEER_GO_OFFLINE 

Indicates peer going offline.

Definition at line 379 of file gnunet-rps-profiler.c.

380 {
384  PEER_GO_ONLINE = 1,
388  PEER_GO_OFFLINE = -1,
389 };
Indicates peer going online.
Indicates peer going offline.

◆ OPTION_CHURN

Do we have Churn?

Enumerator
HAVE_CHURN 

If we have churn this is set.

HAVE_NO_CHURN 

If we have no churn this is set.

Definition at line 710 of file gnunet-rps-profiler.c.

711 {
715  HAVE_CHURN,
720 };
If we have churn this is set.
If we have no churn this is set.

◆ OPTION_QUICK_QUIT

Is it ok to quit the test before the timeout?

Enumerator
HAVE_QUICK_QUIT 

It is ok for the test to quit before the timeout triggers.

HAVE_NO_QUICK_QUIT 

It is NOT ok for the test to quit before the timeout triggers.

Definition at line 725 of file gnunet-rps-profiler.c.

726 {
731 
736 };
It is NOT ok for the test to quit before the timeout triggers.
It is ok for the test to quit before the timeout triggers.

◆ OPTION_COLLECT_STATISTICS

Do we collect statistics at the end?

Enumerator
COLLECT_STATISTICS 

We collect statistics at the end.

NO_COLLECT_STATISTICS 

We do not collect statistics at the end.

Definition at line 741 of file gnunet-rps-profiler.c.

742 {
747 
752 };
We collect statistics at the end.
We do not collect statistics at the end.

◆ OPTION_COLLECT_VIEW

Do we collect views during run?

Enumerator
COLLECT_VIEW 

We collect view during run.

NO_COLLECT_VIEW 

We do not collect the view during run.

Definition at line 757 of file gnunet-rps-profiler.c.

758 {
762  COLLECT_VIEW,
763 
768 };
We collect view during run.
We do not collect the view during run.

Function Documentation

◆ stat_str_2_type()

enum STAT_TYPE stat_str_2_type ( const char *  stat_str)

Converts string representation to the corresponding STAT_TYPE enum.

Parameters
stat_strstring representation of statistics specifier
Returns
corresponding enum

Definition at line 164 of file gnunet-rps-profiler.c.

References STAT_TYPE_BLOCKS, STAT_TYPE_BLOCKS_MANY_PUSH, STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL, STAT_TYPE_BLOCKS_NO_PULL, STAT_TYPE_BLOCKS_NO_PUSH, STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL, STAT_TYPE_ISSUED_PULL_REP, STAT_TYPE_ISSUED_PULL_REQ, STAT_TYPE_ISSUED_PULL_REQ_MH, STAT_TYPE_ISSUED_PUSH_SEND, STAT_TYPE_ISSUED_PUSH_SEND_MH, STAT_TYPE_KNOWN_PEERS, STAT_TYPE_LEARND_PEERS, STAT_TYPE_MAX, STAT_TYPE_PEERS_IN_PULL_MAP, STAT_TYPE_PEERS_IN_PUSH_MAP, STAT_TYPE_PEERS_IN_VIEW, STAT_TYPE_PENDING_ONLINE_CHECKS, STAT_TYPE_RECV_PULL_REP, STAT_TYPE_RECV_PULL_REP_MH, STAT_TYPE_RECV_PULL_REQ, STAT_TYPE_RECV_PULL_REQ_MH, STAT_TYPE_RECV_PUSH_SEND, STAT_TYPE_RECV_PUSH_SEND_MH, STAT_TYPE_ROUNDS, STAT_TYPE_SENT_PULL_REP, STAT_TYPE_SENT_PULL_REQ, STAT_TYPE_SENT_PULL_REQ_MH, STAT_TYPE_SENT_PUSH_SEND, stat_type_strings, STAT_TYPE_UNREQUESTED_PULL_REPLIES, STAT_TYPE_VALID_PEERS, STAT_TYPE_VIEW_SIZE, and STAT_TYPE_VIEW_SIZE_AIM.

Referenced by stat_iterator().

165 {
166  if (0 == strncmp (stat_type_strings[STAT_TYPE_BLOCKS_NO_PULL],
167  stat_str,
168  strlen (stat_type_strings[STAT_TYPE_BLOCKS_NO_PULL])))
169  {
171  }
173  stat_str,
174  strlen (
175  stat_type_strings[STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL])))
176  {
178  }
179  else if (0 == strncmp (stat_type_strings[STAT_TYPE_BLOCKS_MANY_PUSH],
180  stat_str,
181  strlen (
182  stat_type_strings[STAT_TYPE_BLOCKS_MANY_PUSH])))
183  {
185  }
186  else if (0 == strncmp (stat_type_strings[STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL],
187  stat_str,
188  strlen (
189  stat_type_strings[STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL])))
190  {
192  }
193  else if (0 == strncmp (stat_type_strings[STAT_TYPE_BLOCKS_NO_PUSH],
194  stat_str,
195  strlen (stat_type_strings[STAT_TYPE_BLOCKS_NO_PUSH])))
196  {
198  }
199  else if (0 == strncmp (stat_type_strings[STAT_TYPE_BLOCKS],
200  stat_str,
201  strlen (stat_type_strings[STAT_TYPE_BLOCKS])))
202  {
203  return STAT_TYPE_BLOCKS;
204  }
205  else if (0 == strncmp (stat_type_strings[STAT_TYPE_ROUNDS],
206  stat_str,
207  strlen (stat_type_strings[STAT_TYPE_ROUNDS])))
208  {
209  return STAT_TYPE_ROUNDS;
210  }
211  else if (0 == strncmp (stat_type_strings[STAT_TYPE_ISSUED_PUSH_SEND],
212  stat_str,
213  strlen (
214  stat_type_strings[STAT_TYPE_ISSUED_PUSH_SEND])))
215  {
217  }
218  else if (0 == strncmp (stat_type_strings[STAT_TYPE_ISSUED_PUSH_SEND_MH],
219  stat_str,
220  strlen (
221  stat_type_strings[STAT_TYPE_ISSUED_PUSH_SEND_MH])))
222  {
224  }
225  else if (0 == strncmp (stat_type_strings[STAT_TYPE_ISSUED_PULL_REQ],
226  stat_str,
227  strlen (stat_type_strings[STAT_TYPE_ISSUED_PULL_REQ])))
228  {
230  }
231  else if (0 == strncmp (stat_type_strings[STAT_TYPE_ISSUED_PULL_REQ_MH],
232  stat_str,
233  strlen (
234  stat_type_strings[STAT_TYPE_ISSUED_PULL_REQ_MH])))
235  {
237  }
238  else if (0 == strncmp (stat_type_strings[STAT_TYPE_ISSUED_PULL_REP],
239  stat_str,
240  strlen (stat_type_strings[STAT_TYPE_ISSUED_PULL_REP])))
241  {
243  }
244  else if (0 == strncmp (stat_type_strings[STAT_TYPE_SENT_PUSH_SEND],
245  stat_str,
246  strlen (stat_type_strings[STAT_TYPE_SENT_PUSH_SEND])))
247  {
249  }
250  else if (0 == strncmp (stat_type_strings[STAT_TYPE_SENT_PULL_REQ],
251  stat_str,
252  strlen (stat_type_strings[STAT_TYPE_SENT_PULL_REQ])))
253  {
255  }
256  else if (0 == strncmp (stat_type_strings[STAT_TYPE_SENT_PULL_REQ_MH],
257  stat_str,
258  strlen (
259  stat_type_strings[STAT_TYPE_SENT_PULL_REQ_MH])))
260  {
262  }
263  else if (0 == strncmp (stat_type_strings[STAT_TYPE_SENT_PULL_REP],
264  stat_str,
265  strlen (stat_type_strings[STAT_TYPE_SENT_PULL_REP])))
266  {
268  }
269  else if (0 == strncmp (stat_type_strings[STAT_TYPE_RECV_PUSH_SEND],
270  stat_str,
271  strlen (stat_type_strings[STAT_TYPE_RECV_PUSH_SEND])))
272  {
274  }
275  else if (0 == strncmp (stat_type_strings[STAT_TYPE_RECV_PUSH_SEND_MH],
276  stat_str,
277  strlen (
278  stat_type_strings[STAT_TYPE_RECV_PUSH_SEND_MH])))
279  {
281  }
282  else if (0 == strncmp (stat_type_strings[STAT_TYPE_RECV_PULL_REQ],
283  stat_str,
284  strlen (stat_type_strings[STAT_TYPE_RECV_PULL_REQ])))
285  {
287  }
288  else if (0 == strncmp (stat_type_strings[STAT_TYPE_RECV_PULL_REQ_MH],
289  stat_str,
290  strlen (
291  stat_type_strings[STAT_TYPE_RECV_PULL_REQ_MH])))
292  {
294  }
295  else if (0 == strncmp (stat_type_strings[STAT_TYPE_RECV_PULL_REP],
296  stat_str,
297  strlen (stat_type_strings[STAT_TYPE_RECV_PULL_REP])))
298  {
300  }
301  else if (0 == strncmp (stat_type_strings[STAT_TYPE_RECV_PULL_REP_MH],
302  stat_str,
303  strlen (
304  stat_type_strings[STAT_TYPE_RECV_PULL_REP_MH])))
305  {
307  }
308  else if (0 == strncmp (stat_type_strings[STAT_TYPE_VIEW_SIZE],
309  stat_str,
310  strlen (stat_type_strings[STAT_TYPE_VIEW_SIZE])))
311  {
312  return STAT_TYPE_VIEW_SIZE;
313  }
314  else if (0 == strncmp (stat_type_strings[STAT_TYPE_KNOWN_PEERS],
315  stat_str,
316  strlen (stat_type_strings[STAT_TYPE_KNOWN_PEERS])))
317  {
318  return STAT_TYPE_KNOWN_PEERS;
319  }
320  else if (0 == strncmp (stat_type_strings[STAT_TYPE_VALID_PEERS],
321  stat_str,
322  strlen (stat_type_strings[STAT_TYPE_VALID_PEERS])))
323  {
324  return STAT_TYPE_VALID_PEERS;
325  }
326  else if (0 == strncmp (stat_type_strings[STAT_TYPE_LEARND_PEERS],
327  stat_str,
328  strlen (stat_type_strings[STAT_TYPE_LEARND_PEERS])))
329  {
330  return STAT_TYPE_LEARND_PEERS;
331  }
332  else if (0 == strncmp (stat_type_strings[STAT_TYPE_PENDING_ONLINE_CHECKS],
333  stat_str,
334  strlen (
335  stat_type_strings[STAT_TYPE_PENDING_ONLINE_CHECKS])))
336  {
338  }
340  stat_str,
341  strlen (
342  stat_type_strings[STAT_TYPE_UNREQUESTED_PULL_REPLIES])))
343  {
345  }
346  else if (0 == strncmp (stat_type_strings[STAT_TYPE_PEERS_IN_PUSH_MAP],
347  stat_str,
348  strlen (
349  stat_type_strings[STAT_TYPE_PEERS_IN_PUSH_MAP])))
350  {
352  }
353  else if (0 == strncmp (stat_type_strings[STAT_TYPE_PEERS_IN_PULL_MAP],
354  stat_str,
355  strlen (
356  stat_type_strings[STAT_TYPE_PEERS_IN_PULL_MAP])))
357  {
359  }
360  else if (0 == strncmp (stat_type_strings[STAT_TYPE_PEERS_IN_VIEW],
361  stat_str,
362  strlen (stat_type_strings[STAT_TYPE_PEERS_IN_VIEW])))
363  {
365  }
366  else if (0 == strncmp (stat_type_strings[STAT_TYPE_VIEW_SIZE_AIM],
367  stat_str,
368  strlen (stat_type_strings[STAT_TYPE_VIEW_SIZE_AIM])))
369  {
371  }
372  return STAT_TYPE_MAX;
373 }
static char * stat_type_strings[]
Here is the caller graph for this function:

◆ tofile_()

static void tofile_ ( const char *  file_name,
const char *  line 
)
static

Append arguments to file.

Definition at line 861 of file gnunet-rps-profiler.c.

References removetrailingwhitespace::f, GNUNET_DISK_file_close(), GNUNET_DISK_file_open(), GNUNET_DISK_file_write(), GNUNET_DISK_OPEN_APPEND, GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_OPEN_WRITE, GNUNET_DISK_PERM_GROUP_READ, GNUNET_DISK_PERM_OTHER_READ, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_YES, and size.

862 {
863  struct GNUNET_DISK_FileHandle *f;
864  /* char output_buffer[512]; */
865  size_t size;
866  /* int size; */
867  size_t size2;
868 
869  if (NULL == (f = GNUNET_DISK_file_open (file_name,
877  {
879  "Not able to open file %s\n",
880  file_name);
881  return;
882  }
883  /* size = GNUNET_snprintf (output_buffer,
884  sizeof (output_buffer),
885  "%llu %s\n",
886  GNUNET_TIME_absolute_get ().abs_value_us,
887  line);
888  if (0 > size)
889  {
890  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
891  "Failed to write string to buffer (size: %i)\n",
892  size);
893  return;
894  } */size = strlen (line) * sizeof(char);
895 
896  size2 = GNUNET_DISK_file_write (f, line, size);
897  if (size != size2)
898  {
900  "Unable to write to file! (Size: %lu, size2: %lu)\n",
901  size,
902  size2);
904  {
906  "Unable to close file\n");
907  }
908  return;
909  }
910 
912  {
914  "Unable to close file\n");
915  }
916 }
Create file if it doesn&#39;t exist.
int GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1280
static char * file_name
Dump file name.
Append to the file.
static char * line
Desired phone line (string to be converted to a hash).
ssize_t GNUNET_DISK_file_write(const struct GNUNET_DISK_FileHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: disk.c:820
static unsigned int size
Size of the "table".
Definition: peer.c:67
Open the file for writing.
Everybody can read.
#define GNUNET_log(kind,...)
struct GNUNET_DISK_FileHandle * GNUNET_DISK_file_open(const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
Open a file.
Definition: disk.c:1203
Handle used to access files (and pipes).
Here is the call graph for this function:

◆ evaluate()

static int evaluate ( void  )
static

Write the ids and their according index in the given array to a file Unused.

Test the success of a single test

Definition at line 958 of file gnunet-rps-profiler.c.

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, RPSPeer::num_ids_to_request, num_peers, RPSPeer::num_recv_ids, and peer_id.

Referenced by default_reply_handle(), and profiler_eval().

959 {
960  unsigned int i;
961  int tmp_ok;
962 
963  tmp_ok = 1;
964 
965  for (i = 0; i < num_peers; i++)
966  {
968  "%u. peer [%s] received %u of %u expected peer_ids: %i\n",
969  i,
971  rps_peers[i].num_recv_ids,
972  rps_peers[i].num_ids_to_request,
973  (rps_peers[i].num_ids_to_request == rps_peers[i].num_recv_ids));
974  tmp_ok &= (rps_peers[i].num_ids_to_request == rps_peers[i].num_recv_ids);
975  }
976  return tmp_ok ? 0 : 1;
977 }
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
static struct RPSPeer * rps_peers
Information for all the peers.
unsigned int num_ids_to_request
Number of Peer IDs to request during the whole test.
unsigned int num_recv_ids
Number of received PeerIDs.
#define GNUNET_log(kind,...)
static uint32_t num_peers
How many peers do we start?
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
Here is the call graph for this function:
Here is the caller graph for this function:

◆ make_oplist_entry()

static struct OpListEntry* make_oplist_entry ( )
static

Creates an oplist entry and adds it to the oplist DLL.

Definition at line 984 of file gnunet-rps-profiler.c.

References GNUNET_CONTAINER_DLL_insert_tail, and GNUNET_new.

Referenced by manage_service_wrapper(), and test_run().

985 {
986  struct OpListEntry *entry;
987 
988  entry = GNUNET_new (struct OpListEntry);
990  return entry;
991 }
static struct OpListEntry * oplist_tail
OpList DLL tail.
static struct OpListEntry * oplist_head
OpList DLL head.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Operation map entry.
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
Here is the caller graph for this function:

◆ check_statistics_collect_completed_single_peer()

static int check_statistics_collect_completed_single_peer ( const struct RPSPeer rps_peer)
static

Checks if given peer already received its statistics value from the statistics service.

Parameters
rps_peerthe peer to check for
Returns
GNUNET_YES if so GNUNET_NO otherwise

Definition at line 1004 of file gnunet-rps-profiler.c.

References cur_test_run, GNUNET_NO, GNUNET_YES, SingleTestRun::stat_collect_flags, and RPSPeer::stat_collected_flags.

Referenced by check_statistics_collect_completed(), and post_test_shutdown_ready_cb().

1006 {
1009  & rps_peer->stat_collected_flags))
1010  {
1011  return GNUNET_NO;
1012  }
1013  return GNUNET_YES;
1014 }
struct SingleTestRun cur_test_run
uint32_t stat_collect_flags
Mark which values from the statistics service to collect at the end of the run.
uint32_t stat_collected_flags
flags to indicate which statistics values have been already collected from the statistics service...
Here is the caller graph for this function:

◆ check_statistics_collect_completed()

static int check_statistics_collect_completed ( )
static

Checks if all peers already received their statistics value from the statistics service.

Returns
GNUNET_YES if so GNUNET_NO otherwise

Definition at line 1025 of file gnunet-rps-profiler.c.

References check_statistics_collect_completed_single_peer(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_YES, num_peers, op_result(), and rps_disconnect_adapter().

Referenced by post_test_op(), and post_test_shutdown_ready_cb().

1026 {
1027  uint32_t i;
1028 
1029  for (i = 0; i < num_peers; i++)
1030  {
1032  &rps_peers[i]))
1033  {
1035  "At least Peer %" PRIu32
1036  " did not yet receive all statistics values\n",
1037  i);
1038  return GNUNET_NO;
1039  }
1040  }
1042  "All peers received their statistics values\n");
1043  return GNUNET_YES;
1044 }
static struct RPSPeer * rps_peers
Information for all the peers.
#define GNUNET_log(kind,...)
static uint32_t num_peers
How many peers do we start?
static int check_statistics_collect_completed_single_peer(const struct RPSPeer *rps_peer)
Checks if given peer already received its statistics value from the statistics service.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ rps_disconnect_adapter()

static void rps_disconnect_adapter ( void *  cls,
void *  op_result 
)
static

Adapter function called to destroy connection to RPS service.

Parameters
clsclosure
op_resultservice handle returned from the connect adapter

Definition at line 1437 of file gnunet-rps-profiler.c.

References cancel_request(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_RPS_disconnect(), h, RPSPeer::index, op_result(), peer, RPSPeer::pending_rep_head, and RPSPeer::rps_handle.

Referenced by check_statistics_collect_completed(), clean_peer(), and test_run().

1439 {
1440  struct RPSPeer *peer = cls;
1441  struct GNUNET_RPS_Handle *h = op_result;
1442  struct PendingReply *pending_rep;
1443 
1445  "disconnect_adapter (%u)\n",
1446  peer->index);
1447  GNUNET_assert (NULL != peer);
1448  if (NULL != peer->rps_handle)
1449  {
1450  while (NULL != (pending_rep = peer->pending_rep_head))
1451  {
1452  cancel_request (pending_rep);
1453  }
1454  GNUNET_assert (h == peer->rps_handle);
1455  if (NULL != h)
1456  {
1458  h = NULL;
1459  }
1460  peer->rps_handle = NULL;
1461  }
1462 }
struct PendingReply * pending_rep_head
Pending replies DLL.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static int op_result(struct GNUNET_OP_Handle *h, uint64_t op_id, int64_t result_code, const void *data, uint16_t data_size, void **ctx, uint8_t cancel)
Remove an operation, and call its result callback (unless it was cancelled).
Definition: op.c:245
A pending reply: A request was sent and the reply is pending.
void GNUNET_RPS_disconnect(struct GNUNET_RPS_Handle *h)
Disconnect from the rps service.
Definition: rps_api.c:1263
Handler to handle requests from a client.
Definition: rps_api.c:78
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
struct GNUNET_RPS_Handle * rps_handle
Handle to RPS service.
static void cancel_request(struct PendingReply *pending_rep)
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
Information we track for each peer.
#define GNUNET_log(kind,...)
uint32_t index
Index of the peer.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ cancel_pending_req()

static void cancel_pending_req ( struct PendingRequest pending_req)
static

Definition at line 1052 of file gnunet-rps-profiler.c.

References GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_SCHEDULER_cancel(), RPSPeer::num_pending_reqs, RPSPeer::pending_req_head, RPSPeer::pending_req_tail, PendingRequest::request_task, STATcls::rps_peer, and PendingRequest::rps_peer.

Referenced by cancel_pending_req_rep(), and clean_peer().

1053 {
1054  struct RPSPeer *rps_peer;
1055 
1056  rps_peer = pending_req->rps_peer;
1058  rps_peer->pending_req_tail,
1059  pending_req);
1060  rps_peer->num_pending_reqs--;
1062  "Cancelling pending rps get request\n");
1063  GNUNET_SCHEDULER_cancel (pending_req->request_task);
1064  GNUNET_free (pending_req);
1065 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct PendingRequest * pending_req_tail
struct GNUNET_SCHEDULER_Task * request_task
Handle to the request we are waiting for.
struct PendingRequest * pending_req_head
Pending requests DLL.
struct RPSPeer * rps_peer
The peer that requested.
Information we track for each peer.
#define GNUNET_log(kind,...)
unsigned int num_pending_reqs
Number of pending requests.
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
Here is the call graph for this function:
Here is the caller graph for this function:

◆ cancel_request()

static void cancel_request ( struct PendingReply pending_rep)
static

Definition at line 1069 of file gnunet-rps-profiler.c.

References GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_RPS_request_single_info_cancel(), RPSPeer::num_pending_reps, RPSPeer::pending_rep_head, RPSPeer::pending_rep_tail, PendingReply::req_handle, STATcls::rps_peer, and PendingReply::rps_peer.

Referenced by cancel_pending_req_rep(), and rps_disconnect_adapter().

1070 {
1071  struct RPSPeer *rps_peer;
1072 
1073  rps_peer = pending_rep->rps_peer;
1075  rps_peer->pending_rep_tail,
1076  pending_rep);
1077  rps_peer->num_pending_reps--;
1079  "Cancelling rps get reply\n");
1080  GNUNET_assert (NULL != pending_rep->req_handle);
1082  pending_rep->req_handle = NULL;
1083  GNUNET_free (pending_rep);
1084  pending_rep = NULL;
1085 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct GNUNET_RPS_Request_Handle_Single_Info * req_handle
Handle to the request we are waiting for.
struct PendingReply * pending_rep_head
Pending replies DLL.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
void GNUNET_RPS_request_single_info_cancel(struct GNUNET_RPS_Request_Handle_Single_Info *rhs)
Cancel an issued single info request.
Definition: rps_api.c:1231
unsigned int num_pending_reps
Number of pending replies.
Information we track for each peer.
#define GNUNET_log(kind,...)
struct PendingReply * pending_rep_tail
struct RPSPeer * rps_peer
The peer that requested.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ clean_peer()

void clean_peer ( unsigned  peer_index)

Definition at line 1089 of file gnunet-rps-profiler.c.

References cancel_pending_req(), GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_STATISTICS_get_cancel(), GNUNET_TESTBED_operation_done(), op, RPSPeer::op, RPSPeer::pending_req_head, rps_disconnect_adapter(), rps_handle, STATcls::stat_type, STAT_TYPE_MAX, STAT_TYPE_ROUNDS, and stat_type_strings.

Referenced by shutdown_op().

1090 {
1091  struct PendingRequest *pending_req;
1092 
1093  while (NULL != (pending_req = rps_peers[peer_index].pending_req_head))
1094  {
1095  cancel_pending_req (pending_req);
1096  }
1097  pending_req = rps_peers[peer_index].pending_req_head;
1098  rps_disconnect_adapter (&rps_peers[peer_index],
1099  &rps_peers[peer_index].rps_handle);
1100  for (unsigned stat_type = STAT_TYPE_ROUNDS;
1101  stat_type < STAT_TYPE_MAX;
1102  stat_type++)
1103  {
1104  if (NULL != rps_peers[peer_index].h_stat_get[stat_type])
1105  {
1107  "(%u) did not yet receive stat value for `%s'\n",
1108  rps_peers[peer_index].index,
1109  stat_type_strings[stat_type]);
1111  rps_peers[peer_index].h_stat_get[stat_type]);
1112  }
1113  }
1114  if (NULL != rps_peers[peer_index].op)
1115  {
1116  GNUNET_TESTBED_operation_done (rps_peers[peer_index].op);
1117  rps_peers[peer_index].op = NULL;
1118  }
1119 }
A pending request: A request was not made yet but is scheduled for later.
void GNUNET_STATISTICS_get_cancel(struct GNUNET_STATISTICS_GetHandle *gh)
Cancel a GNUNET_STATISTICS_get request.
static struct GNUNET_RPS_Handle * rps_handle
RPS handle.
Definition: gnunet-rps.c:36
static char * stat_type_strings[]
static struct RPSPeer * rps_peers
Information for all the peers.
struct PendingRequest * pending_req_head
Pending requests DLL.
void GNUNET_TESTBED_operation_done(struct GNUNET_TESTBED_Operation *operation)
This function is used to signal that the event information (struct GNUNET_TESTBED_EventInformation) f...
Definition: testbed_api.c:2045
struct GNUNET_TESTBED_Operation * op
Handle for RPS connect operation.
static void rps_disconnect_adapter(void *cls, void *op_result)
Adapter function called to destroy connection to RPS service.
#define GNUNET_log(kind,...)
static void cancel_pending_req(struct PendingRequest *pending_req)
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
Here is the call graph for this function:
Here is the caller graph for this function:

◆ shutdown_op()

static void shutdown_op ( void *  cls)
static

Task run on timeout to shut everything down.

Definition at line 1126 of file gnunet-rps-profiler.c.

References clean_peer(), close_all_files(), GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_SCHEDULER_cancel(), GNUNET_TESTBED_operation_done(), GNUNET_YES, in_shutdown, OpListEntry::index, num_peers, OpListEntry::op, and oplist_head.

Referenced by test_run().

1127 {
1128  unsigned int i;
1129  struct OpListEntry *entry;
1130 
1131  (void) cls;
1132 
1134  "Shutdown task scheduled, going down.\n");
1136 
1137  if (NULL != shutdown_task)
1138  {
1140  shutdown_task = NULL;
1141  }
1142  if (NULL != post_test_task)
1143  {
1145  post_test_task = NULL;
1146  }
1147  if (NULL != churn_task)
1148  {
1150  churn_task = NULL;
1151  }
1152  entry = oplist_head;
1153  while (NULL != (entry = oplist_head))
1154  {
1156  "Operation still pending on shutdown (%u)\n",
1157  entry->index);
1160  GNUNET_free (entry);
1161  }
1162  for (i = 0; i < num_peers; i++)
1163  {
1164  clean_peer (i);
1165  }
1166  close_all_files ();
1167 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
static struct OpListEntry * oplist_tail
OpList DLL tail.
static struct OpListEntry * oplist_head
OpList DLL head.
Operation map entry.
void GNUNET_TESTBED_operation_done(struct GNUNET_TESTBED_Operation *operation)
This function is used to signal that the event information (struct GNUNET_TESTBED_EventInformation) f...
Definition: testbed_api.c:2045
void clean_peer(unsigned peer_index)
int close_all_files()
Close all files that were opened with get_file_handle.
static struct GNUNET_SCHEDULER_Task * post_test_task
Identifier for the task that runs after the test to collect results.
#define GNUNET_log(kind,...)
unsigned int index
Index of the regarding peer.
static struct GNUNET_SCHEDULER_Task * shutdown_task
Identifier for the shutdown task.
static struct GNUNET_SCHEDULER_Task * churn_task
Identifier for the churn task that runs periodically.
static uint32_t num_peers
How many peers do we start?
static int in_shutdown
Are we shutting down?
struct GNUNET_TESTBED_Operation * op
The testbed operation.
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
Here is the call graph for this function:
Here is the caller graph for this function:

◆ trigger_shutdown()

static void trigger_shutdown ( void *  cls)
static

Definition at line 1171 of file gnunet-rps-profiler.c.

References GNUNET_ERROR_TYPE_INFO, GNUNET_log, and GNUNET_SCHEDULER_shutdown().

Referenced by test_run().

1172 {
1173  (void) cls;
1174 
1176  "Shutdown was triggerd by timeout, going down.\n");
1177  shutdown_task = NULL;
1179 }
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:531
#define GNUNET_log(kind,...)
static struct GNUNET_SCHEDULER_Task * shutdown_task
Identifier for the shutdown task.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ post_test_op()

static void post_test_op ( void *  cls)
static

Task run after duration to collect statistics and potentially shut down.

Definition at line 1186 of file gnunet-rps-profiler.c.

References check_statistics_collect_completed(), cur_test_run, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_shutdown(), GNUNET_TESTBED_operation_done(), GNUNET_YES, SingleTestRun::have_collect_statistics, OpListEntry::index, NO_COLLECT_STATISTICS, num_peers, op, RPSPeer::op, SingleTestRun::post_test, and post_test.

Referenced by default_reply_handle(), and test_run().

1187 {
1188  unsigned int i;
1189 
1190  (void) cls;
1191 
1192  post_test_task = NULL;
1195  "Executing post test op.\n");
1196  if (NULL != churn_task)
1197  {
1199  churn_task = NULL;
1200  }
1201  for (i = 0; i < num_peers; i++)
1202  {
1204  "Executing post test op. (peer %" PRIu32 ")\n",
1205  rps_peers[i].index);
1206  if (NULL != rps_peers[i].op)
1207  {
1209  rps_peers[i].op = NULL;
1211  "Cancelled testbed operation\n");
1212  }
1213  if (NULL != cur_test_run.post_test)
1214  {
1215  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Executing post_test for peer %u\n",
1216  i);
1218  }
1219  }
1220  /* If we do not collect statistics, shut down directly */
1223  {
1225  shutdown_task = NULL;
1227  }
1228 }
PostTest post_test
Called directly before disconnecting from the service.
static int check_statistics_collect_completed()
Checks if all peers already received their statistics value from the statistics service.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:531
struct SingleTestRun cur_test_run
static int post_test
Did we finish the test?
static struct RPSPeer * rps_peers
Information for all the peers.
enum OPTION_COLLECT_STATISTICS have_collect_statistics
Collect statistics at the end?
void GNUNET_TESTBED_operation_done(struct GNUNET_TESTBED_Operation *operation)
This function is used to signal that the event information (struct GNUNET_TESTBED_EventInformation) f...
Definition: testbed_api.c:2045
struct GNUNET_TESTBED_Operation * op
Handle for RPS connect operation.
static struct GNUNET_SCHEDULER_Task * post_test_task
Identifier for the task that runs after the test to collect results.
#define GNUNET_log(kind,...)
unsigned int index
Index of the regarding peer.
static struct GNUNET_SCHEDULER_Task * shutdown_task
Identifier for the shutdown task.
static struct GNUNET_SCHEDULER_Task * churn_task
Identifier for the churn task that runs periodically.
We do not collect statistics at the end.
static uint32_t num_peers
How many peers do we start?
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
Here is the call graph for this function:
Here is the caller graph for this function:

◆ info_cb()

void info_cb ( void *  cb_cls,
struct GNUNET_TESTBED_Operation op,
const struct GNUNET_TESTBED_PeerInformation pinfo,
const char *  emsg 
)

Get the id of peer i.

Definition at line 1235 of file gnunet-rps-profiler.c.

References GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_i2s(), GNUNET_i2s_full(), GNUNET_log, GNUNET_OK, GNUNET_TESTBED_operation_done(), GNUNET_YES, GNUNET_TESTBED_PeerInformation::id, in_shutdown, OpListEntry::index, OpListEntry::op, RPSPeer::peer_id, post_test, GNUNET_TESTBED_PeerInformation::result, and tofile.

Referenced by test_run().

1239 {
1240  struct OpListEntry *entry = (struct OpListEntry *) cb_cls;
1241 
1242  (void) op;
1243 
1244  if ((GNUNET_YES == in_shutdown) || (GNUNET_YES == post_test))
1245  {
1246  return;
1247  }
1248 
1249  if ((NULL == pinfo) || (NULL != emsg))
1250  {
1251  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Got Error: %s\n", emsg);
1253  return;
1254  }
1255 
1257  "Peer %u is %s\n",
1258  entry->index,
1259  GNUNET_i2s (pinfo->result.id));
1260 
1261  rps_peer_ids[entry->index] = *(pinfo->result.id);
1262  rps_peers[entry->index].peer_id = &rps_peer_ids[entry->index];
1263 
1266  &rps_peer_ids[entry->index],
1267  &rps_peers[entry->index],
1269  tofile ("/tmp/rps/peer_ids",
1270  "%u\t%s\n",
1271  entry->index,
1272  GNUNET_i2s_full (&rps_peer_ids[entry->index]));
1273 
1276  GNUNET_free (entry);
1277 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
static struct OpListEntry * oplist_tail
OpList DLL tail.
static struct OpListEntry * oplist_head
OpList DLL head.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
union GNUNET_TESTBED_PeerInformation::@73 result
The result of the get information operation; Choose according to the pit.
const char * GNUNET_i2s_full(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define tofile(file_name,...)
This function is used to facilitate writing important information to disk.
static int post_test
Did we finish the test?
struct GNUNET_PeerIdentity * id
The identity of the peer.
static struct RPSPeer * rps_peers
Information for all the peers.
static struct GNUNET_CONTAINER_MultiPeerMap * peer_map
Peermap to get the index of a given peer ID quick.
Operation map entry.
struct GNUNET_PeerIdentity * peer_id
ID of the peer.
void GNUNET_TESTBED_operation_done(struct GNUNET_TESTBED_Operation *operation)
This function is used to signal that the event information (struct GNUNET_TESTBED_EventInformation) f...
Definition: testbed_api.c:2045
There must only be one value per key; storing a value should fail if a value under the same key alrea...
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
#define GNUNET_log(kind,...)
unsigned int index
Index of the regarding peer.
static int in_shutdown
Are we shutting down?
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct GNUNET_TESTBED_Operation * op
The testbed operation.
static struct GNUNET_PeerIdentity * rps_peer_ids
IDs of the peers.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ rps_connect_complete_cb()

static void rps_connect_complete_cb ( void *  cls,
struct GNUNET_TESTBED_Operation op,
void *  ca_result,
const char *  emsg 
)
static

Callback to be called when RPS service connect operation is completed.

Parameters
clsthe callback closure from functions generating an operation
opthe operation that has been finished
ca_resultthe RPS service handle returned from rps_connect_adapter
emsgerror message in case the operation has failed; will be NULL if operation has executed successfully.

Definition at line 1290 of file gnunet-rps-profiler.c.

References cur_test_run, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_SCHEDULER_shutdown(), GNUNET_YES, in_shutdown, RPSPeer::index, SingleTestRun::main_test, num_peers_online, ok, RPSPeer::online, RPSPeer::op, post_test, and RPSPeer::rps_handle.

Referenced by test_run().

1294 {
1295  struct RPSPeer *rps_peer = cls;
1296  struct GNUNET_RPS_Handle *rps = ca_result;
1297 
1298  if ((GNUNET_YES == in_shutdown) || (GNUNET_YES == post_test))
1299  {
1300  return;
1301  }
1302 
1303  rps_peer->rps_handle = rps;
1304  rps_peer->online = GNUNET_YES;
1305  num_peers_online++;
1306 
1307  GNUNET_assert (op == rps_peer->op);
1308  if (NULL != emsg)
1309  {
1311  "Failed to connect to RPS service: %s\n",
1312  emsg);
1313  ok = 1;
1315  return;
1316  }
1317 
1319  "Started client successfully (%u)\n",
1320  rps_peer->index);
1321 
1322  cur_test_run.main_test (rps_peer);
1323 }
int online
A request handle to check for an request.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static int ok
Return value from &#39;main&#39;.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:531
Handler to handle requests from a client.
Definition: rps_api.c:78
struct SingleTestRun cur_test_run
static int post_test
Did we finish the test?
static unsigned int num_peers_online
Number of online peers.
struct GNUNET_RPS_Handle * rps_handle
Handle to RPS service.
struct GNUNET_TESTBED_Operation * op
Handle for RPS connect operation.
MainTest main_test
Main function for each peer.
Information we track for each peer.
#define GNUNET_log(kind,...)
static int in_shutdown
Are we shutting down?
uint32_t index
Index of the peer.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ rps_connect_adapter()

static void* rps_connect_adapter ( void *  cls,
const struct GNUNET_CONFIGURATION_Handle cfg 
)
static

Adapter function called to establish a connection to the RPS service.

Parameters
clsclosure
cfgconfiguration of the peer to connect to; will be available until GNUNET_TESTBED_operation_done() is called on the operation returned from GNUNET_TESTBED_service_connect()
Returns
service handle to return in 'op_result', NULL on error

Definition at line 1337 of file gnunet-rps-profiler.c.

References cur_test_run, GNUNET_RPS_connect(), h, and SingleTestRun::pre_test.

Referenced by test_run().

1339 {
1340  struct GNUNET_RPS_Handle *h;
1341 
1342  h = GNUNET_RPS_connect (cfg);
1343 
1344  if (NULL != cur_test_run.pre_test)
1345  cur_test_run.pre_test (cls, h);
1346 
1347  return h;
1348 }
Handler to handle requests from a client.
Definition: rps_api.c:78
struct SingleTestRun cur_test_run
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
struct GNUNET_RPS_Handle * GNUNET_RPS_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the rps service.
Definition: rps_api.c:843
PreTest pre_test
Called directly after connecting to the service.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ stat_connect_adapter()

static void* stat_connect_adapter ( void *  cls,
const struct GNUNET_CONFIGURATION_Handle cfg 
)
static

Called to open a connection to the peer's statistics.

Parameters
clspeer context
cfgconfiguration of the peer to connect to; will be available until GNUNET_TESTBED_operation_done() is called on the operation returned from GNUNET_TESTBED_service_connect()
Returns
service handle to return in 'op_result', NULL on error

Definition at line 1361 of file gnunet-rps-profiler.c.

References GNUNET_STATISTICS_create(), peer, and RPSPeer::stats_h.

Referenced by test_run().

1363 {
1364  struct RPSPeer *peer = cls;
1365 
1366  peer->stats_h = GNUNET_STATISTICS_create ("rps-profiler", cfg);
1367  return peer->stats_h;
1368 }
struct GNUNET_STATISTICS_Handle * GNUNET_STATISTICS_create(const char *subsystem, const struct GNUNET_CONFIGURATION_Handle *cfg)
Get handle for the statistics service.
struct GNUNET_STATISTICS_Handle * stats_h
Handle to the statistics service.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
Information we track for each peer.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ stat_disconnect_adapter()

static void stat_disconnect_adapter ( void *  cls,
void *  op_result 
)
static

Called to disconnect from peer's statistics service.

Parameters
clspeer context
op_resultservice handle returned from the connect adapter

Definition at line 1378 of file gnunet-rps-profiler.c.

References GNUNET_NO, GNUNET_STATISTICS_destroy(), peer, and RPSPeer::stats_h.

Referenced by test_run().

1379 {
1380  struct RPSPeer *peer = cls;
1381 
1382  // GNUNET_break (GNUNET_OK == GNUNET_STATISTICS_watch_cancel
1383  // (peer->stats_h, "core", "# peers connected",
1384  // stat_iterator, peer));
1385  // GNUNET_break (GNUNET_OK == GNUNET_STATISTICS_watch_cancel
1386  // (peer->stats_h, "nse", "# peers connected",
1387  // stat_iterator, peer));
1389  peer->stats_h = NULL;
1390 }
static int op_result(struct GNUNET_OP_Handle *h, uint64_t op_id, int64_t result_code, const void *data, uint16_t data_size, void **ctx, uint8_t cancel)
Remove an operation, and call its result callback (unless it was cancelled).
Definition: op.c:245
struct GNUNET_STATISTICS_Handle * stats_h
Handle to the statistics service.
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
Information we track for each peer.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ stat_complete_cb()

static void stat_complete_cb ( void *  cls,
struct GNUNET_TESTBED_Operation op,
void *  ca_result,
const char *  emsg 
)
static

Called after successfully opening a connection to a peer's statistics service; we register statistics monitoring for CORE and NSE here.

Parameters
clsthe callback closure from functions generating an operation
opthe operation that has been finished
ca_resultthe service handle returned from GNUNET_TESTBED_ConnectAdapter()
emsgerror message in case the operation has failed; will be NULL if operation has executed successfully.

Definition at line 1404 of file gnunet-rps-profiler.c.

References GNUNET_break.

Referenced by test_run().

1408 {
1409  // struct GNUNET_STATISTICS_Handle *sh = ca_result;
1410  // struct RPSPeer *peer = (struct RPSPeer *) cls;
1411  (void) cls;
1412  (void) op;
1413  (void) ca_result;
1414 
1415  if (NULL != emsg)
1416  {
1417  GNUNET_break (0);
1418  return;
1419  }
1420  // GNUNET_break (GNUNET_OK == GNUNET_STATISTICS_watch
1421  // (sh, "core", "# peers connected",
1422  // stat_iterator, peer));
1423  // GNUNET_break (GNUNET_OK == GNUNET_STATISTICS_watch
1424  // (sh, "nse", "# peers connected",
1425  // stat_iterator, peer));
1426 }
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Here is the caller graph for this function:

◆ default_reply_handle()

static void default_reply_handle ( void *  cls,
uint64_t  n,
const struct GNUNET_PeerIdentity recv_peers 
)
static

Callback to call on receipt of a reply.

Parameters
clsclosure
nnumber of peers
recv_peersthe received peers

Definition at line 1477 of file gnunet-rps-profiler.c.

References cur_test_run, evaluate(), GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, HAVE_QUICK_QUIT, SingleTestRun::have_quick_quit, RPSPeer::num_pending_reps, RPSPeer::num_recv_ids, RPSPeer::peer_id, RPSPeer::pending_rep_head, RPSPeer::pending_rep_tail, post_test, post_test_op(), profiler_reply_handle_info(), STATcls::rps_peer, and PendingReply::rps_peer.

Referenced by profiler_reply_handle(), and profiler_reply_handle_info().

1480 {
1481  struct RPSPeer *rps_peer;
1482  struct PendingReply *pending_rep = (struct PendingReply *) cls;
1483  unsigned int i;
1484 
1485  rps_peer = pending_rep->rps_peer;
1487  rps_peer->pending_rep_tail,
1488  pending_rep);
1489  rps_peer->num_pending_reps--;
1491  "[%s] got %" PRIu64 " peers:\n",
1492  GNUNET_i2s (rps_peer->peer_id),
1493  n);
1494 
1495  for (i = 0; i < n; i++)
1496  {
1498  "%u: %s\n",
1499  i,
1500  GNUNET_i2s (&recv_peers[i]));
1501 
1502  rps_peer->num_recv_ids++;
1503  }
1504 
1505  if (GNUNET_YES != post_test)
1506  return;
1508  return;
1509  if (0 == evaluate ())
1510  {
1512  "Test succeeded before end of duration\n");
1513  if (NULL != post_test_task)
1516  GNUNET_assert (NULL != post_test_task);
1517  }
1518 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct PendingReply * pending_rep_head
Pending replies DLL.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
A pending reply: A request was sent and the reply is pending.
enum OPTION_QUICK_QUIT have_quick_quit
Quit test before timeout?
struct SingleTestRun cur_test_run
static int post_test
Did we finish the test?
unsigned int num_pending_reps
Number of pending replies.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1296
struct GNUNET_PeerIdentity * peer_id
ID of the peer.
static struct GNUNET_SCHEDULER_Task * post_test_task
Identifier for the task that runs after the test to collect results.
unsigned int num_recv_ids
Number of received PeerIDs.
Information we track for each peer.
static void post_test_op(void *cls)
Task run after duration to collect statistics and potentially shut down.
#define GNUNET_log(kind,...)
It is ok for the test to quit before the timeout triggers.
struct PendingReply * pending_rep_tail
struct RPSPeer * rps_peer
The peer that requested.
static int evaluate(void)
Write the ids and their according index in the given array to a file Unused.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
Here is the call graph for this function:
Here is the caller graph for this function:

◆ profiler_reply_handle_info()

static void profiler_reply_handle_info ( void *  cls,
const struct GNUNET_PeerIdentity recv_peer,
double  probability,
uint32_t  num_observed 
)
static

Callback to call on receipt of a reply.

Parameters
clsclosure
nnumber of peers
recv_peersthe received peers

Definition at line 2007 of file gnunet-rps-profiler.c.

References bits_needed, default_reply_handle(), file_name, GNUNET_asprintf(), GNUNET_assert, GNUNET_CONTAINER_multipeermap_get(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_i2s_full(), GNUNET_log, RPSPeer::index, RPSPeer::peer_id, PendingReply::req_handle, STATcls::rps_peer, PendingReply::rps_peer, to_file_raw(), to_file_raw_unaligned(), and tofile.

Referenced by default_reply_handle(), and request_peers().

2011 {
2012  struct RPSPeer *rps_peer;
2013  struct RPSPeer *rcv_rps_peer;
2014  char file_name_buf[128];
2015  char file_name_dh_buf[128];
2016  char file_name_dhr_buf[128];
2017  char file_name_dhru_buf[128];
2018  char *file_name = file_name_buf;
2019  char *file_name_dh = file_name_dh_buf;
2020  char *file_name_dhr = file_name_dhr_buf;
2021  char *file_name_dhru = file_name_dhru_buf;
2022  struct PendingReply *pending_rep = (struct PendingReply *) cls;
2023 
2024  pending_rep->req_handle = NULL;
2025  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "profiler_reply_handle()\n");
2026  rps_peer = pending_rep->rps_peer;
2027  (void) GNUNET_asprintf (&file_name,
2028  "/tmp/rps/received_ids-%u",
2029  rps_peer->index);
2030 
2031  (void) GNUNET_asprintf (&file_name_dh,
2032  "/tmp/rps/diehard_input-%u",
2033  rps_peer->index);
2034  (void) GNUNET_asprintf (&file_name_dhr,
2035  "/tmp/rps/diehard_input_raw-%u",
2036  rps_peer->index);
2037  (void) GNUNET_asprintf (&file_name_dhru,
2038  "/tmp/rps/diehard_input_raw_aligned-%u",
2039  rps_peer->index);
2041  "[%s] got peer with info:\n",
2042  GNUNET_i2s (rps_peer->peer_id));
2044  " %s\n",
2045  GNUNET_i2s (recv_peer));
2046  tofile (file_name,
2047  "%s %f %" PRIu32 " \n",
2048  GNUNET_i2s_full (recv_peer),
2049  probability,
2050  num_observed);
2051  rcv_rps_peer = GNUNET_CONTAINER_multipeermap_get (peer_map, recv_peer);
2052  GNUNET_assert (NULL != rcv_rps_peer);
2053  tofile (file_name_dh,
2054  "%" PRIu32 "\n",
2055  (uint32_t) rcv_rps_peer->index);
2056 #ifdef TO_FILE
2057  to_file_raw (file_name_dhr,
2058  (char *) &rcv_rps_peer->index,
2059  sizeof(uint32_t));
2060  to_file_raw_unaligned (file_name_dhru,
2061  (char *) &rcv_rps_peer->index,
2062  sizeof(uint32_t),
2063  bits_needed);
2064 #endif /* TO_FILE */
2065  default_reply_handle (cls, 1, recv_peer);
2066 }
struct GNUNET_RPS_Request_Handle_Single_Info * req_handle
Handle to the request we are waiting for.
void to_file_raw(const char *file_name, const char *buf, size_t size_buf)
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
A pending reply: A request was sent and the reply is pending.
static char * file_name
Dump file name.
const char * GNUNET_i2s_full(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
static void default_reply_handle(void *cls, uint64_t n, const struct GNUNET_PeerIdentity *recv_peers)
Callback to call on receipt of a reply.
#define tofile(file_name,...)
This function is used to facilitate writing important information to disk.
static unsigned bits_needed
numer of bits required to represent the largest peer id
void to_file_raw_unaligned(const char *file_name, const char *buf, size_t size_buf, unsigned bits_needed)
static struct GNUNET_CONTAINER_MultiPeerMap * peer_map
Peermap to get the index of a given peer ID quick.
struct GNUNET_PeerIdentity * peer_id
ID of the peer.
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
Information we track for each peer.
void * GNUNET_CONTAINER_multipeermap_get(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Given a key find a value in the map matching the key.
#define GNUNET_log(kind,...)
struct RPSPeer * rps_peer
The peer that requested.
uint32_t index
Index of the peer.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
Here is the call graph for this function:
Here is the caller graph for this function:

◆ request_peers()

static void request_peers ( void *  cls)
static

Request random peers.

Definition at line 1531 of file gnunet-rps-profiler.c.

References GNUNET_assert, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, GNUNET_RPS_request_peer_info(), GNUNET_YES, in_shutdown, RPSPeer::num_pending_reps, RPSPeer::num_pending_reqs, RPSPeer::pending_rep_head, RPSPeer::pending_rep_tail, RPSPeer::pending_req_head, RPSPeer::pending_req_tail, post_test, profiler_reply_handle_info(), PendingReply::req_handle, RPSPeer::rps_handle, STATcls::rps_peer, PendingReply::rps_peer, and PendingRequest::rps_peer.

Referenced by schedule_missing_requests().

1532 {
1533  struct PendingRequest *pending_req = cls;
1534  struct RPSPeer *rps_peer;
1535  struct PendingReply *pending_rep;
1536 
1537  rps_peer = pending_req->rps_peer;
1538  GNUNET_assert (1 <= rps_peer->num_pending_reqs);
1540  rps_peer->pending_req_tail,
1541  pending_req);
1542  rps_peer->num_pending_reqs--;
1543  if ((GNUNET_YES == in_shutdown) || (GNUNET_YES == post_test))
1544  return;
1546  "Requesting one peer\n");
1547  pending_rep = GNUNET_new (struct PendingReply);
1548  pending_rep->rps_peer = rps_peer;
1549  // pending_rep->req_handle = GNUNET_RPS_request_peers (rps_peer->rps_handle,
1550  // 1,
1551  // cur_test_run.reply_handle,
1552  // pending_rep);
1553  pending_rep->req_handle = GNUNET_RPS_request_peer_info (rps_peer->rps_handle,
1555  pending_rep);
1557  rps_peer->pending_rep_tail,
1558  pending_rep);
1559  rps_peer->num_pending_reps++;
1560 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
A pending request: A request was not made yet but is scheduled for later.
struct GNUNET_RPS_Request_Handle_Single_Info * req_handle
Handle to the request we are waiting for.
struct PendingReply * pending_rep_head
Pending replies DLL.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
A pending reply: A request was sent and the reply is pending.
static void profiler_reply_handle_info(void *cls, const struct GNUNET_PeerIdentity *recv_peer, double probability, uint32_t num_observed)
Callback to call on receipt of a reply.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static int post_test
Did we finish the test?
struct PendingRequest * pending_req_tail
struct GNUNET_RPS_Handle * rps_handle
Handle to RPS service.
unsigned int num_pending_reps
Number of pending replies.
struct PendingRequest * pending_req_head
Pending requests DLL.
struct GNUNET_RPS_Request_Handle_Single_Info * GNUNET_RPS_request_peer_info(struct GNUNET_RPS_Handle *rps_handle, GNUNET_RPS_NotifyReadySingleInfoCB ready_cb, void *cls)
Request one random peer, getting additional information.
Definition: rps_api.c:995
struct RPSPeer * rps_peer
The peer that requested.
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
Information we track for each peer.
#define GNUNET_log(kind,...)
struct PendingReply * pending_rep_tail
struct RPSPeer * rps_peer
The peer that requested.
static int in_shutdown
Are we shutting down?
unsigned int num_pending_reqs
Number of pending requests.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ schedule_missing_requests()

void schedule_missing_requests ( struct RPSPeer rps_peer)

Schedule requests for peer rps_peer that have neither been scheduled, nor issued, nor replied.

Definition at line 1568 of file gnunet-rps-profiler.c.

References cur_test_run, GNUNET_assert, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_SECONDS, RPSPeer::num_ids_to_request, RPSPeer::num_pending_reps, RPSPeer::num_pending_reqs, RPSPeer::pending_req_head, RPSPeer::pending_req_tail, SingleTestRun::request_interval, request_peers(), PendingRequest::request_task, STATcls::rps_peer, and PendingRequest::rps_peer.

Referenced by churn_cb(), and profiler_cb().

1569 {
1570  unsigned int i;
1571  struct PendingRequest *pending_req;
1572 
1574  "Scheduling %u - %u missing requests\n",
1575  rps_peer->num_ids_to_request,
1576  rps_peer->num_pending_reqs + rps_peer->num_pending_reps);
1577  GNUNET_assert (rps_peer->num_pending_reqs + rps_peer->num_pending_reps <=
1578  rps_peer->num_ids_to_request);
1579  for (i = rps_peer->num_pending_reqs + rps_peer->num_pending_reps;
1580  i < rps_peer->num_ids_to_request; i++)
1581  {
1582  pending_req = GNUNET_new (struct PendingRequest);
1583  pending_req->rps_peer = rps_peer;
1587  request_peers,
1588  pending_req);
1590  rps_peer->pending_req_tail,
1591  pending_req);
1592  rps_peer->num_pending_reqs++;
1593  }
1594 }
A pending request: A request was not made yet but is scheduled for later.
static void request_peers(void *cls)
Request random peers.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_TIME_UNIT_SECONDS
One second.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct SingleTestRun cur_test_run
struct PendingRequest * pending_req_tail
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1269
struct GNUNET_SCHEDULER_Task * request_task
Handle to the request we are waiting for.
unsigned int num_pending_reps
Number of pending replies.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:442
struct PendingRequest * pending_req_head
Pending requests DLL.
unsigned int num_ids_to_request
Number of Peer IDs to request during the whole test.
uint32_t request_interval
Request interval.
struct RPSPeer * rps_peer
The peer that requested.
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
#define GNUNET_log(kind,...)
unsigned int num_pending_reqs
Number of pending requests.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ cancel_pending_req_rep()

void cancel_pending_req_rep ( struct RPSPeer rps_peer)

Definition at line 1598 of file gnunet-rps-profiler.c.

References cancel_pending_req(), cancel_request(), churn(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, RPSPeer::num_pending_reps, RPSPeer::num_pending_reqs, RPSPeer::pending_rep_head, and RPSPeer::pending_req_head.

Referenced by manage_service_wrapper().

1599 {
1601  "Cancelling all (pending) requests.\n");
1602  while (NULL != rps_peer->pending_req_head)
1604  GNUNET_assert (0 == rps_peer->num_pending_reqs);
1605  while (NULL != rps_peer->pending_rep_head)
1606  cancel_request (rps_peer->pending_rep_head);
1607  GNUNET_assert (0 == rps_peer->num_pending_reps);
1608 }
struct PendingReply * pending_rep_head
Pending replies DLL.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
unsigned int num_pending_reps
Number of pending replies.
static void cancel_request(struct PendingReply *pending_rep)
struct PendingRequest * pending_req_head
Pending requests DLL.
#define GNUNET_log(kind,...)
static void cancel_pending_req(struct PendingRequest *pending_req)
unsigned int num_pending_reqs
Number of pending requests.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ churn()

static void churn ( void *  cls)
static

Initialise only non-mal RPSPeers.

Set peers to (non-)malicious before execution

Of signature PreTest

Parameters
rps_peerthe peer to set (non-) malicious
hthe handle to the service

Definition at line 1844 of file gnunet-rps-profiler.c.

References GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_permute(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_SECONDS, GNUNET_YES, in_shutdown, manage_service_wrapper(), num_peers, num_peers_online, and post_test.

Referenced by cancel_pending_req_rep(), and profiler_cb().

1845 {
1846  unsigned int i;
1847  unsigned int j;
1848  double portion_online;
1849  unsigned int *permut;
1850  double prob_go_offline;
1851  double portion_go_online;
1852  double portion_go_offline;
1853 
1854  (void) cls;
1855 
1856  if ((GNUNET_YES == in_shutdown) || (GNUNET_YES == post_test))
1857  {
1858  return;
1859  }
1861  "Churn function executing\n");
1862 
1863  churn_task = NULL; /* Should be invalid by now */
1864 
1865  /* Compute the probability for an online peer to go offline
1866  * this round */
1867  portion_online = num_peers_online * 1.0 / num_peers;
1869  "Portion online: %f\n",
1870  portion_online);
1871  portion_go_online = ((1 - portion_online) * .5 * .66);
1873  "Portion that should go online: %f\n",
1874  portion_go_online);
1875  portion_go_offline = (portion_online + portion_go_online) - .75;
1877  "Portion that probably goes offline: %f\n",
1878  portion_go_offline);
1879  prob_go_offline = portion_go_offline / (portion_online * .5);
1881  "Probability of a selected online peer to go offline: %f\n",
1882  prob_go_offline);
1883 
1885  (unsigned int) num_peers);
1886 
1887  /* Go over 50% randomly chosen peers */
1888  for (i = 0; i < .5 * num_peers; i++)
1889  {
1890  j = permut[i];
1891 
1892  /* If online, shut down with certain probability */
1893  if (GNUNET_YES == rps_peers[j].online)
1894  {
1895  manage_service_wrapper (i, j, -1, prob_go_offline);
1896  }
1897 
1898  /* If offline, restart with certain probability */
1899  else if (GNUNET_NO == rps_peers[j].online)
1900  {
1901  manage_service_wrapper (i, j, 1, 0.66);
1902  }
1903  }
1904 
1905  GNUNET_free (permut);
1906 
1909  churn,
1910  NULL);
1911 }
unsigned int * GNUNET_CRYPTO_random_permute(enum GNUNET_CRYPTO_Quality mode, unsigned int n)
Get an array with a random permutation of the numbers 0...n-1.
#define GNUNET_TIME_UNIT_SECONDS
One second.
static int post_test
Did we finish the test?
static unsigned int num_peers_online
Number of online peers.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1269
static struct RPSPeer * rps_peers
Information for all the peers.
static void churn(void *cls)
Initialise only non-mal RPSPeers.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:442
#define GNUNET_log(kind,...)
static struct GNUNET_SCHEDULER_Task * churn_task
Identifier for the churn task that runs periodically.
static uint32_t num_peers
How many peers do we start?
static int in_shutdown
Are we shutting down?
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
#define GNUNET_free(ptr)
Wrapper around free.
static void manage_service_wrapper(unsigned int i, unsigned int j, enum PEER_ONLINE_DELTA delta, double prob_go_on_off)
Set the rps-service up or down for a specific peer.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ churn_cb()

static void churn_cb ( void *  cls,
struct GNUNET_TESTBED_Operation op,
const char *  emsg 
)
static

Callback to be called when RPS service is started or stopped at peers.

Parameters
clsNULL
opthe operation handle
emsgNULL on success; otherwise an error description

Definition at line 1707 of file gnunet-rps-profiler.c.

References cur_test_run, OpListEntry::delta, delta, RPSPeer::entry_op_manage, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_shutdown(), GNUNET_TESTBED_operation_done(), GNUNET_YES, in_shutdown, OpListEntry::index, num_peers_online, RPSPeer::online, OpListEntry::op, PEER_GO_OFFLINE, RPSPeer::peer_id, post_test, SingleTestRun::pre_test, RPSPeer::rps_handle, and schedule_missing_requests().

Referenced by manage_service_wrapper().

1710 {
1711  // FIXME
1712  struct OpListEntry *entry = cls;
1713 
1714  (void) op;
1715 
1716  if ((GNUNET_YES == in_shutdown) || (GNUNET_YES == post_test))
1717  {
1718  return;
1719  }
1720 
1722  if (NULL != emsg)
1723  {
1725  "Failed to start/stop RPS at a peer\n");
1727  return;
1728  }
1729  GNUNET_assert (0 != entry->delta);
1730 
1731  num_peers_online += entry->delta;
1732 
1733  if (PEER_GO_OFFLINE == entry->delta)
1734  { /* Peer hopefully just went offline */
1735  if (GNUNET_YES != rps_peers[entry->index].online)
1736  {
1738  "peer %s was expected to go offline but is still marked as online\n",
1739  GNUNET_i2s (rps_peers[entry->index].peer_id));
1740  GNUNET_break (0);
1741  }
1742  else
1743  {
1745  "peer %s probably went offline as expected\n",
1746  GNUNET_i2s (rps_peers[entry->index].peer_id));
1747  }
1748  rps_peers[entry->index].online = GNUNET_NO;
1749  }
1750 
1751  else if (PEER_GO_ONLINE < entry->delta)
1752  { /* Peer hopefully just went online */
1753  if (GNUNET_NO != rps_peers[entry->index].online)
1754  {
1756  "peer %s was expected to go online but is still marked as offline\n",
1757  GNUNET_i2s (rps_peers[entry->index].peer_id));
1758  GNUNET_break (0);
1759  }
1760  else
1761  {
1763  "peer %s probably went online as expected\n",
1764  GNUNET_i2s (rps_peers[entry->index].peer_id));
1765  if (NULL != cur_test_run.pre_test)
1766  {
1768  rps_peers[entry->index].rps_handle);
1770  }
1771  }
1772  rps_peers[entry->index].online = GNUNET_YES;
1773  }
1774  else
1775  {
1777  "Invalid value for delta: %i\n", entry->delta);
1778  GNUNET_break (0);
1779  }
1780 
1782  rps_peers[entry->index].entry_op_manage = NULL;
1783  GNUNET_free (entry);
1784  // if (num_peers_in_round[current_round] == peers_running)
1785  // run_round ();
1786 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
static struct OpListEntry * oplist_tail
OpList DLL tail.
static struct GNUNET_TIME_Relative delta
Definition: speedup.c:35
int online
A request handle to check for an request.
static struct OpListEntry * oplist_head
OpList DLL head.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:531
struct SingleTestRun cur_test_run
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Indicates peer going offline.
void schedule_missing_requests(struct RPSPeer *rps_peer)
Schedule requests for peer rps_peer that have neither been scheduled, nor issued, nor replied...
static int post_test
Did we finish the test?
static unsigned int num_peers_online
Number of online peers.
static struct RPSPeer * rps_peers
Information for all the peers.
struct GNUNET_RPS_Handle * rps_handle
Handle to RPS service.
Operation map entry.
struct GNUNET_PeerIdentity * peer_id
ID of the peer.
void GNUNET_TESTBED_operation_done(struct GNUNET_TESTBED_Operation *operation)
This function is used to signal that the event information (struct GNUNET_TESTBED_EventInformation) f...
Definition: testbed_api.c:2045
int delta
Depending on whether we start or stop NSE service at the peer set this to 1 or -1.
const struct OpListEntry * entry_op_manage
Pending operation on that peer.
#define GNUNET_log(kind,...)
unsigned int index
Index of the regarding peer.
PreTest pre_test
Called directly after connecting to the service.
static int in_shutdown
Are we shutting down?
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct GNUNET_TESTBED_Operation * op
The testbed operation.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ manage_service_wrapper()

static void manage_service_wrapper ( unsigned int  i,
unsigned int  j,
enum PEER_ONLINE_DELTA  delta,
double  prob_go_on_off 
)
static

Set the rps-service up or down for a specific peer.

Parameters
iindex of action
jindex of peer
delta(PEER_ONLINE_DELTA) down (-1) or up (1)
prob_go_on_offthe probability of the action

Definition at line 1798 of file gnunet-rps-profiler.c.

References cancel_pending_req_rep(), churn_cb(), OpListEntry::delta, delta, RPSPeer::entry_op_manage, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_TESTBED_peer_manage_service(), OpListEntry::index, make_oplist_entry(), OpListEntry::op, PEER_GO_OFFLINE, PEER_GO_ONLINE, and peer_id.

Referenced by churn().

1801 {
1802  struct OpListEntry *entry = NULL;
1803  uint32_t prob;
1804 
1805  /* make sure that management operation is not already scheduled */
1806  if (NULL != rps_peers[j].entry_op_manage)
1807  {
1808  return;
1809  }
1810 
1812  UINT32_MAX);
1814  "%u. selected peer (%u: %s) is %s.\n",
1815  i,
1816  j,
1818  (PEER_GO_ONLINE == delta) ? "online" : "offline");
1819  if (prob < prob_go_on_off * UINT32_MAX)
1820  {
1822  "%s goes %s\n",
1823  GNUNET_i2s (rps_peers[j].peer_id),
1824  (PEER_GO_OFFLINE == delta) ? "offline" : "online");
1825 
1826  if (PEER_GO_OFFLINE == delta)
1828  entry = make_oplist_entry ();
1829  entry->delta = delta;
1830  entry->index = j;
1831  entry->op = GNUNET_TESTBED_peer_manage_service (NULL,
1832  testbed_peers[j],
1833  "rps",
1834  &churn_cb,
1835  entry,
1836  (PEER_GO_OFFLINE == delta) ?
1837  0 : 1);
1838  rps_peers[j].entry_op_manage = entry;
1839  }
1840 }
static struct GNUNET_TIME_Relative delta
Definition: speedup.c:35
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
Indicates peer going online.
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
Indicates peer going offline.
static void churn_cb(void *cls, struct GNUNET_TESTBED_Operation *op, const char *emsg)
Callback to be called when RPS service is started or stopped at peers.
static struct OpListEntry * make_oplist_entry()
Creates an oplist entry and adds it to the oplist DLL.
static struct RPSPeer * rps_peers
Information for all the peers.
Operation map entry.
static struct GNUNET_TESTBED_Peer ** testbed_peers
Handles to all of the running peers.
int delta
Depending on whether we start or stop NSE service at the peer set this to 1 or -1.
const struct OpListEntry * entry_op_manage
Pending operation on that peer.
void cancel_pending_req_rep(struct RPSPeer *rps_peer)
#define GNUNET_log(kind,...)
unsigned int index
Index of the regarding peer.
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_peer_manage_service(void *op_cls, struct GNUNET_TESTBED_Peer *peer, const char *service_name, GNUNET_TESTBED_OperationCompletionCallback cb, void *cb_cls, unsigned int start)
Start or stop given service at a peer.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct GNUNET_TESTBED_Operation * op
The testbed operation.
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
Here is the call graph for this function:
Here is the caller graph for this function:

◆ profiler_init_peer()

static void profiler_init_peer ( struct RPSPeer rps_peer)
static

Initialise given RPSPeer.

Definition at line 1918 of file gnunet-rps-profiler.c.

References cur_test_run, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, RPSPeer::num_ids_to_request, and SingleTestRun::num_requests.

Referenced by run().

1919 {
1921  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "peer shall request %i peers\n",
1922  rps_peer->num_ids_to_request);
1923 }
struct SingleTestRun cur_test_run
unsigned int num_ids_to_request
Number of Peer IDs to request during the whole test.
#define GNUNET_log(kind,...)
uint32_t num_requests
Number of Requests to make.
Here is the caller graph for this function:

◆ profiler_reply_handle()

static void profiler_reply_handle ( void *  cls,
uint64_t  n,
const struct GNUNET_PeerIdentity recv_peers 
)
static

Callback to call on receipt of a reply.

Parameters
clsclosure
nnumber of peers
recv_peersthe received peers

Definition at line 1934 of file gnunet-rps-profiler.c.

References bits_needed, default_reply_handle(), file_name, GNUNET_asprintf(), GNUNET_assert, GNUNET_CONTAINER_multipeermap_get(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_i2s_full(), GNUNET_log, RPSPeer::index, RPSPeer::peer_id, PendingReply::req_handle, STATcls::rps_peer, PendingReply::rps_peer, to_file_raw(), to_file_raw_unaligned(), and tofile.

Referenced by run().

1937 {
1938  struct RPSPeer *rps_peer;
1939  struct RPSPeer *rcv_rps_peer;
1940  char file_name_buf[128];
1941  char file_name_dh_buf[128];
1942  char file_name_dhr_buf[128];
1943  char file_name_dhru_buf[128];
1944  char *file_name = file_name_buf;
1945  char *file_name_dh = file_name_dh_buf;
1946  char *file_name_dhr = file_name_dhr_buf;
1947  char *file_name_dhru = file_name_dhru_buf;
1948  unsigned int i;
1949  struct PendingReply *pending_rep = (struct PendingReply *) cls;
1950 
1951  pending_rep->req_handle = NULL;
1952  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "profiler_reply_handle()\n");
1953  rps_peer = pending_rep->rps_peer;
1954  (void) GNUNET_asprintf (&file_name,
1955  "/tmp/rps/received_ids-%u",
1956  rps_peer->index);
1957 
1958  (void) GNUNET_asprintf (&file_name_dh,
1959  "/tmp/rps/diehard_input-%u",
1960  rps_peer->index);
1961  (void) GNUNET_asprintf (&file_name_dhr,
1962  "/tmp/rps/diehard_input_raw-%u",
1963  rps_peer->index);
1964  (void) GNUNET_asprintf (&file_name_dhru,
1965  "/tmp/rps/diehard_input_raw_aligned-%u",
1966  rps_peer->index);
1968  "[%s] got %" PRIu64 " peers:\n",
1969  GNUNET_i2s (rps_peer->peer_id),
1970  n);
1971  for (i = 0; i < n; i++)
1972  {
1974  "%u: %s\n",
1975  i,
1976  GNUNET_i2s (&recv_peers[i]));
1977  tofile (file_name,
1978  "%s\n",
1979  GNUNET_i2s_full (&recv_peers[i]));
1980  rcv_rps_peer = GNUNET_CONTAINER_multipeermap_get (peer_map, &recv_peers[i]);
1981  GNUNET_assert (NULL != rcv_rps_peer);
1982  tofile (file_name_dh,
1983  "%" PRIu32 "\n",
1984  (uint32_t) rcv_rps_peer->index);
1985 #ifdef TO_FILE
1986  to_file_raw (file_name_dhr,
1987  (char *) &rcv_rps_peer->index,
1988  sizeof(uint32_t));
1989  to_file_raw_unaligned (file_name_dhru,
1990  (char *) &rcv_rps_peer->index,
1991  sizeof(uint32_t),
1992  bits_needed);
1993 #endif /* TO_FILE */
1994  }
1995  default_reply_handle (cls, n, recv_peers);
1996 }
struct GNUNET_RPS_Request_Handle_Single_Info * req_handle
Handle to the request we are waiting for.
void to_file_raw(const char *file_name, const char *buf, size_t size_buf)
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
A pending reply: A request was sent and the reply is pending.
static char * file_name
Dump file name.
const char * GNUNET_i2s_full(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
static void default_reply_handle(void *cls, uint64_t n, const struct GNUNET_PeerIdentity *recv_peers)
Callback to call on receipt of a reply.
#define tofile(file_name,...)
This function is used to facilitate writing important information to disk.
static unsigned bits_needed
numer of bits required to represent the largest peer id
void to_file_raw_unaligned(const char *file_name, const char *buf, size_t size_buf, unsigned bits_needed)
static struct GNUNET_CONTAINER_MultiPeerMap * peer_map
Peermap to get the index of a given peer ID quick.
struct GNUNET_PeerIdentity * peer_id
ID of the peer.
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
Information we track for each peer.
void * GNUNET_CONTAINER_multipeermap_get(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Given a key find a value in the map matching the key.
#define GNUNET_log(kind,...)
struct RPSPeer * rps_peer
The peer that requested.
uint32_t index
Index of the peer.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
Here is the call graph for this function:
Here is the caller graph for this function:

◆ profiler_cb()

static void profiler_cb ( struct RPSPeer rps_peer)
static

Definition at line 2070 of file gnunet-rps-profiler.c.

References churn(), cur_test_run, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_SECONDS, GNUNET_YES, HAVE_CHURN, SingleTestRun::have_churn, in_shutdown, RPSPeer::num_ids_to_request, post_test, and schedule_missing_requests().

Referenced by run().

2071 {
2072  if ((GNUNET_YES == in_shutdown) || (GNUNET_YES == post_test))
2073  {
2074  return;
2075  }
2076 
2077  /* Start churn */
2078  if ((HAVE_CHURN == cur_test_run.have_churn) && (NULL == churn_task))
2079  {
2081  "Starting churn task\n");
2084  churn,
2085  NULL);
2086  }
2087  else
2088  {
2090  "Not starting churn task\n");
2091  }
2092 
2093  /* Only request peer ids at one peer.
2094  * (It's the before-last because last one is target of the focussed attack.)
2095  */
2096  if (0 < rps_peer->num_ids_to_request)
2097  schedule_missing_requests (rps_peer);
2098 }
#define GNUNET_TIME_UNIT_SECONDS
One second.
If we have churn this is set.
struct SingleTestRun cur_test_run
void schedule_missing_requests(struct RPSPeer *rps_peer)
Schedule requests for peer rps_peer that have neither been scheduled, nor issued, nor replied...
static int post_test
Did we finish the test?
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1269
static void churn(void *cls)
Initialise only non-mal RPSPeers.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:442
unsigned int num_ids_to_request
Number of Peer IDs to request during the whole test.
enum OPTION_CHURN have_churn
Run with (-out) churn.
#define GNUNET_log(kind,...)
static struct GNUNET_SCHEDULER_Task * churn_task
Identifier for the churn task that runs periodically.
static int in_shutdown
Are we shutting down?
Here is the call graph for this function:
Here is the caller graph for this function:

◆ file_name_cb()

static int file_name_cb ( void *  cls,
const char *  filename 
)
static

Function called from profiler_eval with a filename.

Parameters
clsclosure
filenamecomplete filename (absolute path)
Returns
GNUNET_OK to continue to iterate, GNUNET_NO to stop iteration with no error, GNUNET_SYSERR to abort iteration with error!

Definition at line 2111 of file gnunet-rps-profiler.c.

References GNUNET_OK, num_peers, RPS_sampler_elem_create(), RPS_sampler_elem_destroy(), RPS_sampler_elem_next(), RPS_sampler_elem_set(), string_to_auth_key(), and tofile.

Referenced by profiler_eval().

2112 {
2113  if (NULL != strstr (filename, "sampler_el"))
2114  {
2115  struct RPS_SamplerElement *s_elem;
2116  struct GNUNET_CRYPTO_AuthKey auth_key;
2117  const char *key_char;
2118  uint32_t i;
2119  (void) cls;
2120 
2121  key_char = filename + 20; /* Length of "/tmp/rps/sampler_el-" */
2122  tofile (filename, "--------------------------\n");
2123 
2124  auth_key = string_to_auth_key (key_char);
2125  s_elem = RPS_sampler_elem_create ();
2126  RPS_sampler_elem_set (s_elem, auth_key);
2127 
2128  for (i = 0; i < num_peers; i++)
2129  {
2130  RPS_sampler_elem_next (s_elem, &rps_peer_ids[i]);
2131  }
2132  RPS_sampler_elem_destroy (s_elem);
2133  }
2134  return GNUNET_OK;
2135 }
A sampler element sampling one PeerID at a time.
void RPS_sampler_elem_destroy(struct RPS_SamplerElement *sampler_elem)
Destroy a sampler element.
void RPS_sampler_elem_set(struct RPS_SamplerElement *sampler_elem, struct GNUNET_CRYPTO_AuthKey auth_key)
Set the min-wise independent function of the given sampler element.
struct RPS_SamplerElement * RPS_sampler_elem_create(void)
Create a sampler element and initialise it.
#define tofile(file_name,...)
This function is used to facilitate writing important information to disk.
static char * filename
struct GNUNET_CRYPTO_AuthKey string_to_auth_key(const char *str)
static uint32_t num_peers
How many peers do we start?
void RPS_sampler_elem_next(struct RPS_SamplerElement *sampler_elem, const struct GNUNET_PeerIdentity *new_ID)
Update a sampler element with a PeerID.
type for (message) authentication keys
static struct GNUNET_PeerIdentity * rps_peer_ids
IDs of the peers.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ profiler_eval()

static int profiler_eval ( void  )
static

This is run after the test finished.

Compute all perfect samples.

Definition at line 2144 of file gnunet-rps-profiler.c.

References evaluate(), file_name_cb(), GNUNET_DISK_directory_scan(), GNUNET_ERROR_TYPE_ERROR, and GNUNET_log.

Referenced by run().

2145 {
2146 #ifdef TO_FILE
2147  /* Compute perfect sample for each sampler element */
2148  if (-1 == GNUNET_DISK_directory_scan ("/tmp/rps/", file_name_cb, NULL))
2149  {
2150  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Scan of directory failed\n");
2151  }
2152 #endif /* TO_FILE */
2153 
2154  return evaluate ();
2155 }
int GNUNET_DISK_directory_scan(const char *dir_name, GNUNET_FileNameCallback callback, void *callback_cls)
Scan a directory for files.
Definition: disk.c:911
static int file_name_cb(void *cls, const char *filename)
Function called from profiler_eval with a filename.
#define GNUNET_log(kind,...)
static int evaluate(void)
Write the ids and their according index in the given array to a file Unused.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ is_in_view()

static int is_in_view ( uint32_t  a,
uint32_t  b 
)
static

is b in view of a?

Parameters
a
b
Returns

Definition at line 2166 of file gnunet-rps-profiler.c.

References RPSPeer::cur_view_count, GNUNET_NO, GNUNET_YES, and peer_id.

Referenced by compute_probabilities(), and count_containing_views().

2167 {
2168  uint32_t i;
2169 
2170  for (i = 0; i < rps_peers[a].cur_view_count; i++)
2171  {
2172  if (0 == memcmp (rps_peers[b].peer_id,
2173  &rps_peers[a].cur_view[i],
2174  sizeof(struct GNUNET_PeerIdentity)))
2175  {
2176  return GNUNET_YES;
2177  }
2178  }
2179  return GNUNET_NO;
2180 }
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
static struct RPSPeer * rps_peers
Information for all the peers.
uint32_t cur_view_count
Number of peers in the cur_view.
The identity of the host (wraps the signing key of the peer).
Here is the caller graph for this function:

◆ get_idx_of_pid()

static uint32_t get_idx_of_pid ( const struct GNUNET_PeerIdentity pid)
static

Definition at line 2184 of file gnunet-rps-profiler.c.

References GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_i2s_full(), GNUNET_log, num_peers, and peer_id.

Referenced by count_containing_views().

2185 {
2186  uint32_t i;
2187 
2188  for (i = 0; i < num_peers; i++)
2189  {
2190  if (0 == memcmp (pid,
2191  rps_peers[i].peer_id,
2192  sizeof(struct GNUNET_PeerIdentity)))
2193  {
2194  return i;
2195  }
2196  }
2197  // return 0; /* Should not happen - make compiler happy */
2199  "No known _PeerIdentity %s!\n",
2200  GNUNET_i2s_full (pid));
2201  GNUNET_assert (0);
2202 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
const char * GNUNET_i2s_full(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
static struct RPSPeer * rps_peers
Information for all the peers.
The identity of the host (wraps the signing key of the peer).
#define GNUNET_log(kind,...)
static uint32_t num_peers
How many peers do we start?
Here is the call graph for this function:
Here is the caller graph for this function:

◆ count_containing_views()

static uint32_t count_containing_views ( uint32_t  a,
uint32_t  b 
)
static

Counts number of peers in view of a that have b in their view.

Parameters
a
uint32_tb
Returns

Definition at line 2214 of file gnunet-rps-profiler.c.

References RPSPeer::cur_view_count, get_idx_of_pid(), GNUNET_YES, and is_in_view().

Referenced by compute_probabilities().

2215 {
2216  uint32_t i;
2217  uint32_t peer_idx;
2218  uint32_t count = 0;
2219 
2220  for (i = 0; i < rps_peers[a].cur_view_count; i++)
2221  {
2222  peer_idx = get_idx_of_pid (&rps_peers[a].cur_view[i]);
2223  if (GNUNET_YES == is_in_view (peer_idx, b))
2224  {
2225  count++;
2226  }
2227  }
2228  return count;
2229 }
static int is_in_view(uint32_t a, uint32_t b)
is b in view of a?
static struct RPSPeer * rps_peers
Information for all the peers.
uint32_t cur_view_count
Number of peers in the cur_view.
static uint32_t get_idx_of_pid(const struct GNUNET_PeerIdentity *pid)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ compute_probabilities()

static void compute_probabilities ( uint32_t  peer_idx)
static

Computes the probability for each other peer to be selected by the sampling process based on the views of all peers.

Parameters
peer_idxindex of the peer that is about to sample

Definition at line 2239 of file gnunet-rps-profiler.c.

References binom(), count_containing_views(), RPSPeer::cur_view_count, RPSPeer::eval_probs_cache, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_malloc, GNUNET_snprintf(), GNUNET_strndup, GNUNET_YES, is_in_view(), num_peers, and to_file_w_len.

Referenced by view_update_cb().

2240 {
2241  // double probs[num_peers] = { 0 };
2242  double probs[num_peers];
2243  double probs_hist[num_peers]; /* Probability respecting the history */
2244  size_t probs_as_str_size = (num_peers * 10 + 2) * sizeof(char);
2245  char *probs_as_str = GNUNET_malloc (probs_as_str_size);
2246  char *probs_as_str_cpy;
2247  uint32_t i;
2248  double prob_push;
2249  double prob_pull;
2250  uint32_t view_size;
2251  uint32_t cont_views;
2252  uint32_t number_of_being_in_pull_events;
2253  int tmp;
2254  double sum_non_zero_prob = 0;
2255  double sum_non_zero_prob_hist = 0;
2256 
2258  "Computing probabilities for peer %" PRIu32 "\n", peer_idx);
2259  /* Firstly without knowledge of old views */
2260  for (i = 0; i < num_peers; i++)
2261  {
2263  "\tfor peer %" PRIu32 ":\n", i);
2264  view_size = rps_peers[i].cur_view_count;
2266  "\t\tview_size: %" PRIu32 "\n", view_size);
2267  /* For peer i the probability of being sampled is
2268  * evenly distributed among all possibly observed peers. */
2269  /* We could have observed a peer in three cases:
2270  * 1. peer sent a push
2271  * 2. peer was contained in a pull reply
2272  * 3. peer was in history (sampler) - ignored for now */
2273  /* 1. Probability of having received a push from peer i */
2274  if ((GNUNET_YES == is_in_view (i, peer_idx)) &&
2275  (1 <= (0.45 * view_size)))
2276  {
2277  if (0 == binom (view_size, 0.45 * view_size))
2278  prob_push = 0;
2279  else
2280  {
2281  prob_push = 1.0 * binom (0.45 * view_size, 1)
2282  /
2283  binom (view_size, 0.45 * view_size);
2284  }
2286  "\t\t%" PRIu32 " is in %" PRIu32 "'s view, prob: %f\n",
2287  peer_idx,
2288  i,
2289  prob_push);
2291  "\t\tposs choices from view: %" PRIu32 ", containing i: %"
2292  PRIu32 "\n",
2293  binom (view_size, 0.45 * view_size),
2294  binom (0.45 * view_size, 1));
2295  }
2296  else
2297  {
2298  prob_push = 0;
2300  "\t\t%" PRIu32 " is not in %" PRIu32 "'s view, prob: 0\n",
2301  peer_idx,
2302  i);
2303  }
2304  /* 2. Probability of peer i being contained in pulls */
2305  view_size = rps_peers[peer_idx].cur_view_count;
2306  cont_views = count_containing_views (peer_idx, i);
2307  number_of_being_in_pull_events =
2308  (binom (view_size, 0.45 * view_size)
2309  - binom (view_size - cont_views, 0.45 * view_size));
2310  if (0 != number_of_being_in_pull_events)
2311  {
2312  prob_pull = number_of_being_in_pull_events
2313  /
2314  (1.0 * binom (view_size, 0.45 * view_size));
2315  }
2316  else
2317  {
2318  prob_pull = 0;
2319  }
2320  probs[i] = prob_push + prob_pull - (prob_push * prob_pull);
2322  "\t\t%" PRIu32 " has %" PRIu32 " of %" PRIu32
2323  " peers in its view who know %" PRIu32 " prob: %f\n",
2324  peer_idx,
2325  cont_views,
2326  view_size,
2327  i,
2328  prob_pull);
2330  "\t\tnumber of possible pull combinations: %" PRIu32 "\n",
2331  binom (view_size, 0.45 * view_size));
2333  "\t\tnumber of possible pull combinations without %" PRIu32
2334  ": %" PRIu32 "\n",
2335  i,
2336  binom (view_size - cont_views, 0.45 * view_size));
2338  "\t\tnumber of possible pull combinations with %" PRIu32
2339  ": %" PRIu32 "\n",
2340  i,
2341  number_of_being_in_pull_events);
2342 
2343  probs_hist[i] = 0.9 * rps_peers[peer_idx].eval_probs_cache[i] + probs[i];
2344  rps_peers[peer_idx].eval_probs_cache[i] = probs_hist[i];
2345 
2346  sum_non_zero_prob += probs[i];
2347  sum_non_zero_prob_hist += probs_hist[i];
2348  }
2349  /* normalize */
2350  if (0 != sum_non_zero_prob)
2351  {
2352  for (i = 0; i < num_peers; i++)
2353  {
2354  probs[i] = probs[i] * (1.0 / sum_non_zero_prob);
2355  }
2356  }
2357  if (0 != sum_non_zero_prob_hist)
2358  {
2359  for (i = 0; i < num_peers; i++)
2360  {
2361  probs_hist[i] = probs_hist[i] * (1.0 / sum_non_zero_prob_hist);
2362  }
2363  }
2364 
2365  /* str repr */
2366  for (i = 0; i < num_peers; i++)
2367  {
2368  probs_as_str_cpy = GNUNET_strndup (probs_as_str, probs_as_str_size);
2369  tmp = GNUNET_snprintf (probs_as_str,
2370  probs_as_str_size,
2371  "%s %7.6f", probs_as_str_cpy, probs[i]);
2372  GNUNET_free (probs_as_str_cpy);
2373  GNUNET_assert (0 <= tmp);
2374  }
2375 
2376  to_file_w_len (rps_peers[peer_idx].file_name_probs,
2377  probs_as_str_size,
2378  "%s",
2379  probs_as_str);
2380 
2381  probs_as_str[0] = '\0';
2382  for (i = 0; i < num_peers; i++)
2383  {
2384  probs_as_str_cpy = GNUNET_strndup (probs_as_str, probs_as_str_size);
2385  tmp = GNUNET_snprintf (probs_as_str,
2386  probs_as_str_size,
2387  "%s %7.6f", probs_as_str_cpy, probs_hist[i]);
2388  GNUNET_free (probs_as_str_cpy);
2389  GNUNET_assert (0 <= tmp);
2390  }
2391 
2392  to_file_w_len (rps_peers[peer_idx].file_name_probs_hist,
2393  probs_as_str_size,
2394  "%s",
2395  probs_as_str);
2396  GNUNET_free (probs_as_str);
2397 }
static int is_in_view(uint32_t a, uint32_t b)
is b in view of a?
double * eval_probs_cache
Keep the probabilities in cache for computing the probabilities with respect to history.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define to_file_w_len(file_name, len,...)
Definition: rps-test_util.h:83
int GNUNET_snprintf(char *buf, size_t size, const char *format,...) __attribute__((format(printf
Like snprintf, just aborts if the buffer is of insufficient size.
static struct RPSPeer * rps_peers
Information for all the peers.
uint32_t cur_view_count
Number of peers in the cur_view.
uint32_t binom(uint32_t n, uint32_t k)
Binomial coefficient (n choose k)
static uint32_t count_containing_views(uint32_t a, uint32_t b)
Counts number of peers in view of a that have b in their view.
#define GNUNET_strndup(a, length)
Wrapper around GNUNET_xstrndup_.
#define GNUNET_log(kind,...)
static uint32_t num_peers
How many peers do we start?
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ count_peer_in_views_2()

static uint32_t count_peer_in_views_2 ( uint32_t  peer_idx)
static

This counts the number of peers in which views a given peer occurs.

It also stores this value in the rps peer.

Parameters
peer_idxthe index of the peer to count the representation
Returns
the number of occurrences

Definition at line 2410 of file gnunet-rps-profiler.c.

References RPSPeer::count_in_views, RPSPeer::cur_view_count, num_peers, and peer_id.

Referenced by view_update_cb().

2411 {
2412  uint32_t i, j;
2413  uint32_t count = 0;
2414 
2415  for (i = 0; i < num_peers; i++) /* Peer in which view is counted */
2416  {
2417  for (j = 0; j < rps_peers[i].cur_view_count; j++) /* entry in view */
2418  {
2419  if (0 == memcmp (rps_peers[peer_idx].peer_id,
2420  &rps_peers[i].cur_view[j],
2421  sizeof(struct GNUNET_PeerIdentity)))
2422  {
2423  count++;
2424  break;
2425  }
2426  }
2427  }
2428  rps_peers[peer_idx].count_in_views = count;
2429  return count;
2430 }
uint32_t count_in_views
Number of occurrences in other peer&#39;s view.
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
static struct RPSPeer * rps_peers
Information for all the peers.
uint32_t cur_view_count
Number of peers in the cur_view.
The identity of the host (wraps the signing key of the peer).
static uint32_t num_peers
How many peers do we start?
Here is the caller graph for this function:

◆ cumulated_view_sizes()

static uint32_t cumulated_view_sizes ( )
static

Definition at line 2434 of file gnunet-rps-profiler.c.

References RPSPeer::cur_view_count, num_peers, and view_sizes.

Referenced by view_update_cb().

2435 {
2436  uint32_t i;
2437 
2438  view_sizes = 0;
2439  for (i = 0; i < num_peers; i++) /* Peer in which view is counted */
2440  {
2442  }
2443  return view_sizes;
2444 }
static struct RPSPeer * rps_peers
Information for all the peers.
uint32_t cur_view_count
Number of peers in the cur_view.
static unsigned int view_sizes
The added sizes of the peer&#39;s views.
static uint32_t num_peers
How many peers do we start?
Here is the caller graph for this function:

◆ count_peer_in_views()

static void count_peer_in_views ( uint32_t *  count_peers)
static

Definition at line 2448 of file gnunet-rps-profiler.c.

References RPSPeer::cur_view_count, num_peers, and peer_id.

Referenced by compute_diversity().

2449 {
2450  uint32_t i, j;
2451 
2452  for (i = 0; i < num_peers; i++) /* Peer in which view is counted */
2453  {
2454  for (j = 0; j < rps_peers[i].cur_view_count; j++) /* entry in view */
2455  {
2456  if (0 == memcmp (rps_peers[i].peer_id,
2457  &rps_peers[i].cur_view[j],
2458  sizeof(struct GNUNET_PeerIdentity)))
2459  {
2460  count_peers[i]++;
2461  }
2462  }
2463  }
2464 }
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
static struct RPSPeer * rps_peers
Information for all the peers.
uint32_t cur_view_count
Number of peers in the cur_view.
The identity of the host (wraps the signing key of the peer).
static uint32_t num_peers
How many peers do we start?
Here is the caller graph for this function:

◆ compute_diversity()

void compute_diversity ( )

Definition at line 2468 of file gnunet-rps-profiler.c.

References count_peer_in_views(), RPSPeer::cur_view_count, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_new_array, num_peers, and peer_id.

Referenced by all_views_updated_cb().

2469 {
2470  uint32_t i;
2471  /* ith entry represents the numer of occurrences in other peer's views */
2472  uint32_t *count_peers = GNUNET_new_array (num_peers, uint32_t);
2473  uint32_t views_total_size;
2474  double expected;
2475  /* deviation from expected number of peers */
2476  double *deviation = GNUNET_new_array (num_peers, double);
2477 
2478  views_total_size = 0;
2479  expected = 0;
2480 
2481  /* For each peer count its representation in other peer's views*/
2482  for (i = 0; i < num_peers; i++) /* Peer to count */
2483  {
2484  views_total_size += rps_peers[i].cur_view_count;
2485  count_peer_in_views (count_peers);
2487  "Counted representation of %" PRIu32 "th peer [%s]: %" PRIu32
2488  "\n",
2489  i,
2491  count_peers[i]);
2492  }
2493 
2495  "size of all views combined: %" PRIu32 "\n",
2496  views_total_size);
2497  expected = ((double) 1 / num_peers) * views_total_size;
2499  "Expected number of occurrences of each peer in all views: %f\n",
2500  expected);
2501  for (i = 0; i < num_peers; i++) /* Peer to count */
2502  {
2503  deviation[i] = expected - count_peers[i];
2505  "Deviation from expectation: %f\n", deviation[i]);
2506  }
2507  GNUNET_free (count_peers);
2508  GNUNET_free (deviation);
2509 }
static void count_peer_in_views(uint32_t *count_peers)
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
static struct RPSPeer * rps_peers
Information for all the peers.
uint32_t cur_view_count
Number of peers in the cur_view.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
#define GNUNET_log(kind,...)
static uint32_t num_peers
How many peers do we start?
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ print_view_sizes()

void print_view_sizes ( )

Definition at line 2513 of file gnunet-rps-profiler.c.

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, num_peers, and peer_id.

Referenced by all_views_updated_cb().

2514 {
2515  uint32_t i;
2516 
2517  for (i = 0; i < num_peers; i++) /* Peer to count */
2518  {
2520  "View size of %" PRIu32 ". [%s] is %" PRIu32 "\n",
2521  i,
2523  rps_peers[i].cur_view_count);
2524  }
2525 }
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
static struct RPSPeer * rps_peers
Information for all the peers.
#define GNUNET_log(kind,...)
static uint32_t num_peers
How many peers do we start?
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
Here is the call graph for this function:
Here is the caller graph for this function:

◆ all_views_updated_cb()

void all_views_updated_cb ( )

Definition at line 2529 of file gnunet-rps-profiler.c.

References compute_diversity(), and print_view_sizes().

Referenced by view_update_cb().

2530 {
2531  compute_diversity ();
2532  print_view_sizes ();
2533 }
void compute_diversity()
void print_view_sizes()
Here is the call graph for this function:
Here is the caller graph for this function:

◆ view_update_cb()

void view_update_cb ( void *  cls,
uint64_t  view_size,
const struct GNUNET_PeerIdentity peers 
)

Definition at line 2537 of file gnunet-rps-profiler.c.

References all_views_updated_cb(), compute_probabilities(), count_peer_in_views_2(), cumulated_view_sizes(), RPSPeer::cur_view, RPSPeer::cur_view_count, GNUNET_array_grow, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_memcpy, RPSPeer::index, to_file, and view_sizes.

Referenced by GNUNET_RPS_view_request(), and pre_profiler().

2540 {
2542  "View was updated (%" PRIu64 ")\n", view_size);
2543  struct RPSPeer *rps_peer = (struct RPSPeer *) cls;
2544  to_file ("/tmp/rps/view_sizes.txt",
2545  "%" PRIu32 " %" PRIu64 "",
2546  rps_peer->index,
2547  view_size);
2548  for (uint64_t i = 0; i < view_size; i++)
2549  {
2551  "\t%s\n", GNUNET_i2s (&peers[i]));
2552  }
2553  GNUNET_array_grow (rps_peer->cur_view,
2554  rps_peer->cur_view_count,
2555  view_size);
2556  // *rps_peer->cur_view = *peers;
2557  GNUNET_memcpy (rps_peer->cur_view,
2558  peers,
2559  view_size * sizeof(struct GNUNET_PeerIdentity));
2560  to_file ("/tmp/rps/count_in_views.txt",
2561  "%" PRIu32 " %" PRIu32 "",
2562  rps_peer->index,
2563  count_peer_in_views_2 (rps_peer->index));
2565  if (0 != view_size)
2566  {
2567  to_file ("/tmp/rps/repr.txt",
2568  "%" PRIu32 /* index */
2569  " %" PRIu32 /* occurrence in views */
2570  " %" PRIu32 /* view sizes */
2571  " %f" /* fraction of repr in views */
2572  " %f" /* average view size */
2573  " %f" /* prob of occurrence in view slot */
2574  " %f" "", /* exp frac of repr in views */
2575  rps_peer->index,
2576  count_peer_in_views_2 (rps_peer->index),
2577  view_sizes,
2578  count_peer_in_views_2 (rps_peer->index) / (view_size * 1.0), /* fraction of representation in views */
2579  view_sizes / (view_size * 1.0), /* average view size */
2580  1.0 / view_size, /* prob of occurrence in view slot */
2581  (1.0 / view_size) * (view_sizes / view_size) /* expected fraction of repr in views */
2582  );
2583  }
2584  compute_probabilities (rps_peer->index);
2586 }
#define to_file(file_name,...)
This function is used to facilitate writing important information to disk.
Definition: rps-test_util.h:65
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_array_grow(arr, size, tsize)
Grow a well-typed (!) array.
uint32_t cur_view_count
Number of peers in the cur_view.
static void compute_probabilities(uint32_t peer_idx)
Computes the probability for each other peer to be selected by the sampling process based on the view...
static unsigned int view_sizes
The added sizes of the peer&#39;s views.
static uint32_t count_peer_in_views_2(uint32_t peer_idx)
This counts the number of peers in which views a given peer occurs.
Information we track for each peer.
The identity of the host (wraps the signing key of the peer).
#define GNUNET_log(kind,...)
static uint32_t cumulated_view_sizes()
uint32_t index
Index of the peer.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
void all_views_updated_cb()
struct GNUNET_PeerIdentity * cur_view
The current view.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ pre_profiler()

static void pre_profiler ( struct RPSPeer rps_peer,
struct GNUNET_RPS_Handle h 
)
static

Definition at line 2590 of file gnunet-rps-profiler.c.

References RPSPeer::eval_probs_cache, RPSPeer::file_name_probs, RPSPeer::file_name_probs_hist, GNUNET_new_array, GNUNET_RPS_view_request(), RPSPeer::index, num_peers, store_prefix_file_name(), and view_update_cb().

Referenced by run().

2591 {
2592  rps_peer->file_name_probs =
2593  store_prefix_file_name (rps_peer->index, "probs");
2594  rps_peer->file_name_probs_hist =
2595  store_prefix_file_name (rps_peer->index, "probs_hist");
2596  rps_peer->eval_probs_cache = GNUNET_new_array (num_peers, double);
2597  memset (rps_peer->eval_probs_cache, 0, num_peers * sizeof (double));
2598  GNUNET_RPS_view_request (h, 0, view_update_cb, rps_peer);
2599 }
double * eval_probs_cache
Keep the probabilities in cache for computing the probabilities with respect to history.
void GNUNET_RPS_view_request(struct GNUNET_RPS_Handle *rps_handle, uint32_t num_updates, GNUNET_RPS_NotifyReadyCB view_update_cb, void *cls)
Request updates of view.
Definition: rps_api.c:461
char * store_prefix_file_name(const unsigned int index, const char *prefix)
void view_update_cb(void *cls, uint64_t view_size, const struct GNUNET_PeerIdentity *peers)
const char * file_name_probs
File name of the file the stats are finally written to.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
const char * file_name_probs_hist
File name of the file the stats are finally written to.
static uint32_t num_peers
How many peers do we start?
uint32_t index
Index of the peer.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ write_final_stats()

void write_final_stats ( void  )

Definition at line 2602 of file gnunet-rps-profiler.c.

References GNUNET_i2s(), num_peers, peer_id, STATcls::stat_type, STAT_TYPE_BLOCKS, STAT_TYPE_BLOCKS_MANY_PUSH, STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL, STAT_TYPE_BLOCKS_NO_PULL, STAT_TYPE_BLOCKS_NO_PUSH, STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL, STAT_TYPE_ISSUED_PULL_REP, STAT_TYPE_ISSUED_PULL_REQ, STAT_TYPE_ISSUED_PULL_REQ_MH, STAT_TYPE_ISSUED_PUSH_SEND, STAT_TYPE_ISSUED_PUSH_SEND_MH, STAT_TYPE_KNOWN_PEERS, STAT_TYPE_LEARND_PEERS, STAT_TYPE_MAX, STAT_TYPE_PEERS_IN_PULL_MAP, STAT_TYPE_PEERS_IN_PUSH_MAP, STAT_TYPE_PEERS_IN_VIEW, STAT_TYPE_PENDING_ONLINE_CHECKS, STAT_TYPE_RECV_PULL_REP, STAT_TYPE_RECV_PULL_REP_MH, STAT_TYPE_RECV_PULL_REQ, STAT_TYPE_RECV_PULL_REQ_MH, STAT_TYPE_RECV_PUSH_SEND, STAT_TYPE_RECV_PUSH_SEND_MH, STAT_TYPE_ROUNDS, STAT_TYPE_SENT_PULL_REP, STAT_TYPE_SENT_PULL_REQ, STAT_TYPE_SENT_PULL_REQ_MH, STAT_TYPE_SENT_PUSH_SEND, STAT_TYPE_UNREQUESTED_PULL_REPLIES, STAT_TYPE_VALID_PEERS, STAT_TYPE_VIEW_SIZE, STAT_TYPE_VIEW_SIZE_AIM, stats, RPSPeer::stats, and to_file.

Referenced by post_test_shutdown_ready_cb().

2603 {
2604  uint64_t sums[STAT_TYPE_MAX] = { 0 };
2605 
2606  for (uint32_t i = 0; i < num_peers; i++)
2607  {
2608  to_file ("/tmp/rps/final_stats.csv",
2609  "%" PRIu32 ", " /* index */
2610  "%s, %" /* id */
2611  PRIu64 ", %" /* rounds */
2612  PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %"
2613  PRIu64 ", %" /* blocking */
2614  PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" /* issued */
2615  PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" /* sent */
2616  PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %"
2617  PRIu64 ", %" /* recv */
2618  PRIu64 ", %" /* view size */
2619  PRIu64 ", %" /* known peers */
2620  PRIu64 ", %" /* valid peers */
2621  PRIu64 ", %" /* learned peers */
2622  PRIu64 ", %" /* pending online checks */
2623  PRIu64 ", %" /* unrequested pull replies */
2624  PRIu64 ", %" /* peers in push map */
2625  PRIu64 ", %" /* peers in pull map */
2626  PRIu64 ", %" /* peers in view */
2627  PRIu64 "\n" /* view size aim */,
2628  i,
2662  for (enum STAT_TYPE stat_type = STAT_TYPE_ROUNDS;
2663  stat_type < STAT_TYPE_MAX;
2664  stat_type++)
2665  {
2666  sums[stat_type] += rps_peers[i].stats[stat_type];
2667  }
2668  }
2669  to_file ("/tmp/rps/final_stats.dat",
2670  "SUM %"
2671  PRIu64 " %" /* rounds */
2672  PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64
2673  " %" /* blocking */
2674  PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" /* issued */
2675  PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" /* sent */
2676  PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %"
2677  PRIu64 ", %" /* recv */
2678  PRIu64 ", %" /* view size */
2679  PRIu64 ", %" /* known peers */
2680  PRIu64 ", %" /* valid peers */
2681  PRIu64 ", %" /* learned peers */
2682  PRIu64 ", %" /* pending online checks */
2683  PRIu64 ", %" /* unrequested pull replies */
2684  PRIu64 ", %" /* peers in push map */
2685  PRIu64 ", %" /* peers in pull map */
2686  PRIu64 ", %" /* peers in view */
2687  PRIu64 "\n" /* view size aim */,
2688  sums[STAT_TYPE_ROUNDS],
2689  sums[STAT_TYPE_BLOCKS],
2710  sums[STAT_TYPE_VIEW_SIZE],
2711  sums[STAT_TYPE_KNOWN_PEERS],
2712  sums[STAT_TYPE_VALID_PEERS],
2713  sums[STAT_TYPE_LEARND_PEERS],
2719  sums[STAT_TYPE_VIEW_SIZE_AIM]);
2720 }
#define to_file(file_name,...)
This function is used to facilitate writing important information to disk.
Definition: rps-test_util.h:65
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
static struct RPSPeer * rps_peers
Information for all the peers.
uint64_t stats[STAT_TYPE_MAX]
statistics values
struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
static uint32_t num_peers
How many peers do we start?
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
Here is the call graph for this function:
Here is the caller graph for this function:

◆ post_test_shutdown_ready_cb()

void post_test_shutdown_ready_cb ( void *  cls,
int  success 
)

Continuation called by GNUNET_STATISTICS_get() functions.

Remembers that this specific statistics value was received for this peer. Checks whether all peers received their statistics yet. Issues the shutdown.

Parameters
clsclosure
successGNUNET_OK if statistics were successfully obtained, GNUNET_SYSERR if not.

Definition at line 2735 of file gnunet-rps-profiler.c.

References BIT, check_statistics_collect_completed(), check_statistics_collect_completed_single_peer(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_OK, GNUNET_SCHEDULER_shutdown(), GNUNET_TESTBED_operation_done(), GNUNET_YES, RPSPeer::h_stat_get, RPSPeer::index, STATcls::rps_peer, RPSPeer::stat_collected_flags, RPSPeer::stat_op, STATcls::stat_type, and write_final_stats().

Referenced by post_profiler().

2737 {
2738  struct STATcls *stat_cls = (struct STATcls *) cls;
2739  struct RPSPeer *rps_peer = stat_cls->rps_peer;
2740 
2741  rps_peer->h_stat_get[stat_cls->stat_type] = NULL;
2742  if (GNUNET_OK == success)
2743  {
2744  /* set flag that we we got the value */
2745  rps_peer->stat_collected_flags |= BIT (stat_cls->stat_type);
2746  }
2747  else
2748  {
2750  "Peer %u did not receive statistics value\n",
2751  rps_peer->index);
2752  GNUNET_free (stat_cls);
2753  GNUNET_break (0);
2754  return;
2755  }
2756 
2757  if ((NULL != rps_peer->stat_op) &&
2759  rps_peer)) )
2760  {
2762  }
2763 
2764  write_final_stats ();
2766  {
2767  // write_final_stats ();
2768  GNUNET_free (stat_cls);
2770  "Shutting down\n");
2772  }
2773  else
2774  {
2775  GNUNET_free (stat_cls);
2776  }
2777 }
struct RPSPeer * rps_peer
static int check_statistics_collect_completed()
Checks if all peers already received their statistics value from the statistics service.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:531
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
enum STAT_TYPE stat_type
void GNUNET_TESTBED_operation_done(struct GNUNET_TESTBED_Operation *operation)
This function is used to signal that the event information (struct GNUNET_TESTBED_EventInformation) f...
Definition: testbed_api.c:2045
void write_final_stats(void)
Information we track for each peer.
struct GNUNET_STATISTICS_GetHandle * h_stat_get[STAT_TYPE_MAX]
Handle for the statistics get request.
uint32_t stat_collected_flags
flags to indicate which statistics values have been already collected from the statistics service...
#define GNUNET_log(kind,...)
#define BIT(n)
struct GNUNET_TESTBED_Operation * stat_op
Testbed operation to connect to statistics service.
uint32_t index
Index of the peer.
#define GNUNET_free(ptr)
Wrapper around free.
static int check_statistics_collect_completed_single_peer(const struct RPSPeer *rps_peer)
Checks if given peer already received its statistics value from the statistics service.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ stat_iterator()

int stat_iterator ( void *  cls,
const char *  subsystem,
const char *  name,
uint64_t  value,
int  is_persistent 
)

Callback function to process statistic values.

Parameters
clsclosure
subsystemname of subsystem that created the statistic
namethe name of the datum
valuethe current value
is_persistentGNUNET_YES if the value is persistent, GNUNET_NO if not
Returns
GNUNET_OK to continue, GNUNET_SYSERR to abort iteration

Definition at line 2791 of file gnunet-rps-profiler.c.

References RPSPeer::file_name_stats, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_OK, RPSPeer::index, STATcls::rps_peer, stat_str_2_type(), STATcls::stat_type, STAT_TYPE_MAX, STAT_TYPE_ROUNDS, RPSPeer::stats, subsystem, to_file, and value.

Referenced by post_profiler().

2796 {
2797  const struct STATcls *stat_cls = (const struct STATcls *) cls;
2798  struct RPSPeer *rps_peer = (struct RPSPeer *) stat_cls->rps_peer;
2799  enum STAT_TYPE stat_type;
2800 
2801  (void) subsystem;
2802  (void) is_persistent;
2803 
2805  "Got stat value: %s - %" PRIu64 " (%u)\n",
2806  name,
2807  value,
2808  rps_peer->index);
2809  to_file (rps_peer->file_name_stats,
2810  "%s: %" PRIu64 "\n",
2811  name,
2812  value);
2813  stat_type = stat_str_2_type (name);
2814  GNUNET_assert (STAT_TYPE_ROUNDS <= stat_type &&
2815  STAT_TYPE_MAX > stat_type);
2816  rps_peer->stats[stat_type] = value;
2817  return GNUNET_OK;
2818 }
static char * subsystem
Set to subsystem that we&#39;re going to get stats for (or NULL for all).
#define to_file(file_name,...)
This function is used to facilitate writing important information to disk.
Definition: rps-test_util.h:65
struct RPSPeer * rps_peer
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static char * value
Value of the record to add/remove.
uint64_t stats[STAT_TYPE_MAX]
statistics values
enum STAT_TYPE stat_str_2_type(const char *stat_str)
Converts string representation to the corresponding STAT_TYPE enum.
Information we track for each peer.
const char * name
#define GNUNET_log(kind,...)
const char * file_name_stats
File name of the file the stats are finally written to.
uint32_t index
Index of the peer.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ post_profiler()

void post_profiler ( struct RPSPeer rps_peer)

Definition at line 2822 of file gnunet-rps-profiler.c.

References BIT, COLLECT_STATISTICS, cur_test_run, RPSPeer::eval_probs_cache, RPSPeer::file_name_stats, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_malloc, GNUNET_STATISTICS_get(), RPSPeer::h_stat_get, SingleTestRun::have_collect_statistics, RPSPeer::index, post_test_shutdown_ready_cb(), STATcls::rps_peer, SingleTestRun::stat_collect_flags, stat_iterator(), STATcls::stat_type, STAT_TYPE_MAX, STAT_TYPE_ROUNDS, stat_type_strings, RPSPeer::stats_h, and store_prefix_file_name().

Referenced by run().

2823 {
2825  {
2826  return;
2827  }
2828 
2830  "Going to request statistic values with mask 0x%" PRIx32 "\n",
2832 
2833  struct STATcls *stat_cls;
2834  uint32_t stat_type;
2835  for (stat_type = STAT_TYPE_ROUNDS;
2836  stat_type < STAT_TYPE_MAX;
2837  stat_type++)
2838  {
2839  if (BIT (stat_type) & cur_test_run.stat_collect_flags)
2840  {
2841  stat_cls = GNUNET_malloc (sizeof(struct STATcls));
2842  stat_cls->rps_peer = rps_peer;
2843  stat_cls->stat_type = stat_type;
2844  rps_peer->file_name_stats =
2845  store_prefix_file_name (rps_peer->index, "stats");
2846  rps_peer->h_stat_get[stat_type] =
2847  GNUNET_STATISTICS_get (rps_peer->stats_h,
2848  "rps",
2849  stat_type_strings [stat_type],
2851  stat_iterator,
2852  (struct STATcls *) stat_cls);
2853  GNUNET_assert (NULL != rps_peer->h_stat_get);
2855  "Requested statistics for %s (peer %" PRIu32 ")\n",
2856  stat_type_strings [stat_type],
2857  rps_peer->index);
2858  }
2859  }
2860  GNUNET_free (rps_peer->eval_probs_cache);
2861 }
double * eval_probs_cache
Keep the probabilities in cache for computing the probabilities with respect to history.
struct RPSPeer * rps_peer
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_STATISTICS_Handle * stats_h
Handle to the statistics service.
struct SingleTestRun cur_test_run
enum STAT_TYPE stat_type
static char * stat_type_strings[]
char * store_prefix_file_name(const unsigned int index, const char *prefix)
enum OPTION_COLLECT_STATISTICS have_collect_statistics
Collect statistics at the end?
void post_test_shutdown_ready_cb(void *cls, int success)
Continuation called by GNUNET_STATISTICS_get() functions.
uint32_t stat_collect_flags
Mark which values from the statistics service to collect at the end of the run.
We collect statistics at the end.
int stat_iterator(void *cls, const char *subsystem, const char *name, uint64_t value, int is_persistent)
Callback function to process statistic values.
struct GNUNET_STATISTICS_GetHandle * h_stat_get[STAT_TYPE_MAX]
Handle for the statistics get request.
struct GNUNET_STATISTICS_GetHandle * GNUNET_STATISTICS_get(struct GNUNET_STATISTICS_Handle *handle, const char *subsystem, const char *name, GNUNET_STATISTICS_Callback cont, GNUNET_STATISTICS_Iterator proc, void *cls)
Get statistic from the peer.
#define GNUNET_log(kind,...)
const char * file_name_stats
File name of the file the stats are finally written to.
#define BIT(n)
uint32_t index
Index of the peer.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ test_run()

static void test_run ( void *  cls,
struct GNUNET_TESTBED_RunHandle h,
unsigned int  n_peers,
struct GNUNET_TESTBED_Peer **  peers,
unsigned int  links_succeeded,
unsigned int  links_failed 
)
static

Actual "main" function for the testcase.

Parameters
clsclosure
hthe run handle
n_peersnumber of peers in 'peers'
peershandle to peers run in the testbed
links_succeededthe number of overlay link connection attempts that succeeded
links_failedthe number of overlay link connection attempts that failed

Definition at line 2882 of file gnunet-rps-profiler.c.

References COLLECT_STATISTICS, cur_test_run, RPSPeer::cur_view, RPSPeer::cur_view_count, duration, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_shutdown(), GNUNET_TESTBED_peer_get_information(), GNUNET_TESTBED_PIT_IDENTITY, GNUNET_TESTBED_service_connect(), SingleTestRun::have_collect_statistics, SingleTestRun::have_collect_view, OpListEntry::index, RPSPeer::index, info_cb(), SingleTestRun::init_peer, make_oplist_entry(), NO_COLLECT_VIEW, num_peers, num_peers_online, ok, OpListEntry::op, RPSPeer::op, peers, post_test_op(), GNUNET_TIME_Relative::rel_value_us, rps_connect_adapter(), rps_connect_complete_cb(), rps_disconnect_adapter(), shutdown_op(), stat_complete_cb(), stat_connect_adapter(), stat_disconnect_adapter(), RPSPeer::stat_op, timeout, and trigger_shutdown().

Referenced by run().

2888 {
2889  unsigned int i;
2890  struct OpListEntry *entry;
2891 
2892  (void) cls;
2893  (void) h;
2894  (void) links_failed;
2895 
2896  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "RUN was called\n");
2897 
2898  /* Check whether we timed out */
2899  if ((n_peers != num_peers) ||
2900  (NULL == peers) ||
2901  (0 == links_succeeded) )
2902  {
2904  "Going down due to args (eg. timeout)\n");
2905  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tn_peers: %u\n", n_peers);
2906  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tnum_peers: %" PRIu32 "\n",
2907  num_peers);
2908  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tpeers: %p\n", peers);
2909  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tlinks_succeeded: %u\n",
2910  links_succeeded);
2911  ok = 1;
2913  return;
2914  }
2915 
2916 
2917  /* Initialize peers */
2918  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "going to initialise peers\n");
2919  testbed_peers = peers;
2920  num_peers_online = 0;
2921  for (i = 0; i < num_peers; i++)
2922  {
2923  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "initialising %u\n", i);
2924  entry = make_oplist_entry ();
2925  entry->index = i;
2926  rps_peers[i].index = i;
2927  if (NULL != cur_test_run.init_peer)
2930  {
2932  rps_peers->cur_view = NULL;
2933  }
2934  entry->op = GNUNET_TESTBED_peer_get_information (peers[i],
2936  &info_cb,
2937  entry);
2938  }
2939 
2940  /* Bring peers up */
2941  GNUNET_assert (num_peers == n_peers);
2942  for (i = 0; i < n_peers; i++)
2943  {
2944  rps_peers[i].index = i;
2945  rps_peers[i].op =
2947  peers[i],
2948  "rps",
2950  &rps_peers[i],
2953  &rps_peers[i]);
2954  /* Connect all peers to statistics service */
2956  {
2958  "Connecting to statistics service\n");
2959  rps_peers[i].stat_op =
2961  peers[i],
2962  "statistics",
2964  &rps_peers[i],
2967  &rps_peers[i]);
2968  }
2969  }
2970 
2971  if (NULL != churn_task)
2974  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "timeout for shutdown is %lu\n",
2975  timeout.rel_value_us / 1000000);
2978  NULL);
2980 }
static struct GNUNET_TIME_Relative timeout
When do we do a hard shutdown?
uint64_t rel_value_us
The actual value.
static void stat_disconnect_adapter(void *cls, void *op_result)
Called to disconnect from peer&#39;s statistics service.
enum OPTION_COLLECT_VIEW have_collect_view
Collect view during run?
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1331
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static int ok
Return value from &#39;main&#39;.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:531
struct SingleTestRun cur_test_run
static unsigned int num_peers_online
Number of online peers.
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_service_connect(void *op_cls, struct GNUNET_TESTBED_Peer *peer, const char *service_name, GNUNET_TESTBED_ServiceConnectCompletionCallback cb, void *cb_cls, GNUNET_TESTBED_ConnectAdapter ca, GNUNET_TESTBED_DisconnectAdapter da, void *cada_cls)
Connect to a service offered by the given peer.
static struct OpListEntry * make_oplist_entry()
Creates an oplist entry and adds it to the oplist DLL.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1269
static struct RPSPeer * rps_peers
Information for all the peers.
Operation map entry.
static void * rps_connect_adapter(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
Adapter function called to establish a connection to the RPS service.
uint32_t cur_view_count
Number of peers in the cur_view.
enum OPTION_COLLECT_STATISTICS have_collect_statistics
Collect statistics at the end?
static void shutdown_op(void *cls)
Task run on timeout to shut everything down.
struct GNUNET_TESTBED_Operation * op
Handle for RPS connect operation.
static void * stat_connect_adapter(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
Called to open a connection to the peer&#39;s statistics.
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_peer_get_information(struct GNUNET_TESTBED_Peer *peer, enum GNUNET_TESTBED_PeerInformationType pit, GNUNET_TESTBED_PeerInfoCallback cb, void *cb_cls)
Request information about a peer.
static void rps_disconnect_adapter(void *cls, void *op_result)
Adapter function called to destroy connection to RPS service.
static void stat_complete_cb(void *cls, struct GNUNET_TESTBED_Operation *op, void *ca_result, const char *emsg)
Called after successfully opening a connection to a peer&#39;s statistics service; we register statistics...
static struct GNUNET_SCHEDULER_Task * post_test_task
Identifier for the task that runs after the test to collect results.
static struct GNUNET_TESTBED_Peer ** testbed_peers
Handles to all of the running peers.
We collect statistics at the end.
void info_cb(void *cb_cls, struct GNUNET_TESTBED_Operation *op, const struct GNUNET_TESTBED_PeerInformation *pinfo, const char *emsg)
Get the id of peer i.
What is the identity of the peer? Returns a &#39;const struct GNUNET_PeerIdentity *&#39;. ...
static void rps_connect_complete_cb(void *cls, struct GNUNET_TESTBED_Operation *op, void *ca_result, const char *emsg)
Callback to be called when RPS service connect operation is completed.
static void post_test_op(void *cls)
Task run after duration to collect statistics and potentially shut down.
InitPeer init_peer
Called with a single peer in order to initialise that peer.
static struct CadetPeer * peers
Operation to get peer ids.
#define GNUNET_log(kind,...)
unsigned int index
Index of the regarding peer.
static struct GNUNET_SCHEDULER_Task * shutdown_task
Identifier for the shutdown task.
static struct GNUNET_TIME_Relative duration
How long do we run the test?
static struct GNUNET_SCHEDULER_Task * churn_task
Identifier for the churn task that runs periodically.
struct GNUNET_TESTBED_Operation * stat_op
Testbed operation to connect to statistics service.
static void trigger_shutdown(void *cls)
static uint32_t num_peers
How many peers do we start?
uint32_t index
Index of the peer.
struct GNUNET_TESTBED_Operation * op
The testbed operation.
We do not collect the view during run.
struct GNUNET_PeerIdentity * cur_view
The current view.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
Here is the call graph for this function:
Here is the caller graph for this function:

◆ run()

static void run ( void *  cls,
char *const *  args,
const char *  cfgfile,
const struct GNUNET_CONFIGURATION_Handle cfg 
)
static

Entry point for the testcase, sets up the testbed.

Parameters
argcunused
argvunused

Definition at line 2990 of file gnunet-rps-profiler.c.

References BIT, bits_needed, COLLECT_STATISTICS, COLLECT_VIEW, cur_test_run, duration, SingleTestRun::eval_cb, GNUNET_assert, GNUNET_CONTAINER_multipeermap_create(), GNUNET_DISK_directory_create(), GNUNET_DISK_directory_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new_array, GNUNET_NO, GNUNET_TESTBED_run(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_SECONDS, SingleTestRun::have_churn, SingleTestRun::have_collect_statistics, SingleTestRun::have_collect_view, HAVE_NO_CHURN, HAVE_QUICK_QUIT, SingleTestRun::have_quick_quit, SingleTestRun::init_peer, SingleTestRun::main_test, mal_type, SingleTestRun::name, num_peers, SingleTestRun::num_requests, ok, post_profiler(), SingleTestRun::post_test, pre_profiler(), SingleTestRun::pre_test, profiler_cb(), profiler_eval(), profiler_init_peer(), profiler_reply_handle(), GNUNET_TIME_Relative::rel_value_us, SingleTestRun::reply_handle, SingleTestRun::request_interval, SingleTestRun::stat_collect_flags, STAT_TYPE_BLOCKS, STAT_TYPE_BLOCKS_MANY_PUSH, STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL, STAT_TYPE_BLOCKS_NO_PULL, STAT_TYPE_BLOCKS_NO_PUSH, STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL, STAT_TYPE_ISSUED_PULL_REP, STAT_TYPE_ISSUED_PULL_REQ, STAT_TYPE_ISSUED_PULL_REQ_MH, STAT_TYPE_ISSUED_PUSH_SEND, STAT_TYPE_ISSUED_PUSH_SEND_MH, STAT_TYPE_KNOWN_PEERS, STAT_TYPE_LEARND_PEERS, STAT_TYPE_PEERS_IN_PULL_MAP, STAT_TYPE_PEERS_IN_PUSH_MAP, STAT_TYPE_PEERS_IN_VIEW, STAT_TYPE_PENDING_ONLINE_CHECKS, STAT_TYPE_RECV_PULL_REP, STAT_TYPE_RECV_PULL_REP_MH, STAT_TYPE_RECV_PULL_REQ, STAT_TYPE_RECV_PULL_REQ_MH, STAT_TYPE_RECV_PUSH_SEND, STAT_TYPE_RECV_PUSH_SEND_MH, STAT_TYPE_ROUNDS, STAT_TYPE_SENT_PULL_REP, STAT_TYPE_SENT_PULL_REQ, STAT_TYPE_SENT_PULL_REQ_MH, STAT_TYPE_SENT_PUSH_SEND, STAT_TYPE_UNREQUESTED_PULL_REPLIES, STAT_TYPE_VALID_PEERS, STAT_TYPE_VIEW_SIZE, STAT_TYPE_VIEW_SIZE_AIM, test_run(), and timeout.

Referenced by main().

2994 {
2995  // int ret_value;
2996  (void) cls;
2997  (void) args;
2998  (void) cfgfile;
2999 
3000  /* Defaults for tests */
3001  churn_task = NULL;
3002 
3003  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "This is the profiler\n");
3004  cur_test_run.name = "test-rps-profiler";
3005  if (0 == num_peers)
3006  num_peers = 10;
3007  mal_type = 3;
3009  // cur_test_run.pre_test = mal_pre;
3016  if (0 == cur_test_run.num_requests)
3018  // cur_test_run.have_churn = HAVE_CHURN;
3023  | BIT (STAT_TYPE_BLOCKS)
3055 
3056  /* 'Clean' directory */
3057  (void) GNUNET_DISK_directory_remove ("/tmp/rps/");
3058  GNUNET_DISK_directory_create ("/tmp/rps/");
3059  if (0 == duration.rel_value_us)
3060  {
3061  if (0 == timeout.rel_value_us)
3062  {
3065  (90 * 1.2)
3066  + (0.01 * num_peers));
3067  }
3068  else
3069  {
3071  (timeout.rel_value_us / 1000000)
3072  * 0.75);
3073  }
3074  }
3075  else
3076  {
3077  if (0 == timeout.rel_value_us)
3078  {
3081  / 1000000)
3082  * 1.2) + (0.01 * num_peers));
3083  }
3084  }
3087  "duration is %lus\n",
3088  duration.rel_value_us / 1000000);
3090  "timeout is %lus\n",
3091  timeout.rel_value_us / 1000000);
3092 
3093  /* Compute number of bits for representing largest peer id */
3094  for (bits_needed = 1; (uint32_t) (1 << bits_needed) < num_peers; bits_needed++)
3095  ;
3097  "Need %u bits to represent %" PRIu32 " peers\n",
3098  bits_needed,
3099  num_peers);
3100 
3104  if ((2 == mal_type) ||
3105  (3 == mal_type))
3107 
3108  ok = 1;
3109  GNUNET_TESTBED_run (NULL,
3110  cfg,
3111  num_peers,
3112  0, /* event mask */
3113  NULL,
3114  NULL,
3115  &test_run,
3116  NULL);
3117 }
static struct GNUNET_TIME_Relative timeout
When do we do a hard shutdown?
uint64_t rel_value_us
The actual value.
enum OPTION_COLLECT_VIEW have_collect_view
Collect view during run?
int GNUNET_DISK_directory_create(const char *dir)
Implementation of "mkdir -p".
Definition: disk.c:589