GNUnet 0.21.0
gnunet_dht_profiler.c File Reference

Profiler for GNUnet DHT. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_testbed_service.h"
#include "gnunet_dht_service.h"
#include "gnunet_constants.h"
Include dependency graph for gnunet_dht_profiler.c:

Go to the source code of this file.

Data Structures

struct  Context
 Context to hold data of peer. More...
 
struct  ActiveContext
 Context for a peer which actively does DHT PUT/GET. More...
 

Macros

#define MESSAGE(...)    GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, __VA_ARGS__)
 
#define DEBUG(...)    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
 

Enumerations

enum  { MODE_PUT = 0 , MODE_GET = 1 }
 Should we do a PUT (mode = 0) or GET (mode = 1);. More...
 

Functions

static void start_profiling (void)
 Connect to DHT services of active peers. More...
 
static void do_shutdown (void *cls)
 Shutdown task. More...
 
static void bandwidth_stats_cont (void *cls, struct GNUNET_TESTBED_Operation *op, const char *emsg)
 Stats callback. More...
 
static int bandwidth_stats_iterator (void *cls, const struct GNUNET_TESTBED_Peer *peer, const char *subsystem, const char *name, uint64_t value, int is_persistent)
 Process statistic values. More...
 
static void summarize ()
 
static void cancel_get (void *cls)
 Task to cancel DHT GET. More...
 
static void get_iter (void *cls, struct GNUNET_TIME_Absolute exp, const struct GNUNET_HashCode *key, const struct GNUNET_PeerIdentity *trunc_peer, const struct GNUNET_DHT_PathElement *get_path, unsigned int get_path_length, const struct GNUNET_DHT_PathElement *put_path, unsigned int put_path_length, enum GNUNET_BLOCK_Type type, size_t size, const void *data)
 Iterator called on each result obtained for a DHT operation that expects a reply. More...
 
static void delayed_get (void *cls)
 Task to do DHT GETs. More...
 
static void delayed_put (void *cls)
 Task to do DHT PUTs. More...
 
static void put_cont (void *cls)
 Conclude individual PUT operation, schedule the next one. More...
 
static void dht_connected (void *cls, struct GNUNET_TESTBED_Operation *op, void *ca_result, const char *emsg)
 Connection to DHT has been established. More...
 
static void * dht_connect (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
 Connect to DHT service and return the DHT client handler. More...
 
static void dht_disconnect (void *cls, void *op_result)
 Adapter function called to destroy a connection to a service. More...
 
static void service_started (void *cls, struct GNUNET_TESTBED_Operation *op, const char *emsg)
 Callback called when DHT service on the peer is started. More...
 
static void test_run (void *cls, struct GNUNET_TESTBED_RunHandle *h, unsigned int num_peers, struct GNUNET_TESTBED_Peer **peers, unsigned int links_succeeded, unsigned int links_failed)
 Signature of a main function for a testcase. More...
 
static void run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *config)
 Main function that will be run by the scheduler. More...
 
int main (int argc, char *const *argv)
 Main function. More...
 

Variables

static unsigned int put_probability = 100
 Number of peers which should perform a PUT out of 100 peers. More...
 
static const struct GNUNET_CONFIGURATION_Handlecfg
 Configuration. More...
 
static char * hosts_file
 Name of the file with the hosts to run the test over. More...
 
static struct Contexta_ctx
 An array of contexts. More...
 
static struct ActiveContexta_ac
 Array of active peers. More...
 
static struct GNUNET_TIME_Relative delay_stats
 The delay between rounds for collecting statistics. More...
 
static struct GNUNET_TIME_Relative delay_put
 The delay to start puts. More...
 
static struct GNUNET_TIME_Relative delay_get
 The delay to start puts. More...
 
static struct GNUNET_TIME_Relative timeout
 The timeout for GET and PUT. More...
 
static unsigned int num_peers
 Number of peers. More...
 
static unsigned int n_active
 Number of active peers. More...
 
static unsigned int n_dht
 Number of DHT service connections we currently have. More...
 
static unsigned long long n_puts
 Number of DHT PUTs made. More...
 
static unsigned int num_puts_per_peer = 1
 Number of DHT PUTs to be made per peer. More...
 
static unsigned long long n_puts_ok
 Number of DHT PUTs succeeded. More...
 
static unsigned int n_gets
 Number of DHT GETs made. More...
 
static unsigned int n_gets_ok
 Number of DHT GETs succeeded. More...
 
static unsigned int n_gets_fail
 Number of DHT GETs succeeded. More...
 
static unsigned int replication
 Replication degree. More...
 
static struct GNUNET_TESTBED_Operation * bandwidth_stats_op
 Testbed Operation (to get stats). More...
 
static struct GNUNET_TESTBED_Peer ** testbed_handles
 Testbed peer handles. More...
 
static uint64_t outgoing_bandwidth
 Total number of messages sent by peer. More...
 
static uint64_t incoming_bandwidth
 Total number of messages received by peer. More...
 
static double average_put_path_length
 Average number of hops taken to do put. More...
 
static double average_get_path_length
 Average number of hops taken to do get. More...
 
static unsigned int total_put_path_length
 Total put path length across all peers. More...
 
static unsigned int total_get_path_length
 Total get path length across all peers. More...
 
static int peers_started = 0
 Counter to keep track of peers added to peer_context lists. More...
 
static enum { ... }  mode
 Should we do a PUT (mode = 0) or GET (mode = 1);. More...
 
static int in_shutdown = 0
 Are we shutting down. More...
 

Detailed Description

Profiler for GNUnet DHT.

Author
Sree Harsha Totakura sreeh.nosp@m.arsh.nosp@m.a@tot.nosp@m.akur.nosp@m.a.in

