gnunet-nse-profiler.c File Reference

Profiling driver for the network size estimation service. More...

#include "platform.h"
#include "gnunet_testbed_service.h"
#include "gnunet_nse_service.h"

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

Go to the source code of this file.

Data Structures
struct	NSEPeer
	Information we track for a peer in the testbed. More...
struct	OpListEntry
	Operation map entry. More...

Macros
#define	LOG(kind, ...)   GNUNET_log (kind, __VA_ARGS__)
	Generic loggins shorthand. More...
#define	LOG_DEBUG(...)   LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
	Debug logging shorthand. More...

Functions
static void	close_monitor_connections ()
	Clean up all of the monitoring connections to NSE and STATISTICS that we keep to selected peers. More...
static void	shutdown_task (void *cls)
	Task run on shutdown; cleans up everything. More...
static void	handle_estimate (void *cls, struct GNUNET_TIME_Absolute timestamp, double estimate, double std_dev)
	Callback to call when network size estimate is updated. More...
static void *	nse_connect_adapter (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Adapter function called to establish a connection to NSE service. More...
static void	nse_disconnect_adapter (void *cls, void *op_result)
	Adapter function called to destroy a connection to NSE service. More...
static int	stat_iterator (void *cls, const char *subsystem, const char *name, uint64_t value, int is_persistent)
	Callback function to process statistic values. 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_comp_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	connect_nse_service ()
	Task run to connect to the NSE and statistics services to a subset of all of the running peers. More...
static void	next_round (void *cls)
	Task that starts/stops peers to move to the next round. More...
static void	finish_round (void *cls)
	We're at the end of a round. More...
static void	run_round ()
	We have reached the desired number of peers for the current round. More...
static struct OpListEntry *	make_oplist_entry ()
	Creates an oplist entry and adds it to the oplist DLL. More...
static void	manage_service_cb (void *cls, struct GNUNET_TESTBED_Operation *op, const char *emsg)
	Callback to be called when NSE service is started or stopped at peers. More...
static void	adjust_running_peers ()
	Adjust the number of running peers to match the required number of running peers for the round. More...
static void	master_controller_cb (void *cls, const struct GNUNET_TESTBED_EventInformation *event)
	Function that will be called whenever something in the testbed changes. More...
static void	test_master (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 *cfg)
	Actual main function that runs the emulation. More...
int	main (int argc, char *const *argv)
	Main function. More...

Variables
static struct NSEPeer *	peer_head
	Head of DLL of peers we monitor closely. More...
static struct NSEPeer *	peer_tail
	Tail of DLL of peers we monitor closely. More...
static int	ok
	Return value from 'main' (0 == success) More...
static unsigned int	verbose
	Be verbose (configuration option) More...
static char *	hosts_file
	Name of the file with the hosts to run the test over (configuration option) More...
static unsigned int	num_peers
	Maximum number of peers in the test. More...
static unsigned int	num_rounds
	Total number of rounds to execute. More...
static unsigned int	current_round
	Current round we are in. More...
static unsigned int *	num_peers_in_round
	Array of size 'num_rounds' with the requested number of peers in the given round. More...
static unsigned int	peers_running
	How many peers are running right now? More...
static char *	num_peer_spec
	Specification for the numbers of peers to have in each round. More...
static struct GNUNET_TESTBED_Peer **	daemons
	Handles to all of the running peers. More...
static struct GNUNET_CONFIGURATION_Handle *	testing_cfg
	Global configuration file. More...
static unsigned int	connection_limit
	Maximum number of connections to NSE services. More...
static unsigned int	total_connections
	Total number of connections in the whole network. More...
static struct GNUNET_DISK_FileHandle *	output_file
	File to report results to. More...
static char *	output_filename
	Filename to log results to. More...
static struct GNUNET_DISK_FileHandle *	data_file
	File to log connection info, statistics to. More...
static char *	data_filename
	Filename to log connection info, statistics to. More...
static struct GNUNET_TIME_Relative	wait_time = { 60 * 1000 }
	How long to wait before triggering next round? Default: 60 s. More...
static struct OpListEntry *	oplist_head
	DLL head for operation list. More...
static struct OpListEntry *	oplist_tail
	DLL tail for operation list. More...
static struct GNUNET_SCHEDULER_Task *	round_task
	Task running each round of the experiment. More...

Detailed Description

Profiling driver for the network size estimation service.

Generally, the profiler starts a given number of peers, then churns some off, waits a certain amount of time, then churns again, and repeats.

Author

Christian Grothoff

Nathan Evans

Sree Harsha Totakura

Definition in file gnunet-nse-profiler.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log (kind, __VA_ARGS__)

Generic loggins shorthand.

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

LOG_DEBUG

#define LOG_DEBUG

(

...

)

LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)

