gnunet-transport-profiler.c File Reference

Tool to help benchmark the transport subsystem. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_ats_service.h"
#include "gnunet_transport_service.h"

Include dependency graph for gnunet-transport-profiler.c:

Go to the source code of this file.

Data Structures
struct	Iteration

Macros
#define	CONNECT_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
	Timeout for a connections. More...
#define	DEFAULT_MESSAGE_SIZE   1024
	Benchmarking block size in bye. More...
#define	DEFAULT_MESSAGE_COUNT   1024
	Benchmarking message count. More...
#define	DEFAULT_ITERATION_COUNT   1
	Benchmarking iteration count. More...

Functions
static void	shutdown_task (void *cls)
	Task run in monitor mode when the user presses CTRL-C to abort. More...
static void	iteration_done ()
static void	send_msg (void *cls)
	Function called to notify a client about the socket begin ready to queue more data. More...
static void	iteration_start ()
static void *	notify_connect (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *m)
	Function called to notify transport users that another peer connected to us. More...
static void	notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer, void *internal_cls)
	Function called to notify transport users that another peer disconnected from us. More...
static int	check_dummy (void *cls, const struct GNUNET_MessageHeader *message)
	Function called by the transport for each received message. More...
static void	handle_dummy (void *cls, const struct GNUNET_MessageHeader *message)
	Function called by the transport for each received message. More...
static int	blacklist_cb (void *cls, const struct GNUNET_PeerIdentity *peer)
static void	run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *mycfg)
	Main function that will be run by the scheduler. More...
int	main (int argc, char *const *argv)

Variables
static int	benchmark_send
	Option -s. More...
static int	benchmark_receive
	Option -b. More...
static unsigned int	benchmark_count
	Option -n. More...
static unsigned int	benchmark_iterations
	Option -i. More...
static unsigned int	benchmark_size
	Option -m. More...
static unsigned int	benchmark_running
	Benchmark running. More...
static char *	cpid
	Which peer should we connect to? More...
static struct GNUNET_TRANSPORT_CoreHandle *	handle
	Handle to transport service. More...
static struct GNUNET_ATS_ConnectivityHandle *	ats
	Handle to ATS service. More...
static struct GNUNET_CONFIGURATION_Handle *	cfg
	Configuration handle. More...
static struct GNUNET_ATS_ConnectivitySuggestHandle *	ats_sh
	Try_connect handle. More...
static struct Iteration *	ihead
static struct Iteration *	itail
static int	ret
	Global return value (0 success). More...
static struct GNUNET_MQ_Handle *	mq
	Handle for transmissions. More...
static struct GNUNET_TRANSPORT_Blacklist *	bl_handle
static struct GNUNET_PeerIdentity	pid
	Identity of the peer we transmit to / connect to. More...
static unsigned int	verbosity
	Selected level of verbosity. More...

Detailed Description

Tool to help benchmark the transport subsystem.

Author

Christian Grothoff

Nathan Evans

This utility can be used to benchmark a transport mechanism for GNUnet.

Definition in file gnunet-transport-profiler.c.

Macro Definition Documentation

CONNECT_TIMEOUT

#define CONNECT_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)

Timeout for a connections.

Definition at line 56 of file gnunet-transport-profiler.c.

DEFAULT_MESSAGE_SIZE

#define DEFAULT_MESSAGE_SIZE   1024

Benchmarking block size in bye.

Definition at line 62 of file gnunet-transport-profiler.c.

DEFAULT_MESSAGE_COUNT

#define DEFAULT_MESSAGE_COUNT   1024

Benchmarking message count.

Definition at line 67 of file gnunet-transport-profiler.c.

DEFAULT_ITERATION_COUNT

#define DEFAULT_ITERATION_COUNT   1

Benchmarking iteration count.

Definition at line 72 of file gnunet-transport-profiler.c.

Function Documentation

shutdown_task()

static void shutdown_task ( void *  cls )

static

Task run in monitor mode when the user presses CTRL-C to abort.

Stops monitoring activity.

Parameters

cls

NULL

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