Definition in file gnunet_dht_profiler.c.

Macro Definition Documentation

◆ MESSAGE

#define MESSAGE (   ...)     GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, __VA_ARGS__)

Definition at line 34 of file gnunet_dht_profiler.c.

◆ DEBUG

#define DEBUG (   ...)     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)

Definition at line 37 of file gnunet_dht_profiler.c.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Should we do a PUT (mode = 0) or GET (mode = 1);.

Enumerator
MODE_PUT 
MODE_GET 

Definition at line 263 of file gnunet_dht_profiler.c.

264{
265 MODE_PUT = 0,
266
267 MODE_GET = 1
268} mode;
@ MODE_GET
@ MODE_PUT
static enum @44 mode
Should we do a PUT (mode = 0) or GET (mode = 1);.

Function Documentation

◆ start_profiling()

static void start_profiling ( void  )
static

Connect to DHT services of active peers.

Definition at line 784 of file gnunet_dht_profiler.c.

785{
786 struct Context *ctx;
787
788 DEBUG ("GNUNET_TESTBED_service_connect\n");
790 for (unsigned int i = 0; i < n_active; i++)
791 {
792 struct ActiveContext *ac = &a_ac[i];
793 GNUNET_assert (NULL != (ctx = ac->ctx));
794 GNUNET_assert (NULL == ctx->op);
795 ctx->op = GNUNET_TESTBED_service_connect (ctx,
796 ctx->peer,
797 "dht",
798 &dht_connected, ac,
801 ac);
802 }
803}
static struct GNUNET_FS_Handle * ctx
static void dht_connected(void *cls, struct GNUNET_TESTBED_Operation *op, void *ca_result, const char *emsg)
Connection to DHT has been established.
static void * dht_connect(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to DHT service and return the DHT client handler.
static int in_shutdown
Are we shutting down.
static unsigned int n_active
Number of active peers.
#define DEBUG(...)
static void dht_disconnect(void *cls, void *op_result)
Adapter function called to destroy a connection to a service.
static struct ActiveContext * a_ac
Array of active peers.
@ GNUNET_YES
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
Context for a peer which actively does DHT PUT/GET.
struct Context * ctx
The linked peer context.
Context to hold data of peer.

References a_ac, ctx, ActiveContext::ctx, DEBUG, dht_connect(), dht_connected(), dht_disconnect(), GNUNET_assert, GNUNET_break, GNUNET_YES, in_shutdown, and n_active.

Referenced by dht_disconnect(), and service_started().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ do_shutdown()

static void do_shutdown ( void *  cls)
static

Shutdown task.

Cleanup all resources and operations.

Parameters
clsNULL

Definition at line 290 of file gnunet_dht_profiler.c.

291{
292 struct ActiveContext *ac;
293
295 if (NULL != a_ctx)
296 {
297 for (unsigned int cnt = 0; cnt < num_peers; cnt++)
298 {
299 /* Cleanup active context if this peer is an active peer */
300 ac = a_ctx[cnt].ac;
301 if (NULL != ac)
302 {
303 if (NULL != ac->delay_task)
305 if (NULL != ac->hash)
306 free (ac->hash);
307 if (NULL != ac->dht_put)
309 if (NULL != ac->dht_get)
311 }
312 /* Cleanup testbed operation handle at the last as this operation may
313 contain service connection to DHT */
314 if (NULL != a_ctx[cnt].op)
315 GNUNET_TESTBED_operation_done (a_ctx[cnt].op);
316 }
318 a_ctx = NULL;
319 }
320 // FIXME: Should we collect stats only for put/get not for other messages.
321 if (NULL != bandwidth_stats_op)
322 {
323 GNUNET_TESTBED_operation_done (bandwidth_stats_op);
324 bandwidth_stats_op = NULL;
325 }
327}
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
static struct GNUNET_TESTBED_Operation * bandwidth_stats_op
Testbed Operation (to get stats).
static struct Context * a_ctx
An array of contexts.
static unsigned int num_peers
Number of peers.
void GNUNET_DHT_put_cancel(struct GNUNET_DHT_PutHandle *ph)
Cancels a DHT PUT operation.
Definition: dht_api.c:1146
void GNUNET_DHT_get_stop(struct GNUNET_DHT_GetHandle *get_handle)
Stop async DHT-get.
Definition: dht_api.c:1235
#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:975
struct GNUNET_HashCode * hash
The hashes of the values stored via this activity context.
struct GNUNET_SCHEDULER_Task * delay_task
Delay task.
struct GNUNET_DHT_PutHandle * dht_put
The put handle.
struct GNUNET_DHT_GetHandle * dht_get
The get handle.
struct ActiveContext * ac
Active context; NULL if this peer is not an active peer.

References a_ac, a_ctx, Context::ac, bandwidth_stats_op, ActiveContext::delay_task, ActiveContext::dht_get, ActiveContext::dht_put, GNUNET_DHT_get_stop(), GNUNET_DHT_put_cancel(), GNUNET_free, GNUNET_SCHEDULER_cancel(), GNUNET_YES, ActiveContext::hash, in_shutdown, num_peers, and op.

Referenced by run().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ bandwidth_stats_cont()

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

Stats callback.

Finish the stats testbed operation and when all stats have been iterated, shutdown the test.

Parameters
clsclosure
opthe operation that has been finished
emsgerror message in case the operation has failed; will be NULL if operation has executed successfully.

Definition at line 340 of file gnunet_dht_profiler.c.

343{
344 MESSAGE ("# Outgoing (core) bandwidth: %llu bytes\n",
345 (unsigned long long) outgoing_bandwidth);
346 MESSAGE ("# Incoming (core) bandwidth: %llu bytes\n",
347 (unsigned long long) incoming_bandwidth);
348 fprintf (stderr,
349 "Benchmark done. Collect data via gnunet-statistics, then press ENTER to exit.\n");
350 (void) getchar ();
352}
static uint64_t outgoing_bandwidth
Total number of messages sent by peer.
#define MESSAGE(...)
static uint64_t incoming_bandwidth
Total number of messages received by peer.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:562

References GNUNET_SCHEDULER_shutdown(), incoming_bandwidth, MESSAGE, and outgoing_bandwidth.

Referenced by summarize().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ bandwidth_stats_iterator()

static int bandwidth_stats_iterator ( void *  cls,
const struct GNUNET_TESTBED_Peer *  peer,
const char *  subsystem,
const char *  name,
uint64_t  value,
int  is_persistent 
)
static

Process statistic values.

Parameters
clsclosure
peerthe peer the statistic belong to
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 367 of file gnunet_dht_profiler.c.

373{
374 static const char *s_sent = "# bytes encrypted";
375 static const char *s_recv = "# bytes decrypted";
376
377 if (0 == strncmp (s_sent, name, strlen (s_sent)))
379 else if (0 == strncmp (s_recv, name, strlen (s_recv)))
381 return GNUNET_OK;
382}
static char * name
Name (label) of the records to list.
static char * value
Value of the record to add/remove.
@ GNUNET_OK

References GNUNET_OK, incoming_bandwidth, name, outgoing_bandwidth, and value.

Referenced by summarize().

Here is the caller graph for this function:

◆ summarize()

static void summarize ( )
static

Definition at line 386 of file gnunet_dht_profiler.c.

387{
388 MESSAGE ("# PUTS started: %llu\n",
389 n_puts);
390 MESSAGE ("# PUTS succeeded: %llu\n",
391 n_puts_ok);
392 MESSAGE ("# GETS made: %u\n",
393 n_gets);
394 MESSAGE ("# GETS succeeded: %u\n",
395 n_gets_ok);
396 MESSAGE ("# GETS failed: %u\n",
398 MESSAGE ("# average_put_path_length: %f\n",
400 MESSAGE ("# average_get_path_length: %f\n",
402
403 if (NULL == testbed_handles)
404 {
405 MESSAGE ("No peers found\n");
406 return;
407 }
408 /* Collect Stats*/
409 bandwidth_stats_op = GNUNET_TESTBED_get_statistics (n_active,
411 "core",
412 NULL,
415 NULL);
416}
static struct GNUNET_TESTBED_Peer ** testbed_handles
Testbed peer handles.
static unsigned long long n_puts_ok
Number of DHT PUTs succeeded.
static unsigned int n_gets_ok
Number of DHT GETs succeeded.
static int bandwidth_stats_iterator(void *cls, const struct GNUNET_TESTBED_Peer *peer, const char *subsystem, const char *name, uint64_t value, int is_persistent)
Process statistic values.
static double average_get_path_length
Average number of hops taken to do get.
static void bandwidth_stats_cont(void *cls, struct GNUNET_TESTBED_Operation *op, const char *emsg)
Stats callback.
static unsigned int n_gets_fail
Number of DHT GETs succeeded.
static unsigned long long n_puts
Number of DHT PUTs made.
static double average_put_path_length
Average number of hops taken to do put.
static unsigned int n_gets
Number of DHT GETs made.

References average_get_path_length, average_put_path_length, bandwidth_stats_cont(), bandwidth_stats_iterator(), bandwidth_stats_op, MESSAGE, n_active, n_gets, n_gets_fail, n_gets_ok, n_puts, n_puts_ok, and testbed_handles.

Referenced by cancel_get(), and get_iter().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ cancel_get()

static void cancel_get ( void *  cls)
static

Task to cancel DHT GET.

Parameters
clsNULL

Definition at line 425 of file gnunet_dht_profiler.c.

426{
427 struct ActiveContext *ac = cls;
428 struct Context *ctx = ac->ctx;
429
430 ac->delay_task = NULL;
431 GNUNET_assert (NULL != ac->dht_get);
433 ac->dht_get = NULL;
434 n_gets_fail++;
435 GNUNET_assert (NULL != ctx->op);
436 GNUNET_TESTBED_operation_done (ctx->op);
437 ctx->op = NULL;
438
439 /* If profiling is complete, summarize */
441 {
443 / (double) n_active;
445 / (double ) n_gets_ok;
446 summarize ();
447 }
448}
static unsigned int total_put_path_length
Total put path length across all peers.
static void summarize()
static unsigned int total_get_path_length
Total get path length across all peers.

References Context::ac, average_get_path_length, average_put_path_length, ctx, ActiveContext::ctx, ActiveContext::delay_task, ActiveContext::dht_get, GNUNET_assert, GNUNET_DHT_get_stop(), n_active, n_gets_fail, n_gets_ok, summarize(), total_get_path_length, and total_put_path_length.

Referenced by delayed_get().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ get_iter()

static void get_iter ( void *  cls,
struct GNUNET_TIME_Absolute  exp,
const struct GNUNET_HashCode key,
const struct GNUNET_PeerIdentity trunc_peer,
const struct GNUNET_DHT_PathElement get_path,
unsigned int  get_path_length,
const struct GNUNET_DHT_PathElement put_path,
unsigned int  put_path_length,
enum GNUNET_BLOCK_Type  type,
size_t  size,
const void *  data 
)
static

Iterator called on each result obtained for a DHT operation that expects a reply.

Parameters
clsclosure
expwhen will this value expire
keykey of the result
trunc_peerpeer the path was truncated at, or NULL
get_pathpeers on reply path (or NULL if not recorded) [0] = datastore's first neighbor, [length - 1] = local peer
get_path_lengthnumber of entries in get_path
put_pathpeers on the PUT path (or NULL if not recorded) [0] = origin, [length - 1] = datastore
put_path_lengthnumber of entries in put_path
typetype of the result
sizenumber of bytes in data
datapointer to the result data

Definition at line 470 of file gnunet_dht_profiler.c.

481{
482 struct ActiveContext *ac = cls;
483 struct ActiveContext *get_ac = ac->get_ac;
484 struct Context *ctx = ac->ctx;
485
486 /* we found the data we are looking for */
487 DEBUG ("We found a GET request; %u remaining\n",
488 n_gets - (n_gets_fail + n_gets_ok)); // FIXME: It always prints 1.
489 n_gets_ok++;
490 get_ac->nrefs--;
492 ac->dht_get = NULL;
493 if (ac->delay_task != NULL)
495 ac->delay_task = NULL;
496 GNUNET_assert (NULL != ctx->op);
497 GNUNET_TESTBED_operation_done (ctx->op);
498 ctx->op = NULL;
499
500 total_put_path_length = total_put_path_length + (double) put_path_length;
501 total_get_path_length = total_get_path_length + (double) get_path_length;
502 DEBUG ("total_put_path_length = %u,put_path \n",
504 /* Summarize if profiling is complete */
506 {
508 / (double) n_active;
510 / (double ) n_gets_ok;
511 summarize ();
512 }
513}
uint16_t nrefs
The number of peers currently doing GET on our data.
struct ActiveContext * get_ac
The active context used for our DHT GET.

References Context::ac, average_get_path_length, average_put_path_length, ctx, ActiveContext::ctx, DEBUG, ActiveContext::delay_task, ActiveContext::dht_get, ActiveContext::get_ac, GNUNET_assert, GNUNET_DHT_get_stop(), GNUNET_SCHEDULER_cancel(), n_active, n_gets, n_gets_fail, n_gets_ok, ActiveContext::nrefs, summarize(), total_get_path_length, and total_put_path_length.

Referenced by delayed_get().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ delayed_get()

static void delayed_get ( void *  cls)
static

Task to do DHT GETs.

Parameters
clsthe active context

Definition at line 522 of file gnunet_dht_profiler.c.

523{
524 struct ActiveContext *ac = cls;
525 struct ActiveContext *get_ac;
526 unsigned int r;
527
528 ac->delay_task = NULL;
529 get_ac = NULL;
530 while (1)
531 {
533 n_active);
534 get_ac = &a_ac[r];
535 if (NULL != get_ac->hash)
536 break;
537 }
538 get_ac->nrefs++;
539 ac->get_ac = get_ac;
542 DEBUG ("GET_REQUEST_START key %s \n",
543 GNUNET_h2s (&get_ac->hash[r]));
546 &get_ac->hash[r],
547 1, /* replication level */
549 NULL,
550 0, /* extended query and size */
551 &get_iter,
552 ac); /* GET iterator and closure */
553 n_gets++;
554
555 /* schedule the timeout task for GET */
557 &cancel_get,
558 ac);
559}
static void get_iter(void *cls, struct GNUNET_TIME_Absolute exp, const struct GNUNET_HashCode *key, const struct GNUNET_PeerIdentity *trunc_peer, const struct GNUNET_DHT_PathElement *get_path, unsigned int get_path_length, const struct GNUNET_DHT_PathElement *put_path, unsigned int put_path_length, enum GNUNET_BLOCK_Type type, size_t size, const void *data)
Iterator called on each result obtained for a DHT operation that expects a reply.
static void cancel_get(void *cls)
Task to cancel DHT GET.
static struct GNUNET_TIME_Relative timeout
The timeout for GET and PUT.
static unsigned int num_puts_per_peer
Number of DHT PUTs to be made per peer.
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
@ GNUNET_CRYPTO_QUALITY_WEAK
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
struct GNUNET_DHT_GetHandle * GNUNET_DHT_get_start(struct GNUNET_DHT_Handle *handle, enum GNUNET_BLOCK_Type type, const struct GNUNET_HashCode *key, uint32_t desired_replication_level, enum GNUNET_DHT_RouteOption options, const void *xquery, size_t xquery_size, GNUNET_DHT_GetIterator iter, void *iter_cls)
Perform an asynchronous GET operation on the DHT identified.
Definition: dht_api.c:1162
@ GNUNET_DHT_RO_NONE
Default.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
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:1272
@ GNUNET_BLOCK_TYPE_TEST
Block for testing.
struct GNUNET_DHT_Handle * dht
Handler to the DHT service.

References a_ac, cancel_get(), DEBUG, ActiveContext::delay_task, ActiveContext::dht, ActiveContext::dht_get, ActiveContext::get_ac, get_iter(), GNUNET_BLOCK_TYPE_TEST, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_DHT_get_start(), GNUNET_DHT_RO_NONE, GNUNET_h2s(), GNUNET_SCHEDULER_add_delayed(), ActiveContext::hash, n_active, n_gets, ActiveContext::nrefs, num_puts_per_peer, and timeout.

Referenced by dht_connected().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ delayed_put()

static void delayed_put ( void *  cls)
static

Task to do DHT PUTs.

If the "put_count" hits zero, we stop the TESTBED operation (connection to DHT) so that others PUTs have a chance.

Parameters
clsthe active context

Definition at line 599 of file gnunet_dht_profiler.c.

600{
601 struct ActiveContext *ac = cls;
602 char block[65536];
603 size_t block_size;
604
605 ac->delay_task = NULL;
606 if (0 == ac->put_count)
607 {
608 struct Context *ctx = ac->ctx;
609 struct GNUNET_TESTBED_Operation *op;
610
611 GNUNET_assert (NULL != ctx);
612 op = ctx->op;
613 ctx->op = NULL;
614 GNUNET_TESTBED_operation_done (op);
615 return;
616 }
617
618
619 /* Generate and DHT PUT some random data */
620 block_size = 16; /* minimum */
621 /* make random payload, reserve 512 - 16 bytes for DHT headers */
624 - 512);
626 block,
627 block_size);
628 ac->put_count--;
629 GNUNET_CRYPTO_hash (block,
630 block_size,
631 &ac->hash[ac->put_count]);
632 DEBUG ("PUT_REQUEST_START key %s\n",
633 GNUNET_h2s (&ac->hash[ac->put_count]));
634 ac->dht_put = GNUNET_DHT_put (ac->dht,
635 &ac->hash[ac->put_count],
639 block_size,
640 block,
641 GNUNET_TIME_UNIT_FOREVER_ABS, /* expiration time */
642 &put_cont,
643 ac); /* continuation and its closure */
644 n_puts++;
645}
static unsigned int replication
Replication degree.
static void put_cont(void *cls)
Conclude individual PUT operation, schedule the next one.
#define GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE
What is the maximum size for encrypted messages? Note that this number imposes a clear limit on the m...
void GNUNET_CRYPTO_random_block(enum GNUNET_CRYPTO_Quality mode, void *buffer, size_t length)
Fill block with a random values.
struct GNUNET_DHT_PutHandle * GNUNET_DHT_put(struct GNUNET_DHT_Handle *handle, const struct GNUNET_HashCode *key, uint32_t desired_replication_level, enum GNUNET_DHT_RouteOption options, enum GNUNET_BLOCK_Type type, size_t size, const void *data, struct GNUNET_TIME_Absolute exp, GNUNET_SCHEDULER_TaskCallback cont, void *cont_cls)
Perform a PUT operation storing data in the DHT.
Definition: dht_api.c:1088
@ GNUNET_DHT_RO_RECORD_ROUTE
We should keep track of the route that the message took in the P2P network.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
unsigned int put_count
How many puts should we still issue?