Debug logging shorthand.

Definition at line 44 of file gnunet-nse-profiler.c.

Function Documentation

close_monitor_connections()

static void close_monitor_connections ( )

static

Clean up all of the monitoring connections to NSE and STATISTICS that we keep to selected peers.

Definition at line 234 of file gnunet-nse-profiler.c.

{
  struct NSEPeer *pos;
  struct OpListEntry *oplist_entry;
 
  while (NULL != (pos = peer_head))
  {
    if (NULL != pos->nse_op)
      GNUNET_TESTBED_operation_done (pos->nse_op);
    if (NULL != pos->stat_op)
      GNUNET_TESTBED_operation_done (pos->stat_op);
    GNUNET_CONTAINER_DLL_remove (peer_head, peer_tail, pos);
    GNUNET_free (pos);
  }
  while (NULL != (oplist_entry = oplist_head))
  {
    GNUNET_CONTAINER_DLL_remove (oplist_head, oplist_tail, oplist_entry);
    GNUNET_TESTBED_operation_done (oplist_entry->op);
    GNUNET_free (oplist_entry);
  }
}

References GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_TESTBED_operation_done(), NSEPeer::nse_op, OpListEntry::op, oplist_head, oplist_tail, peer_head, peer_tail, and NSEPeer::stat_op.