{
  struct Iteration *icur;
  struct Iteration *inext;
 
  unsigned int iterations;
 
  unsigned long long avg_duration;
  float avg_rate;
  float stddev_rate;
  float stddev_duration;
 
  if (NULL != ats_sh)
  {
    GNUNET_ATS_connectivity_suggest_cancel (ats_sh);
    ats_sh = NULL;
  }
  if (NULL != bl_handle)
  {
    GNUNET_TRANSPORT_blacklist_cancel (bl_handle);
    bl_handle = NULL;
  }
  if (NULL != ats)
  {
    GNUNET_ATS_connectivity_done (ats);
    ats = NULL;
  }
  if (NULL != handle)
  {
    GNUNET_TRANSPORT_core_disconnect (handle);
    handle = NULL;
  }
 
  if (verbosity > 0)
    fprintf (stdout, "\n");
 
  /* Output format:
   * All time values in ms
   * Rate in KB/s
   * #messages;#messagesize;#avg_dur;#avg_rate;#duration_i0;#duration_i0;... */
 
  if (benchmark_send)
  {
    /* First iteration to calculate avg and stddev */
    iterations = 0;
    avg_duration = 0;
    avg_rate = 0.0;
 
    inext = ihead;
    while (NULL != (icur = inext))
    {
      inext = icur->next;
      icur->rate = ((benchmark_count * benchmark_size) / 1024)
                   / ((float) icur->dur.rel_value_us / (1000 * 1000));
      if (verbosity > 0)
        fprintf (stdout,
                 _ ("%llu B in %llu ms == %.2f KB/s!\n"),
                 ((long long unsigned int) benchmark_count * benchmark_size),
                 ((long long unsigned int) icur->dur.rel_value_us / 1000),
                 (float) icur->rate);
 
      avg_duration += icur->dur.rel_value_us / (1000);
      avg_rate += icur->rate;
      iterations++;
    }
    if (0 == iterations)
      iterations = 1;   /* avoid division by zero */
    /* Calculate average rate */
    avg_rate /= iterations;
    /* Calculate average duration */
    avg_duration /= iterations;
 
    stddev_rate = 0;
    stddev_duration = 0;
    inext = ihead;
    while (NULL != (icur = inext))
    {
      inext = icur->next;
      stddev_rate += ((icur->rate - avg_rate) * (icur->rate - avg_rate));
      stddev_duration += (((icur->dur.rel_value_us / 1000) - avg_duration)
                          * ((icur->dur.rel_value_us / 1000) - avg_duration));
    }
    /* Calculate standard deviation rate */
    stddev_rate = stddev_rate / iterations;
    stddev_rate = sqrtf (stddev_rate);
 
    /* Calculate standard deviation duration */
    stddev_duration = stddev_duration / iterations;
    stddev_duration = sqrtf (stddev_duration);
 
    /* Output */
    fprintf (stdout,
             "%u;%u;%llu;%llu;%.2f;%.2f",
             benchmark_count,
             benchmark_size,
             avg_duration,
             (unsigned long long) stddev_duration,
             avg_rate,
             stddev_rate);
 
    inext = ihead;
    while (NULL != (icur = inext))
    {
      inext = icur->next;
      GNUNET_CONTAINER_DLL_remove (ihead, itail, icur);
 
      fprintf (stdout,
               ";%llu;%.2f",
               (long long unsigned int) (icur->dur.rel_value_us / 1000),
               icur->rate);
 
      GNUNET_free (icur);
    }
  }
#if 0
  if (benchmark_receive)
  {
    duration = GNUNET_TIME_absolute_get_duration (start_time);
    fprintf (stdout,
             "Received %llu bytes/s (%llu bytes in %s)\n",
             1000LL * 1000LL * traffic_received / (1 + duration.rel_value_us),
             traffic_received,
             GNUNET_STRINGS_relative_time_to_string (duration, GNUNET_YES));
  }
#endif
  fprintf (stdout, "\n");
}

References _, ats, ats_sh, benchmark_count, benchmark_receive, benchmark_send, benchmark_size, bl_handle, Iteration::dur, duration, GNUNET_ATS_connectivity_done(), GNUNET_ATS_connectivity_suggest_cancel(), GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_duration(), GNUNET_TRANSPORT_blacklist_cancel(), GNUNET_TRANSPORT_core_disconnect(), GNUNET_YES, handle, ihead, itail, Iteration::next, Iteration::rate, GNUNET_TIME_Relative::rel_value_us, start_time, traffic_received, and verbosity.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

iteration_done()

static void iteration_done ( )

static

Definition at line 356 of file gnunet-transport-profiler.c.