References Context::ac, ctx, ActiveContext::ctx, DEBUG, ActiveContext::delay_task, ActiveContext::dht, ActiveContext::dht_put, GNUNET_assert, GNUNET_BLOCK_TYPE_TEST, GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE, GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_block(), GNUNET_CRYPTO_random_u32(), GNUNET_DHT_put(), GNUNET_DHT_RO_RECORD_ROUTE, GNUNET_h2s(), GNUNET_TIME_UNIT_FOREVER_ABS, ActiveContext::hash, n_puts, op, put_cont(), ActiveContext::put_count, and replication.

Referenced by dht_connected(), and put_cont().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ put_cont()

static void put_cont ( void *  cls)
static

Conclude individual PUT operation, schedule the next one.

Parameters
clsthe active context

Definition at line 580 of file gnunet_dht_profiler.c.

581{
582 struct ActiveContext *ac = cls;
583
584 ac->dht_put = NULL;
585 n_puts_ok++;
587 ac);
588}
static void delayed_put(void *cls)
Task to do DHT PUTs.
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:1299

References ActiveContext::delay_task, delayed_put(), ActiveContext::dht_put, GNUNET_SCHEDULER_add_now(), and n_puts_ok.

Referenced by delayed_put().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ dht_connected()

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

Connection to DHT has been established.