Referenced by finish_round(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

shutdown_task()

static void shutdown_task ( void *  cls )

static

Task run on shutdown; cleans up everything.

Parameters

cls

unused

Definition at line 263 of file gnunet-nse-profiler.c.

{
  LOG_DEBUG ("Ending test.\n");
  close_monitor_connections ();
  if (NULL != round_task)
  {
    GNUNET_SCHEDULER_cancel (round_task);
    round_task = NULL;
  }
  if (NULL != data_file)
  {
    GNUNET_DISK_file_close (data_file);
    data_file = NULL;
  }
  if (NULL != output_file)
  {
    GNUNET_DISK_file_close (output_file);
    output_file = NULL;
  }
  if (NULL != testing_cfg)
  {
    GNUNET_CONFIGURATION_destroy (testing_cfg);
    testing_cfg = NULL;
  }
}

References close_monitor_connections(), data_file, GNUNET_CONFIGURATION_destroy(), GNUNET_DISK_file_close(), GNUNET_SCHEDULER_cancel(), LOG_DEBUG, output_file, round_task, and testing_cfg.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_estimate()

static void handle_estimate ( void *  cls, struct GNUNET_TIME_Absolute  timestamp, double  estimate, double  std_dev  )

static

Callback to call when network size estimate is updated.

Parameters

cls	closure with the 'struct NSEPeer' providing the update
timestamp	server timestamp
estimate	the value of the current network size estimate
std_dev	standard deviation (rounded down to nearest integer) of the size estimation values seen

Definition at line 300 of file gnunet-nse-profiler.c.

{
  struct NSEPeer *peer = cls;
  char output_buffer[512];
  size_t size;
 
  if (NULL == output_file)
  {
    fprintf (stderr,
             "Received network size estimate from peer %p. Size: %f std.dev. %f\n",
             peer,
             estimate,
             std_dev);
    return;
  }
  size = GNUNET_snprintf (output_buffer,
                          sizeof(output_buffer),
                          "%p %u %llu %f %f %f\n",
                          peer,
                          peers_running,
                          (unsigned long long) timestamp.abs_value_us,
                          GNUNET_NSE_log_estimate_to_n (estimate),
                          estimate,
                          std_dev);
  if (size != GNUNET_DISK_file_write (output_file, output_buffer, size))
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
}

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_DISK_file_write(), GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_NSE_log_estimate_to_n, GNUNET_snprintf(), output_file, peer, peers_running, and size.

Referenced by nse_connect_adapter().

Here is the call graph for this function:

Here is the caller graph for this function:

nse_connect_adapter()

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

static

Adapter function called to establish a connection to NSE service.

Parameters

cls	closure (the 'struct NSEPeer')
cfg	configuration 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 343 of file gnunet-nse-profiler.c.

{
  struct NSEPeer *current_peer = cls;
 
  return GNUNET_NSE_connect (cfg, &handle_estimate, current_peer);
}

References cfg, GNUNET_NSE_connect(), and handle_estimate().

Referenced by connect_nse_service().

Here is the call graph for this function:

Here is the caller graph for this function:

nse_disconnect_adapter()

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

static

Adapter function called to destroy a connection to NSE service.

Parameters

cls	closure
op_result	service handle returned from the connect adapter

Definition at line 359 of file gnunet-nse-profiler.c.

{
  GNUNET_NSE_disconnect (op_result);
}

References GNUNET_NSE_disconnect(), and op_result().

Referenced by connect_nse_service().

Here is the call graph for this function:

Here is the caller graph for this function:

stat_iterator()

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

static

Callback function to process statistic values.

Parameters

cls	struct NSEPeer
subsystem	name of subsystem that created the statistic
name	the name of the datum
value	the current value
is_persistent	GNUNET_YES if the value is persistent, GNUNET_NO if not

Returns

GNUNET_OK to continue, GNUNET_SYSERR to abort iteration

Definition at line 376 of file gnunet-nse-profiler.c.

{
  char *output_buffer;
  struct GNUNET_TIME_Absolute now;
  int size;
  unsigned int flag;
 
  GNUNET_assert (NULL != data_file);
  now = GNUNET_TIME_absolute_get ();
  flag = strcasecmp (subsystem, "core");
  if (0 != flag)
    flag = 1;
  size = GNUNET_asprintf (&output_buffer,
                          "%llu %llu %u\n",
                          (unsigned long long) now.abs_value_us / 1000LL / 1000LL,
                          (unsigned long long) value,
                          flag);
  if (0 > size)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Error formatting output buffer.\n");
    GNUNET_free (output_buffer);
    return GNUNET_SYSERR;
  }
  if (size != GNUNET_DISK_file_write (data_file, output_buffer, (size_t) size))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
    GNUNET_free (output_buffer);
    return GNUNET_SYSERR;
  }
  GNUNET_free (output_buffer);
  return GNUNET_OK;
}