{
  static int it_count = 0;
 
  it_count++;
  itail->dur = GNUNET_TIME_absolute_get_duration (itail->start);
  if (it_count == benchmark_iterations)
  {
    benchmark_running = GNUNET_NO;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  iteration_start ();
}

References benchmark_iterations, benchmark_running, Iteration::dur, GNUNET_NO, GNUNET_SCHEDULER_shutdown(), GNUNET_TIME_absolute_get_duration(), itail, iteration_start(), and Iteration::start.

Referenced by send_msg().

Here is the call graph for this function:

Here is the caller graph for this function:

send_msg()

static void send_msg ( void *  cls )

static

Function called to notify a client about the socket begin ready to queue more data.

buf will be NULL and size zero if the socket was closed for writing in the meantime.

Parameters

cls	closure
size	number of bytes available in buf
buf	where the callee should write the message

Returns

number of bytes written to buf

Definition at line 309 of file gnunet-transport-profiler.c.

{
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *m;
 
  if (NULL == mq)
    return;
  env = GNUNET_MQ_msg_extra (m, benchmark_size, GNUNET_MESSAGE_TYPE_DUMMY);
  memset (&m[1], 52, benchmark_size - sizeof(struct GNUNET_MessageHeader));
 
  if (itail->msgs_sent < benchmark_count)
  {
    GNUNET_MQ_notify_sent (env, &send_msg, NULL);
  }
  else
  {
    iteration_done ();
  }
  GNUNET_MQ_send (mq, env);
  if ((verbosity > 0) && (0 == itail->msgs_sent % 10))
    fprintf (stdout, ".");
}

References benchmark_count, benchmark_size, env, GNUNET_MESSAGE_TYPE_DUMMY, GNUNET_MQ_msg_extra, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), itail, iteration_done(), m, mq, Iteration::msgs_sent, and verbosity.

Referenced by iteration_start(), and reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

iteration_start()

static void iteration_start ( )

static

Definition at line 334 of file gnunet-transport-profiler.c.

{
  struct Iteration *icur;
 
  ret = 0;
  if (! benchmark_send)
    return;
  benchmark_running = GNUNET_YES;
  icur = GNUNET_new (struct Iteration);
  GNUNET_CONTAINER_DLL_insert_tail (ihead, itail, icur);
  icur->start = GNUNET_TIME_absolute_get ();
  if (verbosity > 0)
    fprintf (
      stdout,
      "\nStarting benchmark, starting to send %u messages in %u byte blocks\n",
      benchmark_count,
      benchmark_size);
  send_msg (NULL);
}

References benchmark_count, benchmark_running, benchmark_send, benchmark_size, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_new, GNUNET_TIME_absolute_get(), GNUNET_YES, ihead, itail, ret, send_msg(), Iteration::start, and verbosity.

Referenced by iteration_done(), and notify_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

notify_connect()

static void* notify_connect ( void *  cls, const struct GNUNET_PeerIdentity *  peer, struct GNUNET_MQ_Handle *  m  )

static

Function called to notify transport users that another peer connected to us.

Parameters

cls	closure
peer	the peer that connected
m	message queue for transmissions

Returns

NULL

Definition at line 382 of file gnunet-transport-profiler.c.

{
  if (0 != memcmp (&pid, peer, sizeof(struct GNUNET_PeerIdentity)))
  {
    fprintf (stdout, "Connected to different peer `%s'\n", GNUNET_i2s (&pid));
    return NULL;
  }
 
  if (verbosity > 0)
    fprintf (stdout, "Successfully connected to `%s'\n", GNUNET_i2s (&pid));
  mq = m;
  iteration_start ();
  return NULL;
}

References GNUNET_i2s(), iteration_start(), m, mq, peer, pid, and verbosity.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

notify_disconnect()

static void notify_disconnect ( void *  cls, const struct GNUNET_PeerIdentity *  peer, void *  internal_cls  )

static

Function called to notify transport users that another peer disconnected from us.

Parameters

cls	closure
peer	the peer that disconnected
internal_cls	NULL

Definition at line 409 of file gnunet-transport-profiler.c.

{
  if (0 != memcmp (&pid, peer, sizeof(struct GNUNET_PeerIdentity)))
    return;
  mq = NULL;
  if (GNUNET_YES == benchmark_running)
  {
    fprintf (stdout,
             "Disconnected from peer `%s' while benchmarking\n",
             GNUNET_i2s (&pid));
    return;
  }
}

References benchmark_running, GNUNET_i2s(), GNUNET_YES, mq, peer, and pid.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

check_dummy()

static int check_dummy ( void *  cls, const struct GNUNET_MessageHeader *  message  )

static

Function called by the transport for each received message.

Parameters