Call the delay task.

Parameters
clsthe active context
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 658 of file gnunet_dht_profiler.c.

662{
663 struct ActiveContext *ac = cls;
664 struct Context *ctx = ac->ctx;
665
666 GNUNET_assert (NULL != ctx); // FIXME: Fails
667 GNUNET_assert (NULL != ctx->op);
668 GNUNET_assert (ctx->op == op);
669 ac->dht = (struct GNUNET_DHT_Handle *) ca_result;
670 if (NULL != emsg)
671 {
673 "Connection to DHT service failed: %s\n",
674 emsg);
675 GNUNET_TESTBED_operation_done (ctx->op); /* Calls dht_disconnect() */
676 ctx->op = NULL;
677 return;
678 }
679 switch (mode)
680 {
681 case MODE_PUT:
682 {
683 struct GNUNET_TIME_Relative peer_delay_put;
684
685 peer_delay_put.rel_value_us =
689 ac->hash = calloc (ac->put_count,
690 sizeof(struct GNUNET_HashCode));
691 if (NULL == ac->hash)
692 {
694 "calloc");
696 return;
697 }
698 ac->delay_task = GNUNET_SCHEDULER_add_delayed (peer_delay_put,
700 ac);
701 break;
702 }
703
704 case MODE_GET:
705 {
706 struct GNUNET_TIME_Relative peer_delay_get;
707
708 peer_delay_get.rel_value_us =
712 ac->delay_task = GNUNET_SCHEDULER_add_delayed (peer_delay_get,
714 ac);
715 break;
716 }
717 }
718}
static struct GNUNET_TIME_Relative delay_put
The delay to start puts.
static void delayed_get(void *cls)
Task to do DHT GETs.
static struct GNUNET_TIME_Relative delay_get
The delay to start puts.
uint64_t GNUNET_CRYPTO_random_u64(enum GNUNET_CRYPTO_Quality mode, uint64_t max)
Generate a random unsigned 64-bit value.
#define GNUNET_log(kind,...)
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
@ GNUNET_ERROR_TYPE_ERROR
Connection to the DHT service.
Definition: dht_api.c:235
A 512-bit hashcode.
Time for relative time used by GNUnet, in microseconds.
uint64_t rel_value_us
The actual value.