References GNUNET_TIME_Absolute::abs_value_us, data_file, GNUNET_asprintf(), GNUNET_assert, GNUNET_DISK_file_write(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_OK, GNUNET_SYSERR, GNUNET_TIME_absolute_get(), size, subsystem, and value.

Referenced by stat_comp_cb(), and stat_disconnect_adapter().

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

cls	peer context
cfg	configuration 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 424 of file gnunet-nse-profiler.c.

{
  struct NSEPeer *peer = cls;
 
  peer->sh = GNUNET_STATISTICS_create ("nse-profiler", cfg);
  return peer->sh;
}

References cfg, GNUNET_STATISTICS_create(), and peer.

Referenced by connect_nse_service().

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

cls	peer context
op_result	service handle returned from the connect adapter

Definition at line 440 of file gnunet-nse-profiler.c.

{
  struct NSEPeer *peer = cls;
 
  GNUNET_break (GNUNET_OK ==
                GNUNET_STATISTICS_watch_cancel (peer->sh,
                                                "core",
                                                "# peers connected",
                                                stat_iterator,
                                                peer));
  GNUNET_break (GNUNET_OK ==
                GNUNET_STATISTICS_watch_cancel (peer->sh,
                                                "nse",
                                                "# peers connected",
                                                stat_iterator,
                                                peer));
  GNUNET_STATISTICS_destroy (op_result, GNUNET_NO);
  peer->sh = NULL;
}

References GNUNET_break, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_destroy(), GNUNET_STATISTICS_watch_cancel(), op_result(), peer, and stat_iterator().

Referenced by connect_nse_service().

Here is the call graph for this function:

Here is the caller graph for this function:

stat_comp_cb()

static void stat_comp_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

cls	the callback closure from functions generating an operation
op	the operation that has been finished
ca_result	the service handle returned from GNUNET_TESTBED_ConnectAdapter()
emsg	error message in case the operation has failed; will be NULL if operation has executed successfully.

Definition at line 472 of file gnunet-nse-profiler.c.

{
  struct GNUNET_STATISTICS_Handle *sh = ca_result;
  struct NSEPeer *peer = cls;
 
  if (NULL != emsg)
  {
    GNUNET_break (0);
    return;
  }
  GNUNET_break (GNUNET_OK == GNUNET_STATISTICS_watch (sh,
                                                      "core",
                                                      "# peers connected",
                                                      stat_iterator,
                                                      peer));
  GNUNET_break (GNUNET_OK == GNUNET_STATISTICS_watch (sh,
                                                      "nse",
                                                      "# peers connected",
                                                      stat_iterator,
                                                      peer));
}

References GNUNET_break, GNUNET_OK, GNUNET_STATISTICS_watch(), peer, sh, and stat_iterator().

Referenced by connect_nse_service().

Here is the call graph for this function:

Here is the caller graph for this function:

connect_nse_service()

static void connect_nse_service ( )

static

Task run to connect to the NSE and statistics services to a subset of all of the running peers.

Definition at line 503 of file gnunet-nse-profiler.c.

{
  struct NSEPeer *current_peer;
  unsigned int i;
  unsigned int connections;
 
  if (0 == connection_limit)
    return;
  LOG_DEBUG ("Connecting to nse service of peers\n");
  connections = 0;
  for (i = 0; i < num_peers_in_round[current_round]; i++)
  {
    if ((num_peers_in_round[current_round] > connection_limit) &&
        (0 != (i % (num_peers_in_round[current_round] / connection_limit))))
      continue;
    LOG_DEBUG ("Connecting to nse service of peer %d\n", i);
    current_peer = GNUNET_new (struct NSEPeer);
    current_peer->daemon = daemons[i];
    current_peer->nse_op =
      GNUNET_TESTBED_service_connect (NULL,
                                      current_peer->daemon,
                                      "nse",
                                      NULL,
                                      NULL,
                                      &nse_connect_adapter,
                                      &nse_disconnect_adapter,
                                      current_peer);
    if (NULL != data_file)
      current_peer->stat_op =
        GNUNET_TESTBED_service_connect (NULL,
                                        current_peer->daemon,
                                        "statistics",
                                        stat_comp_cb,
                                        current_peer,
                                        &stat_connect_adapter,
                                        &stat_disconnect_adapter,
                                        current_peer);
    GNUNET_CONTAINER_DLL_insert (peer_head, peer_tail, current_peer);
    if (++connections == connection_limit)
      break;
  }
}

References connection_limit, connections, current_round, NSEPeer::daemon, daemons, data_file, GNUNET_CONTAINER_DLL_insert, GNUNET_new, GNUNET_TESTBED_service_connect(), LOG_DEBUG, nse_connect_adapter(), nse_disconnect_adapter(), NSEPeer::nse_op, num_peers_in_round, peer_head, peer_tail, stat_comp_cb(), stat_connect_adapter(), stat_disconnect_adapter(), and NSEPeer::stat_op.

Referenced by run_round().

Here is the call graph for this function:

Here is the caller graph for this function:

next_round()

static void next_round ( void *  cls )

static

Task that starts/stops peers to move to the next round.

Task run at the end of a round.

Parameters

cls	NULL, unused

Disconnect from all monitored peers; then get statistics from all peers.

Parameters

cls	NULL, unused

Definition at line 674 of file gnunet-nse-profiler.c.

{
  round_task = NULL;
  LOG_DEBUG ("Disconnecting nse service of peers\n");
  current_round++;
  if (current_round == num_rounds)
  {
    /* this was the last round, terminate */
    ok = 0;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if (num_peers_in_round[current_round] == peers_running)
  {
    /* no need to churn, just run next round */
    run_round ();
    return;
  }
  adjust_running_peers ();
}

References adjust_running_peers(), current_round, GNUNET_SCHEDULER_shutdown(), LOG_DEBUG, num_peers_in_round, num_rounds, ok, peers_running, round_task, and run_round().

Referenced by finish_round().

Here is the call graph for this function:

Here is the caller graph for this function:

finish_round()

static void finish_round ( void *  cls )

static

We're at the end of a round.

Stop monitoring, write total number of connections to log and get full stats. Then trigger the next round.

Parameters

cls	unused, NULL

Definition at line 564 of file gnunet-nse-profiler.c.

{
  LOG (GNUNET_ERROR_TYPE_INFO, "Have %u connections\n", total_connections);
  close_monitor_connections ();
  round_task = GNUNET_SCHEDULER_add_now (&next_round, NULL);
}

References close_monitor_connections(), GNUNET_ERROR_TYPE_INFO, GNUNET_SCHEDULER_add_now(), LOG, next_round(), round_task, and total_connections.

Referenced by run_round().

Here is the call graph for this function:

Here is the caller graph for this function:

run_round()

static void run_round ( )

static

We have reached the desired number of peers for the current round.

Run it (by connecting and monitoring a few peers and waiting the specified delay before finishing the round).

Definition at line 578 of file gnunet-nse-profiler.c.

{
  LOG_DEBUG ("Running round %u\n", current_round);
  connect_nse_service ();
  GNUNET_SCHEDULER_add_delayed (wait_time, &finish_round, NULL);
}

References connect_nse_service(), current_round, finish_round(), GNUNET_SCHEDULER_add_delayed(), LOG_DEBUG, and wait_time.

Referenced by manage_service_cb(), next_round(), and test_master().

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 590 of file gnunet-nse-profiler.c.

{
  struct OpListEntry *entry;
 
  entry = GNUNET_new (struct OpListEntry);
  GNUNET_CONTAINER_DLL_insert_tail (oplist_head, oplist_tail, entry);
  return entry;
}

References GNUNET_CONTAINER_DLL_insert_tail, GNUNET_new, oplist_head, and oplist_tail.

Referenced by adjust_running_peers().

Here is the caller graph for this function:

manage_service_cb()

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

static

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

Parameters

cls	NULL
op	the operation handle
emsg	NULL on success; otherwise an error description

Definition at line 608 of file gnunet-nse-profiler.c.

{
  struct OpListEntry *entry = cls;
 
  GNUNET_TESTBED_operation_done (entry->op);
  if (NULL != emsg)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR, "Failed to start/stop NSE at a peer\n");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  GNUNET_assert (0 != entry->delta);
  peers_running += entry->delta;
  GNUNET_CONTAINER_DLL_remove (oplist_head, oplist_tail, entry);
  GNUNET_free (entry);
  if (num_peers_in_round[current_round] == peers_running)
    run_round ();
}

References current_round, OpListEntry::delta, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_SCHEDULER_shutdown(), GNUNET_TESTBED_operation_done(), LOG, num_peers_in_round, OpListEntry::op, oplist_head, oplist_tail, peers_running, and run_round().

Referenced by adjust_running_peers().

Here is the call graph for this function:

Here is the caller graph for this function:

adjust_running_peers()

static void adjust_running_peers ( )

static

Adjust the number of running peers to match the required number of running peers for the round.

Definition at line 635 of file gnunet-nse-profiler.c.

{
  struct OpListEntry *entry;
  unsigned int i;
 
  /* start peers if we have too few */
  for (i = peers_running; i < num_peers_in_round[current_round]; i++)
  {
    entry = make_oplist_entry ();
    entry->delta = 1;
    entry->op = GNUNET_TESTBED_peer_manage_service (NULL,
                                                    daemons[i],
                                                    "nse",
                                                    &manage_service_cb,
                                                    entry,
                                                    1);
  }
  /* stop peers if we have too many */
  for (i = num_peers_in_round[current_round]; i < peers_running; i++)
  {
    entry = make_oplist_entry ();
    entry->delta = -1;
    entry->op = GNUNET_TESTBED_peer_manage_service (NULL,
                                                    daemons[i],
                                                    "nse",
                                                    &manage_service_cb,
                                                    entry,
                                                    0);
  }
}

References current_round, daemons, OpListEntry::delta, GNUNET_TESTBED_peer_manage_service(), make_oplist_entry(), manage_service_cb(), num_peers_in_round, OpListEntry::op, and peers_running.

Referenced by next_round(), and test_master().

Here is the call graph for this function:

Here is the caller graph for this function:

master_controller_cb()

static void master_controller_cb ( void *  cls, const struct GNUNET_TESTBED_EventInformation *  event  )

static

Function that will be called whenever something in the testbed changes.

Parameters

cls	closure, NULL
event	information on what is happening

Definition at line 704 of file gnunet-nse-profiler.c.

{
  switch (event->type)
  {
  case GNUNET_TESTBED_ET_CONNECT:
    total_connections++;
    break;
 
  case GNUNET_TESTBED_ET_DISCONNECT:
    total_connections--;
    break;
 
  default:
    break;
  }
}

References GNUNET_TESTBED_ET_CONNECT, GNUNET_TESTBED_ET_DISCONNECT, total_connections, and GNUNET_TESTBED_EventInformation::type.

Referenced by run().

Here is the caller graph for this function:

test_master()

static void test_master ( 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

cls	NULL
h	the run handle
num_peers_	number of peers in 'peers'
peers	handle to peers run in the testbed. NULL upon timeout (see GNUNET_TESTBED_test_run()).
links_succeeded	the number of overlay link connection attempts that succeeded
links_failed	the number of overlay link connection attempts that failed

Definition at line 737 of file gnunet-nse-profiler.c.

{
  if (NULL == peers)
  {
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  daemons = peers;
  GNUNET_break (num_peers_ == num_peers);
  peers_running = num_peers;
  if (num_peers_in_round[current_round] == peers_running)
  {
    /* no need to churn, just run the starting round */
    run_round ();
    return;
  }
  adjust_running_peers ();
}

References adjust_running_peers(), current_round, daemons, GNUNET_break, GNUNET_SCHEDULER_shutdown(), num_peers, num_peers_in_round, peers, peers_running, and run_round().

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

static

Actual main function that runs the emulation.

Parameters

cls	unused
args	remaining args, unused
cfgfile	name of the configuration
cfg	configuration handle

Definition at line 771 of file gnunet-nse-profiler.c.

{
  char *tok;
  uint64_t event_mask;
  unsigned int num;
 
  ok = 1;
  testing_cfg = GNUNET_CONFIGURATION_dup (cfg);
  LOG_DEBUG ("Starting daemons.\n");
  if (NULL == num_peer_spec)
  {
    fprintf (stderr, "You need to specify the number of peers to run\n");
    return;
  }
  for (tok = strtok (num_peer_spec, ","); NULL != tok; tok = strtok (NULL, ","))
  {
    if (1 != sscanf (tok, "%u", &num))
    {
      fprintf (stderr, "You need to specify numbers, not `%s'\n", tok);
      return;
    }
    if (0 == num)
    {
      fprintf (stderr, "Refusing to run a round with 0 peers\n");
      return;
    }
    GNUNET_array_append (num_peers_in_round, num_rounds, num);
    num_peers = GNUNET_MAX (num_peers, num);
  }
  if (0 == num_peers)
  {
    fprintf (stderr, "Refusing to run a testbed with no rounds\n");
    return;
  }
  if ((NULL != data_filename) &&
      (NULL ==
       (data_file = GNUNET_DISK_file_open (data_filename,
                                           GNUNET_DISK_OPEN_READWRITE
                                           | GNUNET_DISK_OPEN_TRUNCATE
                                           | GNUNET_DISK_OPEN_CREATE,
                                           GNUNET_DISK_PERM_USER_READ
                                           | GNUNET_DISK_PERM_USER_WRITE))))
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", data_filename);
 
  if ((NULL != output_filename) &&
      (NULL ==
       (output_file = GNUNET_DISK_file_open (output_filename,
                                             GNUNET_DISK_OPEN_READWRITE
                                             | GNUNET_DISK_OPEN_CREATE,
                                             GNUNET_DISK_PERM_USER_READ
                                             | GNUNET_DISK_PERM_USER_WRITE))))
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", output_filename);
  event_mask = 0LL;
  event_mask |= (1LL << GNUNET_TESTBED_ET_PEER_START);
  event_mask |= (1LL << GNUNET_TESTBED_ET_PEER_STOP);
  event_mask |= (1LL << GNUNET_TESTBED_ET_CONNECT);
  event_mask |= (1LL << GNUNET_TESTBED_ET_DISCONNECT);
  GNUNET_TESTBED_run (hosts_file,
                      cfg,
                      num_peers,
                      event_mask,
                      master_controller_cb,
                      NULL, /* master_controller_cb cls */
                      &test_master,
                      NULL); /* test_master cls */
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
}

References cfg, data_file, data_filename, event_mask, GNUNET_array_append, GNUNET_CONFIGURATION_dup(), GNUNET_DISK_file_open(), GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_OPEN_READWRITE, GNUNET_DISK_OPEN_TRUNCATE, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_ERROR_TYPE_ERROR, GNUNET_log_strerror_file, GNUNET_MAX, GNUNET_SCHEDULER_add_shutdown(), GNUNET_TESTBED_ET_CONNECT, GNUNET_TESTBED_ET_DISCONNECT, GNUNET_TESTBED_ET_PEER_START, GNUNET_TESTBED_ET_PEER_STOP, GNUNET_TESTBED_run(), hosts_file, LOG_DEBUG, master_controller_cb(), num_peer_spec, num_peers, num_peers_in_round, num_rounds, ok, output_file, output_filename, shutdown_task(), test_master(), and testing_cfg.

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 849 of file gnunet-nse-profiler.c.

{
  struct GNUNET_GETOPT_CommandLineOption options[] =
  { GNUNET_GETOPT_option_uint (
      'C',
      "connections",
      "COUNT",
      gettext_noop (
        "limit to the number of connections to NSE services, 0 for none"),
      &connection_limit),
    GNUNET_GETOPT_option_string (
      'd',
      "details",
      "FILENAME",
      gettext_noop (
        "name of the file for writing connection information and statistics"),
      &data_filename),
 
    GNUNET_GETOPT_option_string (
      'H',
      "hosts",
      "FILENAME",
      gettext_noop (
        "name of the file with the login information for the testbed"),
      &hosts_file),
 
    GNUNET_GETOPT_option_string (
      'o',
      "output",
      "FILENAME",
      gettext_noop ("name of the file for writing the main results"),
      &output_filename),
 
 
    GNUNET_GETOPT_option_string (
      'p',
      "peers",
      "NETWORKSIZESPEC",
      gettext_noop (
        "Number of peers to run in each round, separated by commas"),
      &num_peer_spec),
 
    GNUNET_GETOPT_option_increment_uint (
      'V',
      "verbose",
      gettext_noop ("be verbose (print progress information)"),
      &verbose),
 
    GNUNET_GETOPT_option_relative_time ('w',
                                        "wait",
                                        "DELAY",
                                        gettext_noop ("delay between rounds"),
                                        &wait_time),
    GNUNET_GETOPT_OPTION_END };
 
  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
    return 2;
  if (
    GNUNET_OK !=
    GNUNET_PROGRAM_run (argc,
                        argv,
                        "nse-profiler",
                        gettext_noop (
                          "Measure quality and performance of the NSE service."),
                        options,
                        &run,
                        NULL))
    ok = 1;
  return ok;
}

References connection_limit, data_filename, gettext_noop, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_increment_uint(), GNUNET_GETOPT_option_relative_time(), GNUNET_GETOPT_option_string(), GNUNET_GETOPT_option_uint(), GNUNET_OK, GNUNET_PROGRAM_run(), GNUNET_STRINGS_get_utf8_args(), hosts_file, num_peer_spec, ok, options, output_filename, run(), verbose, and wait_time.

Here is the call graph for this function:

Variable Documentation

peer_head

struct NSEPeer* peer_head

static

Head of DLL of peers we monitor closely.

Definition at line 115 of file gnunet-nse-profiler.c.

Referenced by close_monitor_connections(), and connect_nse_service().

peer_tail

struct NSEPeer* peer_tail

static

Tail of DLL of peers we monitor closely.

Definition at line 120 of file gnunet-nse-profiler.c.

Referenced by close_monitor_connections(), and connect_nse_service().

ok

int ok

static

Return value from 'main' (0 == success)

Definition at line 125 of file gnunet-nse-profiler.c.

Referenced by accept_client(), check_unique(), connect_check_run(), GNUNET_CRYPTO_rsa_blind(), GNUNET_log_skip(), main(), next_round(), pick_random_dv_hops(), run(), and save_hostlist_file().

verbose

unsigned int verbose

static

Be verbose (configuration option)

Definition at line 130 of file gnunet-nse-profiler.c.

Referenced by main().

hosts_file

char* hosts_file

static

Name of the file with the hosts to run the test over (configuration option)

Definition at line 135 of file gnunet-nse-profiler.c.

Referenced by main(), and run().

num_peers

unsigned int num_peers

static

Maximum number of peers in the test.

Definition at line 140 of file gnunet-nse-profiler.c.

Referenced by run(), and test_master().

num_rounds

unsigned int num_rounds

static

Total number of rounds to execute.

Definition at line 145 of file gnunet-nse-profiler.c.

Referenced by next_round(), and run().

current_round

unsigned int current_round

static

Current round we are in.

Definition at line 150 of file gnunet-nse-profiler.c.

Referenced by adjust_running_peers(), connect_nse_service(), manage_service_cb(), next_round(), run_round(), and test_master().

num_peers_in_round

unsigned int* num_peers_in_round

static

Array of size 'num_rounds' with the requested number of peers in the given round.

Definition at line 155 of file gnunet-nse-profiler.c.

Referenced by adjust_running_peers(), connect_nse_service(), manage_service_cb(), next_round(), run(), and test_master().

peers_running

unsigned int peers_running

static

How many peers are running right now?

Definition at line 160 of file gnunet-nse-profiler.c.

Referenced by adjust_running_peers(), handle_estimate(), manage_service_cb(), next_round(), and test_master().

num_peer_spec

char* num_peer_spec

static

Specification for the numbers of peers to have in each round.

Definition at line 165 of file gnunet-nse-profiler.c.

Referenced by main(), and run().

daemons

struct GNUNET_TESTBED_Peer** daemons

static

Handles to all of the running peers.

Definition at line 170 of file gnunet-nse-profiler.c.

Referenced by adjust_running_peers(), connect_nse_service(), and test_master().

testing_cfg

struct GNUNET_CONFIGURATION_Handle* testing_cfg

static

Global configuration file.

Definition at line 175 of file gnunet-nse-profiler.c.

Referenced by run(), and shutdown_task().

connection_limit

unsigned int connection_limit

static

Maximum number of connections to NSE services.

Definition at line 180 of file gnunet-nse-profiler.c.

Referenced by connect_nse_service(), and main().

total_connections

unsigned int total_connections

static

Total number of connections in the whole network.

Definition at line 185 of file gnunet-nse-profiler.c.

Referenced by finish_round(), and master_controller_cb().

output_file

struct GNUNET_DISK_FileHandle* output_file

static

File to report results to.

Definition at line 190 of file gnunet-nse-profiler.c.

Referenced by handle_estimate(), run(), and shutdown_task().

output_filename

char* output_filename

static

Filename to log results to.

Definition at line 195 of file gnunet-nse-profiler.c.

Referenced by main(), and run().

data_file

struct GNUNET_DISK_FileHandle* data_file

static

File to log connection info, statistics to.

Definition at line 200 of file gnunet-nse-profiler.c.

Referenced by connect_nse_service(), run(), shutdown_task(), and stat_iterator().

data_filename

char* data_filename

static

Filename to log connection info, statistics to.

Definition at line 205 of file gnunet-nse-profiler.c.

Referenced by main(), and run().

wait_time

struct GNUNET_TIME_Relative wait_time = { 60 * 1000 }

static

How long to wait before triggering next round? Default: 60 s.

Definition at line 205 of file gnunet-nse-profiler.c.

Referenced by main(), and run_round().

oplist_head

struct OpListEntry* oplist_head

static

DLL head for operation list.

Definition at line 216 of file gnunet-nse-profiler.c.

Referenced by close_monitor_connections(), make_oplist_entry(), and manage_service_cb().

oplist_tail

struct OpListEntry* oplist_tail

static

DLL tail for operation list.

Definition at line 221 of file gnunet-nse-profiler.c.

Referenced by close_monitor_connections(), make_oplist_entry(), and manage_service_cb().

round_task

struct GNUNET_SCHEDULER_Task* round_task

static

Task running each round of the experiment.

Definition at line 226 of file gnunet-nse-profiler.c.

Referenced by finish_round(), next_round(), and shutdown_task().