cls	closure
message	the message

Returns

GNUNET_OK

Definition at line 434 of file gnunet-transport-profiler.c.

{
  return GNUNET_OK; /* all messages are fine */
}

References GNUNET_OK.

handle_dummy()

static void handle_dummy ( void *  cls, const struct GNUNET_MessageHeader *  message  )

static

Function called by the transport for each received message.

Parameters

cls	closure
message	the message

Definition at line 447 of file gnunet-transport-profiler.c.

{
  if (! benchmark_receive)
    return;
  if (verbosity > 0)
    fprintf (stdout,
             "Received %u bytes\n",
             (unsigned int) ntohs (message->size));
}

References benchmark_receive, GNUNET_MessageHeader::size, and verbosity.

blacklist_cb()

static int blacklist_cb ( void *  cls, const struct GNUNET_PeerIdentity *  peer  )

static

Definition at line 459 of file gnunet-transport-profiler.c.

{
  if (0 != memcmp (&pid, peer, sizeof(struct GNUNET_PeerIdentity)))
  {
    if (verbosity > 0)
      fprintf (stdout, "Denying connection to `%s'\n", GNUNET_i2s (peer));
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_i2s(), GNUNET_OK, GNUNET_SYSERR, peer, pid, and verbosity.

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 *  mycfg  )

static

Main function that will be run by the scheduler.

Parameters

cls	closure
args	remaining command-line arguments
cfgfile	name of the configuration file used (for saving, can be NULL!)
mycfg	configuration

Definition at line 480 of file gnunet-transport-profiler.c.

{
  struct GNUNET_MQ_MessageHandler handlers[] =
  { GNUNET_MQ_hd_var_size (dummy,
                           GNUNET_MESSAGE_TYPE_DUMMY,
                           struct GNUNET_MessageHeader,
                           NULL),
    GNUNET_MQ_handler_end () };
 
  cfg = (struct GNUNET_CONFIGURATION_Handle *) mycfg;
 
  ret = 1;
  if (GNUNET_MAX_MESSAGE_SIZE <= benchmark_size)
  {
    fprintf (stderr, "Message size too big!\n");
    return;
  }
 
  if (NULL == cpid)
  {
    fprintf (stderr, "No peer identity given\n");
    return;
  }
  if (GNUNET_OK != GNUNET_CRYPTO_eddsa_public_key_from_string (cpid,
                                                               strlen (cpid),
                                                               &pid.public_key))
  {
    fprintf (stderr, "Failed to parse peer identity `%s'\n", cpid);
    return;
  }
  if (1 == benchmark_send)
  {
    if (verbosity > 0)
      fprintf (stderr,
               "Trying to send %u messages with size %u to peer `%s'\n",
               benchmark_count,
               benchmark_size,
               GNUNET_i2s (&pid));
  }
  else if (1 == benchmark_receive)
  {
    fprintf (stderr,
             "Trying to receive messages from peer `%s'\n",
             GNUNET_i2s (&pid));
  }
  else
  {
    fprintf (stderr, "No operation given\n");
    return;
  }
 
  ats = GNUNET_ATS_connectivity_init (cfg);
  if (NULL == ats)
  {
    fprintf (stderr, "Failed to connect to ATS service\n");
    ret = 1;
    return;
  }
 
  handle = GNUNET_TRANSPORT_core_connect (cfg,
                                          NULL,
                                          handlers,
                                          NULL,
                                          &notify_connect,
                                          &notify_disconnect,
                                          NULL);
  if (NULL == handle)
  {
    fprintf (stderr, "Failed to connect to transport service\n");
    GNUNET_ATS_connectivity_done (ats);
    ats = NULL;
    ret = 1;
    return;
  }
 
  bl_handle = GNUNET_TRANSPORT_blacklist (cfg, &blacklist_cb, NULL);
  ats_sh = GNUNET_ATS_connectivity_suggest (ats, &pid, 1);
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
}

References ats, ats_sh, benchmark_count, benchmark_receive, benchmark_send, benchmark_size, bl_handle, blacklist_cb(), cfg, cpid, dummy, GNUNET_ATS_connectivity_done(), GNUNET_ATS_connectivity_init(), GNUNET_ATS_connectivity_suggest(), GNUNET_CRYPTO_eddsa_public_key_from_string(), GNUNET_i2s(), GNUNET_MAX_MESSAGE_SIZE, GNUNET_MESSAGE_TYPE_DUMMY, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_OK, GNUNET_SCHEDULER_add_shutdown(), GNUNET_TRANSPORT_blacklist(), GNUNET_TRANSPORT_core_connect(), handle, handlers, notify_connect(), notify_disconnect(), pid, GNUNET_PeerIdentity::public_key, ret, shutdown_task(), and verbosity.

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
	)