References Context::ac, ctx, ActiveContext::ctx, delay_get, delay_put, ActiveContext::delay_task, delayed_get(), delayed_put(), ActiveContext::dht, GNUNET_assert, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u64(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_log_strerror, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_shutdown(), ActiveContext::hash, mode, MODE_GET, MODE_PUT, num_puts_per_peer, op, ActiveContext::put_count, and GNUNET_TIME_Relative::rel_value_us.

Referenced by start_profiling().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ dht_connect()

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

Connect to DHT service and return the DHT client handler.

Parameters
clsthe active 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 731 of file gnunet_dht_profiler.c.

733{
734 n_dht++;
735 return GNUNET_DHT_connect (cfg,
736 10);
737}
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration.
static unsigned int n_dht
Number of DHT service connections we currently have.
struct GNUNET_DHT_Handle * GNUNET_DHT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, unsigned int ht_len)
Initialize the connection with the DHT service.
Definition: dht_api.c:1037

References cfg, GNUNET_DHT_connect(), and n_dht.

Referenced by start_profiling().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ dht_disconnect()

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

Adapter function called to destroy a connection to a service.

Parameters
clsthe active context
op_resultservice handle returned from the connect adapter

Definition at line 748 of file gnunet_dht_profiler.c.

750{
751 struct ActiveContext *ac = cls;
752
753 GNUNET_assert (NULL != ac->dht);
754 GNUNET_assert (ac->dht == op_result);
756 ac->dht = NULL;
757 n_dht--;
758 if (0 != n_dht)
759 return;
760 if (GNUNET_YES == in_shutdown)
761 return;
762 switch (mode)
763 {
764 case MODE_PUT:
765 if (n_puts_ok != ((unsigned long long) n_active) * num_puts_per_peer)
766 return;
767 /* Start GETs if all PUTs have been made */
768 mode = MODE_GET;
770 return;
771
772 case MODE_GET:
773 if ((n_gets_ok + n_gets_fail) != n_active)
774 return;
775 break;
776 }
777}
static void start_profiling(void)
Connect to DHT services of active peers.
void GNUNET_DHT_disconnect(struct GNUNET_DHT_Handle *handle)
Shutdown connection with the DHT service.
Definition: dht_api.c:1060
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:246

References ActiveContext::dht, GNUNET_assert, GNUNET_DHT_disconnect(), GNUNET_YES, in_shutdown, mode, MODE_GET, MODE_PUT, n_active, n_dht, n_gets_fail, n_gets_ok, n_puts_ok, num_puts_per_peer, op_result(), and start_profiling().

Referenced by start_profiling().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ service_started()

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

Callback called when DHT service on the peer is started.

Parameters
clsthe context
opthe operation that has been finished
emsgerror message in case the operation has failed; will be NULL if operation has executed successfully.

Definition at line 815 of file gnunet_dht_profiler.c.

818{
819 struct Context *ctx = cls;
820
821 GNUNET_assert (NULL != ctx);
822 GNUNET_assert (NULL != ctx->op);
823 GNUNET_TESTBED_operation_done (ctx->op);
824 ctx->op = NULL;
826 DEBUG ("Peers Started = %d; num_peers = %d \n",
828 num_peers);
831}
static int peers_started
Counter to keep track of peers added to peer_context lists.

References ctx, DEBUG, GNUNET_assert, num_peers, peers_started, and start_profiling().

Referenced by test_run().

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  num_peers,
struct GNUNET_TESTBED_Peer **  peers,
unsigned int  links_succeeded,
unsigned int  links_failed 
)
static

Signature of a main function for a testcase.

Parameters
clsclosure
hthe run handle
num_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

Definition at line 846 of file gnunet_dht_profiler.c.

852{
853 unsigned int ac_cnt;
854
856 if (NULL == peers)
857 {
858 /* exit */
859 GNUNET_assert (0);
860 }
861 MESSAGE ("%u peers started, %u/%u links up\n",
862 num_peers,
863 links_succeeded,
864 links_succeeded + links_failed);
866 struct Context);
867 /* select the peers which actively participate in profiling */
869 if (0 == n_active)
870 {
873 a_ctx = NULL;
874 return;
875 }
876
878 struct ActiveContext);
879 ac_cnt = 0;
880 for (unsigned int cnt = 0; cnt < num_peers && ac_cnt < n_active; cnt++)
881 {
883 100) >= put_probability)
884 continue;
885
886 a_ctx[cnt].ac = &a_ac[ac_cnt];
887 a_ac[ac_cnt].ctx = &a_ctx[cnt];
888 ac_cnt++;
889 }
890 n_active = ac_cnt;
891
892 /* start DHT service on all peers */
893 for (unsigned int cnt = 0; cnt < num_peers; cnt++)
894 {
895 a_ctx[cnt].peer = peers[cnt];
896 a_ctx[cnt].op = GNUNET_TESTBED_peer_manage_service (&a_ctx[cnt],
897 peers[cnt],
898 "dht",
900 &a_ctx[cnt],
901 1);
902 }
903}
struct GNUNET_CONTAINER_MultiPeerMap * peers
Map from PIDs to struct CadetPeer entries.
static void service_started(void *cls, struct GNUNET_TESTBED_Operation *op, const char *emsg)
Callback called when DHT service on the peer is started.
static unsigned int put_probability
Number of peers which should perform a PUT out of 100 peers.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
struct GNUNET_TESTBED_Peer * peer
The testbed peer this context belongs to.
struct GNUNET_TESTBED_Operation * op
Testbed operation acting on this peer.