Definition at line 565 of file gnunet-transport-profiler.c.

{
  int res;
 
  benchmark_count = DEFAULT_MESSAGE_COUNT;
  benchmark_size = DEFAULT_MESSAGE_SIZE;
  benchmark_iterations = DEFAULT_ITERATION_COUNT;
  benchmark_running = GNUNET_NO;
 
  struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_option_flag ('s',
                               "send",
                               gettext_noop ("send data to peer"),
                               &benchmark_send),
    GNUNET_GETOPT_option_flag ('r',
                               "receive",
                               gettext_noop ("receive data from peer"),
                               &benchmark_receive),
    GNUNET_GETOPT_option_uint ('i',
                               "iterations",
                               NULL,
                               gettext_noop ("iterations"),
                               &benchmark_iterations),
    GNUNET_GETOPT_option_uint ('n',
                               "number",
                               NULL,
                               gettext_noop ("number of messages to send"),
                               &benchmark_count),
    GNUNET_GETOPT_option_uint ('m',
                               "messagesize",
                               NULL,
                               gettext_noop ("message size to use"),
                               &benchmark_size),
    GNUNET_GETOPT_option_string ('p',
                                 "peer",
                                 "PEER",
                                 gettext_noop ("peer identity"),
                                 &cpid),
    GNUNET_GETOPT_option_verbose (&verbosity),
    GNUNET_GETOPT_OPTION_END
  };
 
  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
    return 2;
 
  res =
    GNUNET_PROGRAM_run (argc,
                        argv,
                        "gnunet-transport",
                        gettext_noop ("Direct access to transport service."),
                        options,
                        &run,
                        NULL);
  GNUNET_free_nz ((void *) argv);
  if (GNUNET_OK == res)
    return ret;
  return 1;
}

References benchmark_count, benchmark_iterations, benchmark_receive, benchmark_running, benchmark_send, benchmark_size, cpid, DEFAULT_ITERATION_COUNT, DEFAULT_MESSAGE_COUNT, DEFAULT_MESSAGE_SIZE, gettext_noop, GNUNET_free_nz, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_flag(), GNUNET_GETOPT_option_string(), GNUNET_GETOPT_option_uint(), GNUNET_GETOPT_option_verbose(), GNUNET_NO, GNUNET_OK, GNUNET_PROGRAM_run(), GNUNET_STRINGS_get_utf8_args(), options, res, ret, run(), and verbosity.

Here is the call graph for this function:

Variable Documentation

benchmark_send

int benchmark_send

static

Option -s.

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

Referenced by iteration_start(), main(), run(), and shutdown_task().

benchmark_receive

int benchmark_receive

static

Option -b.

Definition at line 82 of file gnunet-transport-profiler.c.

Referenced by handle_dummy(), main(), run(), and shutdown_task().

benchmark_count

unsigned int benchmark_count

static

Option -n.

Definition at line 87 of file gnunet-transport-profiler.c.

Referenced by iteration_start(), main(), run(), send_msg(), and shutdown_task().

benchmark_iterations

unsigned int benchmark_iterations

static

Option -i.

Definition at line 92 of file gnunet-transport-profiler.c.

Referenced by iteration_done(), and main().

benchmark_size

unsigned int benchmark_size

static

Option -m.

Definition at line 97 of file gnunet-transport-profiler.c.

Referenced by iteration_start(), main(), run(), send_msg(), and shutdown_task().

benchmark_running

unsigned int benchmark_running

static

Benchmark running.

Definition at line 102 of file gnunet-transport-profiler.c.

Referenced by iteration_done(), iteration_start(), main(), and notify_disconnect().

cpid

char* cpid

static

Which peer should we connect to?

Definition at line 107 of file gnunet-transport-profiler.c.

Referenced by blacklist_cb(), main(), and run().

handle

struct GNUNET_TRANSPORT_CoreHandle* handle

static

Handle to transport service.

Definition at line 112 of file gnunet-transport-profiler.c.

Referenced by run(), and shutdown_task().

ats

struct GNUNET_ATS_ConnectivityHandle* ats

static

Handle to ATS service.

Definition at line 117 of file gnunet-transport-profiler.c.