References a_ac, a_ctx, Context::ac, ActiveContext::ctx, GNUNET_assert, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_free, GNUNET_new_array, GNUNET_SCHEDULER_shutdown(), MESSAGE, n_active, num_peers, Context::op, Context::peer, peers, put_probability, service_started(), and testbed_handles.

Referenced by run().

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 config 
)
static

Main function that will be run by the scheduler.

Parameters
clsclosure
argsremaining command-line arguments
cfgfilename of the configuration file used (for saving, can be NULL!)
configconfiguration

Definition at line 915 of file gnunet_dht_profiler.c.

919{
920 uint64_t event_mask;
921
922 if (0 == num_peers)
923 {
925 _ ("Exiting as the number of peers is %u\n"),
926 num_peers);
927 return;
928 }
929 cfg = config;
930 event_mask = 0;
931 GNUNET_TESTBED_run (hosts_file,
932 cfg,
933 num_peers,
935 NULL,
936 NULL,
937 &test_run,
938 NULL);
940 NULL);
941}
const struct GNUNET_CONFIGURATION_Handle * config
static uint64_t event_mask
Global event mask for all testbed events.
static void test_run(void *cls, struct GNUNET_TESTBED_RunHandle *h, unsigned int num_peers, struct GNUNET_TESTBED_Peer **peers, unsigned int links_succeeded, unsigned int links_failed)
Signature of a main function for a testcase.
static void do_shutdown(void *cls)
Shutdown task.
static char * hosts_file
Name of the file with the hosts to run the test over.
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,...
Definition: scheduler.c:1334
#define _(String)
GNU gettext support macro.
Definition: platform.h:178

References _, cfg, config, do_shutdown(), event_mask, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_SCHEDULER_add_shutdown(), hosts_file, num_peers, and test_run().

Referenced by main().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ main()

int main ( int  argc,
char *const *  argv 
)

Main function.

Returns
0 on success

Definition at line 950 of file gnunet_dht_profiler.c.