Referenced by run(), and shutdown_task().

cfg

struct GNUNET_CONFIGURATION_Handle* cfg

static

Configuration handle.

Definition at line 122 of file gnunet-transport-profiler.c.

Referenced by run().

ats_sh

struct GNUNET_ATS_ConnectivitySuggestHandle* ats_sh

static

Try_connect handle.

Definition at line 127 of file gnunet-transport-profiler.c.

Referenced by run(), and shutdown_task().

ihead

struct Iteration* ihead

static

Definition at line 129 of file gnunet-transport-profiler.c.

Referenced by iteration_start(), and shutdown_task().

itail

struct Iteration* itail

static

Definition at line 131 of file gnunet-transport-profiler.c.

Referenced by iteration_done(), iteration_start(), send_msg(), and shutdown_task().

ret

int ret

static

Global return value (0 success).

Definition at line 136 of file gnunet-transport-profiler.c.

Referenced by iteration_start(), main(), and run().

mq

struct GNUNET_MQ_Handle* mq

static

Handle for transmissions.

Definition at line 141 of file gnunet-transport-profiler.c.

Referenced by notify_connect(), notify_disconnect(), and send_msg().

bl_handle

struct GNUNET_TRANSPORT_Blacklist* bl_handle

static

Definition at line 143 of file gnunet-transport-profiler.c.

Referenced by run(), and shutdown_task().

pid

struct GNUNET_PeerIdentity pid

static

Identity of the peer we transmit to / connect to.

(equivalent to 'cpid' string).

Definition at line 143 of file gnunet-transport-profiler.c.

Referenced by add_valid_address(), blacklist_cb(), blacklist_check(), check_access(), check_connection_quality(), check_hello(), check_known_address(), check_known_challenge(), check_validation_request_pending(), consider_for_advertising(), consider_peer_for_forwarding(), core_send_connect_info(), cores_send_connect_info(), cores_send_disconnect_info(), create_target(), cummulative_ack(), db_read_whitelist(), detach_terminal(), do_transmit(), dv_neighbour_selection(), dv_neighbour_transmission(), find_list_tunnels(), find_peer_by_pid(), find_queue(), find_target(), flush_respect(), fork_and_exec(), free_ack_cummulator_cb(), free_backtalker_cb(), free_dv_routes_cb(), free_matching_requests(), free_neighbour_cb(), free_peer(), free_request(), free_validation_state_cb(), GAS_plugin_request_connect_start(), GAS_plugin_request_connect_stop(), GCPP_try_path_from_dht(), GDS_NEIGHBOURS_handle_get(), GDS_try_connect(), GDS_u_connect(), GDS_u_try_connect(), get_idx_of_pid(), gns_resolve_name(), GNUNET_CORE_get_mq(), GNUNET_FRIENDS_parse(), GNUNET_HELLO_builder_from_url(), GNUNET_HELLO_builder_new(), GNUNET_HELLO_extract_address(), GNUNET_i2s(), GNUNET_i2s2(), GNUNET_i2s_full(), GNUNET_PEER_intern(), GNUNET_PEER_resolve(), GNUNET_PEER_search(), GNUNET_TRANSPORT_communicator_notify(), gnunet_try_connect(), GSC_SESSIONS_end(), GSC_SESSIONS_solicit(), GST_validation_handle_hello(), handle_ack(), handle_dht_local_hello_offer(), handle_friend(), handle_hello(), handle_p2p_put(), handle_remote_overlay_connect(), handle_search_response(), handle_transport_notify_connect(), handle_transport_notify_excess_bw(), handshake_ack_monotime_cb(), handshake_monotime_cb(), ip_try_connect(), logger_run(), lookup_neighbour(), lookup_virtual_link(), main(), maint_child_death(), netjail_stop_run(), notify_client_connect_info(), notify_client_queues(), notify_connect(), notify_disconnect(), read_cb(), rekey_monotime_cb(), run(), save_list_tunnels(), setup_cipher(), show_peer(), start_address_validation(), start_helper(), stop_peer_request(), suggest_to_connect(), transmit_ping_if_allowed(), update_ax_by_kx(), update_friend_hello(), write_benchmark_data(), and write_pid_file().

verbosity

unsigned int verbosity

static

Selected level of verbosity.

Definition at line 154 of file gnunet-transport-profiler.c.

Referenced by blacklist_cb(), handle_dummy(), iteration_start(), main(), notify_connect(), run(), send_msg(), and shutdown_task().