952{
953 int rc;
956 "peers",
957 "COUNT",
958 gettext_noop ("number of peers to start"),
959 &num_peers),
961 "peer-put-count",
962 "COUNT",
964 "number of PUTs to perform per peer"),
967 "hosts",
968 "FILENAME",
970 "name of the file with the login information for the testbed"),
971 &hosts_file),
973 "delay",
974 "DELAY",
976 "delay between rounds for collecting statistics (default: 30 sec)"),
977 &delay_stats),
979 "PUT-delay",
980 "DELAY",
982 "delay to start doing PUTs (default: 1 sec)"),
983 &delay_put),
985 "GET-delay",
986 "DELAY",
988 "delay to start doing GETs (default: 5 min)"),
989 &delay_get),
991 "replication",
992 "DEGREE",
993 gettext_noop ("replication degree for DHT PUTs"),
994 &replication),
996 "random-chance",
997 "PROBABILITY",
999 "chance that a peer is selected at random for PUTs"),
1002 "timeout",
1003 "TIMEOUT",
1004 gettext_noop (
1005 "timeout for DHT PUT and GET requests (default: 1 min)"),
1006 &timeout),
1008 };
1009
1010 if (GNUNET_OK !=
1011 GNUNET_STRINGS_get_utf8_args (argc, argv,
1012 &argc, &argv))
1013 return 2;
1014 /* set default delays */
1019 replication = 1; /* default replication */
1020 rc = 0;
1021 if (GNUNET_OK !=
1022 GNUNET_PROGRAM_run (argc,
1023 argv,
1024 "gnunet-dht-profiler",
1025 gettext_noop (
1026 "Measure quality and performance of the DHT service."),
1027 options,
1028 &run,
1029 NULL))
1030 rc = 1;
1031 return rc;
1032}
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
#define gettext_noop(String)
Definition: gettext.h:70
static struct GNUNET_TIME_Relative delay_stats
The delay between rounds for collecting statistics.
static void run(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *config)
Main function that will be run by the scheduler.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_uint(char shortName, const char *name, const char *argumentHelp, const char *description, unsigned int *val)
Allow user to specify an unsigned int.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_relative_time(char shortName, const char *name, const char *argumentHelp, const char *description, struct GNUNET_TIME_Relative *val)
Allow user to specify a struct GNUNET_TIME_Relative (using human-readable "fancy" time).
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_string(char shortName, const char *name, const char *argumentHelp, const char *description, char **str)
Allow user to specify a string.
enum GNUNET_GenericReturnValue GNUNET_PROGRAM_run(int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
Run a standard GNUnet command startup sequence (initialize loggers and configuration,...
Definition: program.c:400
enum GNUNET_GenericReturnValue GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1230
#define GNUNET_TIME_UNIT_SECONDS
One second.
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:484
Definition of a command line option.

References delay_get, delay_put, delay_stats, gettext_noop, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_relative_time(), GNUNET_GETOPT_option_string(), GNUNET_GETOPT_option_uint(), GNUNET_OK, GNUNET_PROGRAM_run(), GNUNET_STRINGS_get_utf8_args(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_SECONDS, hosts_file, num_peers, num_puts_per_peer, options, put_probability, replication, run(), and timeout.

Here is the call graph for this function:

Variable Documentation

◆ put_probability

unsigned int put_probability = 100
static

Number of peers which should perform a PUT out of 100 peers.

Definition at line 43 of file gnunet_dht_profiler.c.

Referenced by main(), and test_run().

◆ cfg

const struct GNUNET_CONFIGURATION_Handle* cfg
static

Configuration.

Definition at line 48 of file gnunet_dht_profiler.c.

Referenced by dht_connect(), and run().

◆ hosts_file

char* hosts_file
static

Name of the file with the hosts to run the test over.

Definition at line 53 of file gnunet_dht_profiler.c.

Referenced by main(), and run().

◆ a_ctx

struct Context* a_ctx
static

An array of contexts.

The size of this array should be equal to num_peers

Definition at line 138 of file gnunet_dht_profiler.c.

Referenced by do_shutdown(), and test_run().

◆ a_ac

struct ActiveContext* a_ac
static

Array of active peers.

Definition at line 143 of file gnunet_dht_profiler.c.

Referenced by delayed_get(), do_shutdown(), start_profiling(), and test_run().

◆ delay_stats

struct GNUNET_TIME_Relative delay_stats
static

The delay between rounds for collecting statistics.

Definition at line 148 of file gnunet_dht_profiler.c.

Referenced by main().

◆ delay_put

struct GNUNET_TIME_Relative delay_put
static

The delay to start puts.

Definition at line 153 of file gnunet_dht_profiler.c.

Referenced by dht_connected(), and main().

◆ delay_get

struct GNUNET_TIME_Relative delay_get
static

The delay to start puts.

Definition at line 158 of file gnunet_dht_profiler.c.

Referenced by dht_connected(), and main().

◆ timeout

struct GNUNET_TIME_Relative timeout
static

The timeout for GET and PUT.

Definition at line 163 of file gnunet_dht_profiler.c.

Referenced by delayed_get(), and main().

◆ num_peers

◆ n_active

unsigned int n_active
static

Number of active peers.

Definition at line 173 of file gnunet_dht_profiler.c.

Referenced by cancel_get(), delayed_get(), dht_disconnect(), get_iter(), start_profiling(), summarize(), and test_run().

◆ n_dht

unsigned int n_dht
static

Number of DHT service connections we currently have.

Definition at line 178 of file gnunet_dht_profiler.c.

Referenced by dht_connect(), and dht_disconnect().

◆ n_puts

unsigned long long n_puts
static

Number of DHT PUTs made.

Definition at line 183 of file gnunet_dht_profiler.c.

Referenced by delayed_put(), and summarize().

◆ num_puts_per_peer

unsigned int num_puts_per_peer = 1
static

Number of DHT PUTs to be made per peer.

Definition at line 188 of file gnunet_dht_profiler.c.

Referenced by delayed_get(), dht_connected(), dht_disconnect(), and main().

◆ n_puts_ok

unsigned long long n_puts_ok
static

Number of DHT PUTs succeeded.

Definition at line 193 of file gnunet_dht_profiler.c.

Referenced by dht_disconnect(), put_cont(), and summarize().

◆ n_gets

unsigned int n_gets
static

Number of DHT GETs made.

Definition at line 198 of file gnunet_dht_profiler.c.

Referenced by delayed_get(), get_iter(), and summarize().

◆ n_gets_ok

unsigned int n_gets_ok
static

Number of DHT GETs succeeded.

Definition at line 203 of file gnunet_dht_profiler.c.

Referenced by cancel_get(), dht_disconnect(), get_iter(), and summarize().

◆ n_gets_fail

unsigned int n_gets_fail
static

Number of DHT GETs succeeded.

Definition at line 208 of file gnunet_dht_profiler.c.

Referenced by cancel_get(), dht_disconnect(), get_iter(), and summarize().

◆ replication

unsigned int replication
static

Replication degree.

Definition at line 213 of file gnunet_dht_profiler.c.

Referenced by delayed_put(), and main().

◆ bandwidth_stats_op

struct GNUNET_TESTBED_Operation* bandwidth_stats_op
static

Testbed Operation (to get stats).

Definition at line 218 of file gnunet_dht_profiler.c.

Referenced by do_shutdown(), and summarize().

◆ testbed_handles

struct GNUNET_TESTBED_Peer** testbed_handles
static

Testbed peer handles.

Definition at line 223 of file gnunet_dht_profiler.c.

Referenced by summarize(), and test_run().

◆ outgoing_bandwidth

uint64_t outgoing_bandwidth
static

Total number of messages sent by peer.

Definition at line 228 of file gnunet_dht_profiler.c.

Referenced by bandwidth_stats_cont(), and bandwidth_stats_iterator().

◆ incoming_bandwidth

uint64_t incoming_bandwidth
static

Total number of messages received by peer.

Definition at line 233 of file gnunet_dht_profiler.c.

Referenced by bandwidth_stats_cont(), and bandwidth_stats_iterator().

◆ average_put_path_length

double average_put_path_length
static

Average number of hops taken to do put.

Definition at line 238 of file gnunet_dht_profiler.c.

Referenced by cancel_get(), get_iter(), and summarize().

◆ average_get_path_length

double average_get_path_length
static

Average number of hops taken to do get.

Definition at line 243 of file gnunet_dht_profiler.c.

Referenced by cancel_get(), get_iter(), and summarize().

◆ total_put_path_length

unsigned int total_put_path_length
static

Total put path length across all peers.

Definition at line 248 of file gnunet_dht_profiler.c.

Referenced by cancel_get(), and get_iter().

◆ total_get_path_length

unsigned int total_get_path_length
static

Total get path length across all peers.

Definition at line 253 of file gnunet_dht_profiler.c.

Referenced by cancel_get(), and get_iter().

◆ peers_started

int peers_started = 0
static

Counter to keep track of peers added to peer_context lists.

Definition at line 258 of file gnunet_dht_profiler.c.

Referenced by service_started().

◆ 

◆ in_shutdown

int in_shutdown = 0
static

Are we shutting down.

Definition at line 274 of file gnunet_dht_profiler.c.

Referenced by dht_disconnect(), do_shutdown(), and start_profiling().