ats-testing.c File Reference

ats testing library: setup topology solvers More...

#include "ats-testing.h"

Include dependency graph for ats-testing.c:

Go to the source code of this file.

Data Structures
struct	TestbedConnectOperation
	Connect peers with testbed. More...

Functions
static void	do_shutdown (void *cls)
	Shutdown nicely. More...
static struct BenchmarkPartner *	find_partner (struct BenchmarkPeer *me, const struct GNUNET_PeerIdentity *peer)
static struct BenchmarkPeer *	find_peer (const struct GNUNET_PeerIdentity *peer)
static void *	comm_connect_cb (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
	Method called whenever a given peer connects. More...
static void	comm_disconnect_cb (void *cls, const struct GNUNET_PeerIdentity *peer, void *internal_cls)
static void	handle_pong (void *cls, const struct TestMessage *message)
static void	handle_ping (void *cls, const struct TestMessage *message)
static void *	transport_connect_adapter (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
static void	transport_disconnect_adapter (void *cls, void *op_result)
static void *	core_connect_adapter (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
static void	core_disconnect_adapter (void *cls, void *op_result)
static void	connect_completion_callback (void *cls, struct GNUNET_TESTBED_Operation *op, const char *emsg)
static void	do_connect_peers (void *cls)
static void	comm_connect_completion_cb (void *cls, struct GNUNET_TESTBED_Operation *op, void *ca_result, const char *emsg)
static void	do_comm_connect (void *cls)
static void	ats_performance_info_cb (void *cls, const struct GNUNET_HELLO_Address *address, int address_active, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in, const struct GNUNET_ATS_Properties *ats_prop)
static void *	ats_perf_connect_adapter (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
static void	ats_perf_disconnect_adapter (void *cls, void *op_result)
static void	ats_connect_completion_cb (void *cls, struct GNUNET_TESTBED_Operation *op, void *ca_result, const char *emsg)
static void	do_connect_ats (void *cls)
static void	peerinformation_cb (void *cb_cls, struct GNUNET_TESTBED_Operation *op, const struct GNUNET_TESTBED_PeerInformation *pinfo, const char *emsg)
static void	main_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	controller_event_cb (void *cls, const struct GNUNET_TESTBED_EventInformation *event)
	Controller event callback. More...
struct BenchmarkPeer *	GNUNET_ATS_TEST_get_peer (int src)
	Topology related functions. More...
struct BenchmarkPartner *	GNUNET_ATS_TEST_get_partner (int src, int dest)
void	GNUNET_ATS_TEST_create_topology (char *name, char *cfg_file, unsigned int num_slaves, unsigned int num_masters, int test_core, GNUNET_ATS_TEST_TopologySetupDoneCallback done_cb, void *done_cb_cls, GNUNET_ATS_AddressInformationCallback log_request_cb)
	Create a topology for ats testing. More...
void	GNUNET_ATS_TEST_shutdown_topology (void)
	Shutdown topology. More...

Variables
struct GNUNET_CONFIGURATION_Handle *	cfg
	Handle to our configuration. More...
struct GNUNET_ATS_TEST_Topology *	top

Detailed Description

ats testing library: setup topology solvers

Author

Christian Grothoff

Matthias Wachs

Definition in file ats-testing.c.

Function Documentation

do_shutdown()

static void do_shutdown ( void *  cls )

static

Shutdown nicely.

Parameters

cls

NULL

Definition at line 61 of file ats-testing.c.

References BenchmarkPeer::ats_perf_op, BenchmarkPeer::ats_task, BenchmarkState::benchmarking, BenchmarkPeer::comm_op, TestbedConnectOperation::connect_op, BenchmarkPeer::core_connect_ops, GNUNET_ATS_TEST_generate_traffic_stop_all(), GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_free_non_null, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_shutdown(), GNUNET_TESTBED_operation_done(), GNUNET_ATS_TEST_Topology::mps, GNUNET_ATS_TEST_Topology::num_masters, BenchmarkPeer::num_partners, GNUNET_ATS_TEST_Topology::num_slaves, p, BenchmarkPeer::partners, BenchmarkPeer::peer_id_op, GNUNET_ATS_TEST_Topology::sps, and GNUNET_ATS_TEST_Topology::state.

Referenced by main_run().

{
  int c_m;
  int c_s;
  int c_op;
  struct BenchmarkPeer *p;

  top->state.benchmarking = GNUNET_NO;

  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
             "Benchmarking done\n");

  GNUNET_ATS_TEST_generate_traffic_stop_all();

  for (c_m = 0; c_m < top->num_masters; c_m++)
    {
      p = &top->mps[c_m];
      if (NULL != top->mps[c_m].peer_id_op)
        {
          GNUNET_TESTBED_operation_done(p->peer_id_op);
          p->peer_id_op = NULL;
        }

      if (NULL != p->ats_task)
        GNUNET_SCHEDULER_cancel(p->ats_task);
      p->ats_task = NULL;

      for (c_op = 0; c_op < p->num_partners; c_op++)
        {
          if ((NULL != p->core_connect_ops) &&
              (NULL != p->core_connect_ops[c_op].connect_op))
            {
              GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                         "Failed to connect peer 0 and %u\n",
                         c_op);
              GNUNET_TESTBED_operation_done(p->core_connect_ops[c_op].connect_op);
              p->core_connect_ops[c_op].connect_op = NULL;
            }
        }

      if (NULL != p->ats_perf_op)
        {
          GNUNET_TESTBED_operation_done(p->ats_perf_op);
          p->ats_perf_op = NULL;
        }

      if (NULL != p->comm_op)
        {
          GNUNET_TESTBED_operation_done(p->comm_op);
          p->comm_op = NULL;
        }
      GNUNET_free_non_null(p->core_connect_ops);
      GNUNET_free(p->partners);
      p->partners = NULL;
    }

  for (c_s = 0; c_s < top->num_slaves; c_s++)
    {
      p = &top->sps[c_s];
      if (NULL != p->peer_id_op)
        {
          GNUNET_TESTBED_operation_done(p->peer_id_op);
          p->peer_id_op = NULL;
        }
      if (NULL != p->ats_perf_op)
        {
          GNUNET_TESTBED_operation_done(p->ats_perf_op);
          p->ats_perf_op = NULL;
        }
      if (NULL != p->comm_op)
        {
          GNUNET_TESTBED_operation_done(p->comm_op);
          p->comm_op = NULL;
        }
      GNUNET_free(p->partners);
      p->partners = NULL;
    }
  GNUNET_SCHEDULER_shutdown();
  GNUNET_free(top);
  top = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

find_partner()

static struct BenchmarkPartner* find_partner ( struct BenchmarkPeer *  me, const struct GNUNET_PeerIdentity *  peer  )

static

Definition at line 145 of file ats-testing.c.

References BenchmarkPartner::dest, GNUNET_memcmp, BenchmarkPeer::id, BenchmarkPeer::num_partners, and BenchmarkPeer::partners.

Referenced by ats_performance_info_cb(), and comm_connect_cb().

{
  int c_m;

  for (c_m = 0; c_m < me->num_partners; c_m++)
    {
      /* Find a partner with other as destination */
      if (0 == GNUNET_memcmp(peer,
                             &me->partners[c_m].dest->id))
        {
          return &me->partners[c_m];
        }
    }

  return NULL;
}

Here is the caller graph for this function:

find_peer()

static struct BenchmarkPeer* find_peer ( const struct GNUNET_PeerIdentity *  peer )

static

Definition at line 165 of file ats-testing.c.

References GNUNET_memcmp, BenchmarkPeer::id, GNUNET_ATS_TEST_Topology::mps, GNUNET_ATS_TEST_Topology::num_masters, GNUNET_ATS_TEST_Topology::num_slaves, and GNUNET_ATS_TEST_Topology::sps.

Referenced by comm_connect_cb().

{
  int c_p;

  for (c_p = 0; c_p < top->num_masters; c_p++)
    {
      if (0 == GNUNET_memcmp(&top->mps[c_p].id,
                             peer))
        return &top->mps[c_p];
    }

  for (c_p = 0; c_p < top->num_slaves; c_p++)
    {
      if (0 == GNUNET_memcmp(&top->sps[c_p].id,
                             peer))
        return &top->sps[c_p];
    }
  return NULL;
}

Here is the caller graph for this function:

comm_connect_cb()

static void* comm_connect_cb ( void *  cls, const struct GNUNET_PeerIdentity *  peer, struct GNUNET_MQ_Handle *  mq  )

static

Method called whenever a given peer connects.

Parameters

cls	closure
peer	peer identity this notification is about
mq	queue to use to send messages to peer

Returns

the struct BenchmarkPartner of peer

Definition at line 195 of file ats-testing.c.

References BenchmarkState::connected_CORE, BenchmarkPeer::core_connections, BenchmarkPeer::core_slave_connections, GNUNET_ATS_TEST_Topology::done_cb, GNUNET_ATS_TEST_Topology::done_cb_cls, find_partner(), find_peer(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_strdup, GNUNET_YES, BenchmarkPeer::id, id, BenchmarkPeer::master, me, GNUNET_ATS_TEST_Topology::mps, mq, BenchmarkPartner::mq, BenchmarkPeer::no, GNUNET_ATS_TEST_Topology::num_masters, GNUNET_ATS_TEST_Topology::num_slaves, p, GNUNET_ATS_TEST_Topology::sps, and GNUNET_ATS_TEST_Topology::state.

Referenced by core_connect_adapter(), and transport_connect_adapter().

{
  struct BenchmarkPeer *me = cls;
  struct BenchmarkPeer *remote;
  struct BenchmarkPartner *p;
  char *id;
  int c;
  int completed;

  remote = find_peer(peer);
  if (NULL == remote)
    {
      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
                 "Unknown peer connected: `%s'\n",
                 GNUNET_i2s(peer));
      GNUNET_break(0);
      return NULL;
    }

  id = GNUNET_strdup(GNUNET_i2s(&me->id));
  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
             "%s [%u] `%s' connected to %s [%u] %s\n",
             (me->master == GNUNET_YES) ? "Master" : "Slave",
             me->no,
             id,
             (remote->master == GNUNET_YES) ? "Master" : "Slave",
             remote->no,
             GNUNET_i2s(peer));

  me->core_connections++;
  if ((GNUNET_YES == me->master) &&
      (GNUNET_NO == remote->master) &&
      (GNUNET_NO == top->state.connected_CORE))
    {
      me->core_slave_connections++;

      if (me->core_slave_connections == top->num_slaves)
        {
          GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                     "Master [%u] connected all slaves\n",
                     me->no);
        }
      completed = GNUNET_YES;
      for (c = 0; c < top->num_masters; c++)
        {
          if (top->mps[c].core_slave_connections != top->num_slaves)
            completed = GNUNET_NO;
        }
      if (GNUNET_YES == completed)
        {
          GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                     "All master peers connected all slave peers\n");
          top->state.connected_CORE = GNUNET_YES;
          /* Notify about setup done */
          if (NULL != top->done_cb)
            top->done_cb(top->done_cb_cls,
                         top->mps,
                         top->sps);
        }
    }
  GNUNET_free(id);
  p = find_partner(me,
                   peer);
  if (NULL != p)
    p->mq = mq;
  return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

comm_disconnect_cb()

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

static

Parameters

cls	this peer
peer	id of disconnecting peer
internal_cls	the struct BenchmarkPartner of peer

Definition at line 272 of file ats-testing.c.

References BenchmarkState::benchmarking, BenchmarkPeer::core_connections, BenchmarkPartner::dest, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_strdup, GNUNET_YES, BenchmarkPeer::id, id, BenchmarkPeer::master, me, p, and GNUNET_ATS_TEST_Topology::state.

Referenced by core_connect_adapter(), and transport_connect_adapter().

{
  struct BenchmarkPeer *me = cls;
  struct BenchmarkPartner *p = internal_cls;
  char *id;

  if (NULL == p)
    return;

  id = GNUNET_strdup(GNUNET_i2s(&me->id));
  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
             "%s disconnected from %s\n",
             id,
             GNUNET_i2s(peer));
  GNUNET_assert(me->core_connections > 0);
  me->core_connections--;

  if ((GNUNET_YES == top->state.benchmarking) &&
      ((GNUNET_YES == me->master) ||
       (GNUNET_YES == p->dest->master)))
    {
      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
                 "%s disconnected from %s while benchmarking\n",
                 id,
                 GNUNET_i2s(peer));
    }
  GNUNET_free(id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

handle_pong()

static void handle_pong ( void *  cls, const struct TestMessage *  message  )

static

Definition at line 305 of file ats-testing.c.

References GNUNET_ATS_TEST_traffic_handle_pong(), and p.

{
  struct BenchmarkPartner *p = cls;

  GNUNET_ATS_TEST_traffic_handle_pong(p);
}

Here is the call graph for this function:

handle_ping()

static void handle_ping ( void *  cls, const struct TestMessage *  message  )

static

Definition at line 315 of file ats-testing.c.

References GNUNET_ATS_TEST_traffic_handle_ping(), and p.

{
  struct BenchmarkPartner *p = cls;

  GNUNET_ATS_TEST_traffic_handle_ping(p);
}

Here is the call graph for this function:

transport_connect_adapter()

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

static

Definition at line 325 of file ats-testing.c.

References comm_connect_cb(), comm_disconnect_cb(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_TRANSPORT_core_connect(), BenchmarkPeer::id, me, ping(), pong(), TEST_MESSAGE_TYPE_PING, TEST_MESSAGE_TYPE_PONG, and BenchmarkPeer::th.

Referenced by do_comm_connect().

{
  struct BenchmarkPeer *me = cls;
  struct GNUNET_MQ_MessageHandler handlers[] = {
    GNUNET_MQ_hd_fixed_size(ping,
                            TEST_MESSAGE_TYPE_PING,
                            struct TestMessage,
                            me),
    GNUNET_MQ_hd_fixed_size(pong,
                            TEST_MESSAGE_TYPE_PONG,
                            struct TestMessage,
                            me),
    GNUNET_MQ_handler_end()
  };

  me->th = GNUNET_TRANSPORT_core_connect(cfg,
                                         &me->id,
                                         handlers,
                                         me,
                                         &comm_connect_cb,
                                         &comm_disconnect_cb,
                                         NULL);
  if (NULL == me->th)
    GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
               "Failed to create transport connection \n");
  return me->th;
}

Here is the call graph for this function:

Here is the caller graph for this function:

transport_disconnect_adapter()

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

static

Definition at line 356 of file ats-testing.c.

References GNUNET_TRANSPORT_core_disconnect(), me, and BenchmarkPeer::th.

Referenced by do_comm_connect().

{
  struct BenchmarkPeer *me = cls;

  GNUNET_TRANSPORT_core_disconnect(me->th);
  me->th = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

core_connect_adapter()

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

static

Definition at line 367 of file ats-testing.c.

References BenchmarkPeer::ch, comm_connect_cb(), comm_disconnect_cb(), GNUNET_CORE_connect(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, me, ping(), pong(), TEST_MESSAGE_TYPE_PING, and TEST_MESSAGE_TYPE_PONG.

Referenced by do_comm_connect().

{
  struct BenchmarkPeer *me = cls;
  struct GNUNET_MQ_MessageHandler handlers[] = {
    GNUNET_MQ_hd_fixed_size(ping,
                            TEST_MESSAGE_TYPE_PING,
                            struct TestMessage,
                            me),
    GNUNET_MQ_hd_fixed_size(pong,
                            TEST_MESSAGE_TYPE_PONG,
                            struct TestMessage,
                            me),
    GNUNET_MQ_handler_end()
  };

  me->ch = GNUNET_CORE_connect(cfg,
                               me,
                               NULL,
                               &comm_connect_cb,
                               &comm_disconnect_cb,
                               handlers);
  if (NULL == me->ch)
    GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
               "Failed to create core connection \n");
  return me->ch;
}

Here is the call graph for this function:

Here is the caller graph for this function:

core_disconnect_adapter()

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

static

Definition at line 397 of file ats-testing.c.

References BenchmarkPeer::ch, GNUNET_CORE_disconnect(), and me.

Referenced by do_comm_connect().

{
  struct BenchmarkPeer *me = cls;

  GNUNET_CORE_disconnect(me->ch);
  me->ch = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

connect_completion_callback()

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

static

Definition at line 408 of file ats-testing.c.

References _, TestbedConnectOperation::connect_op, BenchmarkState::connected_PEERS, BenchmarkPeer::core_connect_ops, GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SCHEDULER_shutdown(), GNUNET_TESTBED_operation_done(), GNUNET_YES, TestbedConnectOperation::master, BenchmarkPeer::no, GNUNET_ATS_TEST_Topology::num_masters, GNUNET_ATS_TEST_Topology::num_slaves, TestbedConnectOperation::slave, and GNUNET_ATS_TEST_Topology::state.

Referenced by do_connect_peers().

{
  struct TestbedConnectOperation *cop = cls;
  static int ops = 0;
  int c;

  if (NULL == emsg)
    {
      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                 _("Connected master [%u] with slave [%u]\n"),
                 cop->master->no,
                 cop->slave->no);
    }
  else
    {
      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
                 _("Failed to connect master peer [%u] with slave [%u]\n"),
                 cop->master->no, cop->slave->no);
      GNUNET_break(0);
      GNUNET_SCHEDULER_shutdown();
    }
  GNUNET_TESTBED_operation_done(op);
  ops++;
  for (c = 0; c < top->num_slaves; c++)
    {
      if (cop == &cop->master->core_connect_ops[c])
        cop->master->core_connect_ops[c].connect_op = NULL;
    }
  if (ops == top->num_masters * top->num_slaves)
    {
      top->state.connected_PEERS = GNUNET_YES;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

do_connect_peers()

static void do_connect_peers ( void *  cls )

static

Definition at line 446 of file ats-testing.c.

References connect_completion_callback(), TestbedConnectOperation::connect_op, BenchmarkState::connected_ATS_service, BenchmarkState::connected_COMM_service, BenchmarkPeer::core_connect_ops, GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_malloc, GNUNET_NO, GNUNET_SCHEDULER_shutdown(), GNUNET_TESTBED_overlay_connect(), TestbedConnectOperation::master, GNUNET_ATS_TEST_Topology::mps, BenchmarkPeer::no, GNUNET_ATS_TEST_Topology::num_masters, GNUNET_ATS_TEST_Topology::num_slaves, p, BenchmarkPeer::peer, TestbedConnectOperation::slave, GNUNET_ATS_TEST_Topology::sps, and GNUNET_ATS_TEST_Topology::state.

Referenced by comm_connect_completion_cb().

{
  int c_m;
  int c_s;
  struct BenchmarkPeer *p;

  if ((top->state.connected_ATS_service == GNUNET_NO) ||
      (top->state.connected_COMM_service == GNUNET_NO))
    return;

  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
             "Connecting peers on CORE level\n");
  for (c_m = 0; c_m < top->num_masters; c_m++)
    {
      p = &top->mps[c_m];
      p->core_connect_ops = GNUNET_malloc(top->num_slaves *
                                          sizeof(struct TestbedConnectOperation));

      for (c_s = 0; c_s < top->num_slaves; c_s++)
        {
          GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                     "Connecting master [%u] with slave [%u]\n",
                     p->no,
                     top->sps[c_s].no);
          p->core_connect_ops[c_s].master = p;
          p->core_connect_ops[c_s].slave = &top->sps[c_s];
          p->core_connect_ops[c_s].connect_op
            = GNUNET_TESTBED_overlay_connect(NULL,
                                             &connect_completion_callback,
                                             &p->core_connect_ops[c_s],
                                             top->sps[c_s].peer,
                                             p->peer);
          if (NULL == p->core_connect_ops[c_s].connect_op)
            {
              GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
                         "Could not connect master [%u] and slave [%u]\n",
                         p->no,
                         top->sps[c_s].no);
              GNUNET_break(0);
              GNUNET_SCHEDULER_shutdown();
              return;
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

comm_connect_completion_cb()

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

static

Definition at line 494 of file ats-testing.c.

References BenchmarkState::connected_COMM_service, do_connect_peers(), GNUNET_break, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_shutdown(), GNUNET_YES, GNUNET_ATS_TEST_Topology::num_masters, GNUNET_ATS_TEST_Topology::num_slaves, GNUNET_ATS_TEST_Topology::state, and GNUNET_ATS_TEST_Topology::test_core.

Referenced by do_comm_connect().

{
  static int comm_done = 0;

  if ((NULL != emsg) || (NULL == ca_result))
    {
      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                 "Initialization failed, shutdown\n");
      GNUNET_break(0);
      GNUNET_SCHEDULER_shutdown();
      return;
    }
  comm_done++;

  if (comm_done == top->num_slaves + top->num_masters)
    {
      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                 "Connected to all %s services\n",
                 (GNUNET_YES == top->test_core) ? "CORE" : "TRANSPORT");
      top->state.connected_COMM_service = GNUNET_YES;
      GNUNET_SCHEDULER_add_now(&do_connect_peers,
                               NULL);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

do_comm_connect()

static void do_comm_connect ( void *  cls )

static

Definition at line 524 of file ats-testing.c.

References comm_connect_completion_cb(), BenchmarkPeer::comm_op, core_connect_adapter(), core_disconnect_adapter(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_TESTBED_service_connect(), GNUNET_YES, GNUNET_ATS_TEST_Topology::mps, GNUNET_ATS_TEST_Topology::num_masters, GNUNET_ATS_TEST_Topology::num_slaves, BenchmarkPeer::peer, GNUNET_ATS_TEST_Topology::sps, GNUNET_ATS_TEST_Topology::test_core, transport_connect_adapter(), and transport_disconnect_adapter().

Referenced by ats_connect_completion_cb().

{
  int c_s;
  int c_m;

  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
             "Connecting to all %s services\n",
             (GNUNET_YES == top->test_core) ? "CORE" : "TRANSPORT");
  for (c_m = 0; c_m < top->num_masters; c_m++)
    {
      if (GNUNET_YES == top->test_core)
        top->mps[c_m].comm_op
          = GNUNET_TESTBED_service_connect(NULL,
                                           top->mps[c_m].peer,
                                           "core",
                                           &comm_connect_completion_cb,
                                           NULL,
                                           &core_connect_adapter,
                                           &core_disconnect_adapter,
                                           &top->mps[c_m]);
      else
        {
          top->mps[c_m].comm_op
            = GNUNET_TESTBED_service_connect(NULL,
                                             top->mps[c_m].peer,
                                             "transport",
                                             &comm_connect_completion_cb,
                                             NULL,
                                             &transport_connect_adapter,
                                             &transport_disconnect_adapter,
                                             &top->mps[c_m]);
        }
    }

  for (c_s = 0; c_s < top->num_slaves; c_s++)
    {
      if (GNUNET_YES == top->test_core)
        top->sps[c_s].comm_op
          = GNUNET_TESTBED_service_connect(NULL,
                                           top->sps[c_s].peer,
                                           "core",
                                           &comm_connect_completion_cb,
                                           NULL,
                                           &core_connect_adapter,
                                           &core_disconnect_adapter,
                                           &top->sps[c_s]);
      else
        {
          top->sps[c_s].comm_op
            = GNUNET_TESTBED_service_connect(NULL,
                                             top->sps[c_s].peer,
                                             "transport",
                                             &comm_connect_completion_cb,
                                             NULL,
                                             &transport_connect_adapter,
                                             &transport_disconnect_adapter,
                                             &top->sps[c_s]);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ats_performance_info_cb()

static void ats_performance_info_cb ( void *  cls, const struct GNUNET_HELLO_Address *  address, int  address_active, struct GNUNET_BANDWIDTH_Value32NBO  bandwidth_out, struct GNUNET_BANDWIDTH_Value32NBO  bandwidth_in, const struct GNUNET_ATS_Properties *  ats_prop  )

static

Definition at line 587 of file ats-testing.c.

References GNUNET_ATS_TEST_Topology::ats_perf_cb, BenchmarkPartner::bandwidth_in, BenchmarkPartner::bandwidth_out, GNUNET_ATS_Properties::delay, BenchmarkPartner::dest, GNUNET_ATS_Properties::distance, find_partner(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_strdup, GNUNET_YES, BenchmarkPeer::id, BenchmarkPeer::master, me, BenchmarkPartner::me, BenchmarkPeer::no, p, GNUNET_HELLO_Address::peer, peer_id, BenchmarkPartner::props, GNUNET_ATS_Properties::scope, GNUNET_ATS_Properties::utilization_in, GNUNET_ATS_Properties::utilization_out, and GNUNET_BANDWIDTH_Value32NBO::value__.

Referenced by ats_perf_connect_adapter().

{
  struct BenchmarkPeer *me = cls;
  struct BenchmarkPartner *p;
  int log;
  char *peer_id;

  if (NULL == address)
    {
      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
                 "Peer %u: ATS Service disconnected!\n",
                 me->no);
      return;
    }

  p = find_partner(me,
                   &address->peer);
  if (NULL == p)
    {
      /* This is not one of my partners
       * Will happen since the peers will connect to each other due to gossiping
       */
      return;
    }
  peer_id = GNUNET_strdup(GNUNET_i2s(&me->id));

  log = GNUNET_NO;
  if ((p->bandwidth_in != ntohl(bandwidth_in.value__)) ||
      (p->bandwidth_out != ntohl(bandwidth_out.value__)))
    log = GNUNET_YES;
  p->bandwidth_in = ntohl(bandwidth_in.value__);
  p->bandwidth_out = ntohl(bandwidth_out.value__);

  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
             "%s [%u] received ATS information: %s\n",
             (GNUNET_YES == p->me->master) ? "Master" : "Slave",
             p->me->no,
             GNUNET_i2s(&p->dest->id));

  p->props.utilization_out = ats_prop->utilization_out;
  p->props.utilization_in = ats_prop->utilization_in;
  p->props.scope = ats_prop->scope;
  p->props.delay = ats_prop->delay;
  p->props.distance = ats_prop->distance;

  if (GNUNET_YES == log)
    top->ats_perf_cb(cls, address,
                     address_active,
                     bandwidth_out,
                     bandwidth_in,
                     ats_prop);
  GNUNET_free(peer_id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ats_perf_connect_adapter()

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

static

Definition at line 648 of file ats-testing.c.

References BenchmarkPeer::ats_perf_handle, ats_performance_info_cb(), GNUNET_ATS_performance_init(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, and me.

Referenced by do_connect_ats().

{
  struct BenchmarkPeer *me = cls;

  me->ats_perf_handle
    = GNUNET_ATS_performance_init(cfg,
                                  &ats_performance_info_cb,
                                  me);
  if (NULL == me->ats_perf_handle)
    GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
               "Failed to create ATS performance handle \n");
  return me->ats_perf_handle;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ats_perf_disconnect_adapter()

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

static

Definition at line 665 of file ats-testing.c.

References BenchmarkPeer::ats_perf_handle, GNUNET_ATS_performance_done(), and me.

Referenced by do_connect_ats().

{
  struct BenchmarkPeer *me = cls;

  GNUNET_ATS_performance_done(me->ats_perf_handle);
  me->ats_perf_handle = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ats_connect_completion_cb()

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

static

Definition at line 676 of file ats-testing.c.

References BenchmarkState::connected_ATS_service, do_comm_connect(), GNUNET_break, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_shutdown(), GNUNET_YES, GNUNET_ATS_TEST_Topology::num_masters, GNUNET_ATS_TEST_Topology::num_slaves, and GNUNET_ATS_TEST_Topology::state.

Referenced by do_connect_ats().

{
  static int op_done = 0;

  if ((NULL != emsg) || (NULL == ca_result))
    {
      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                 "Initialization failed, shutdown\n");
      GNUNET_break(0);
      GNUNET_SCHEDULER_shutdown();
      return;
    }
  op_done++;
  if (op_done == (top->num_masters + top->num_slaves))
    {
      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                 "Connected to all ATS services\n");
      top->state.connected_ATS_service = GNUNET_YES;
      GNUNET_SCHEDULER_add_now(&do_comm_connect,
                               NULL);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

do_connect_ats()

static void do_connect_ats ( void *  cls )

static

Definition at line 704 of file ats-testing.c.

References ats_connect_completion_cb(), ats_perf_connect_adapter(), ats_perf_disconnect_adapter(), BenchmarkPeer::ats_perf_op, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_TESTBED_service_connect(), GNUNET_ATS_TEST_Topology::mps, GNUNET_ATS_TEST_Topology::num_masters, GNUNET_ATS_TEST_Topology::num_slaves, BenchmarkPeer::peer, and GNUNET_ATS_TEST_Topology::sps.

Referenced by peerinformation_cb().

{
  int c_m;
  int c_s;

  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
             "Connecting to all ATS services\n");
  for (c_m = 0; c_m < top->num_masters; c_m++)
    {
      top->mps[c_m].ats_perf_op
        = GNUNET_TESTBED_service_connect(NULL,
                                         top->mps[c_m].peer,
                                         "ats",
                                         &ats_connect_completion_cb,
                                         NULL,
                                         &ats_perf_connect_adapter,
                                         &ats_perf_disconnect_adapter,
                                         &top->mps[c_m]);
    }

  for (c_s = 0; c_s < top->num_slaves; c_s++)
    {
      top->sps[c_s].ats_perf_op
        = GNUNET_TESTBED_service_connect(NULL,
                                         top->sps[c_s].peer,
                                         "ats",
                                         &ats_connect_completion_cb,
                                         NULL,
                                         &ats_perf_connect_adapter,
                                         &ats_perf_disconnect_adapter,
                                         &top->sps[c_s]);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

peerinformation_cb()

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

static

Definition at line 741 of file ats-testing.c.

References do_connect_ats(), done(), GNUNET_assert, GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, GNUNET_SCHEDULER_add_now(), GNUNET_TESTBED_operation_done(), GNUNET_TESTBED_PIT_IDENTITY, GNUNET_YES, BenchmarkPeer::id, GNUNET_TESTBED_PeerInformation::id, BenchmarkPeer::master, BenchmarkPeer::no, GNUNET_ATS_TEST_Topology::num_masters, GNUNET_ATS_TEST_Topology::num_slaves, p, BenchmarkPeer::peer_id_op, GNUNET_TESTBED_PeerInformation::pit, and GNUNET_TESTBED_PeerInformation::result.

Referenced by main_run().

{
  struct BenchmarkPeer *p = cb_cls;
  static int done = 0;

  GNUNET_assert(pinfo->pit == GNUNET_TESTBED_PIT_IDENTITY);

  p->id = *pinfo->result.id;
  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
             "%s [%u] has peer id `%s'\n",
             (p->master == GNUNET_YES) ? "Master" : "Slave",
             p->no,
             GNUNET_i2s(&p->id));

  GNUNET_TESTBED_operation_done(op);
  p->peer_id_op = NULL;
  done++;

  if (done == top->num_slaves + top->num_masters)
    {
      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                 "Retrieved all peer ID, connect to ATS\n");
      GNUNET_SCHEDULER_add_now(&do_connect_ats,
                               NULL);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

main_run()

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

cls	closure
h	testbed handle
num_peers	number of peers in 'peers'
peers_	handle to peers run in the testbed
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 785 of file ats-testing.c.

References GNUNET_ATS_Properties::delay, BenchmarkPartner::dest, GNUNET_ATS_Properties::distance, do_shutdown(), GNUNET_assert, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_malloc, GNUNET_new_array, GNUNET_NO, GNUNET_NT_UNSPECIFIED, GNUNET_SCHEDULER_add_shutdown(), GNUNET_TESTBED_peer_get_information(), GNUNET_TESTBED_PIT_IDENTITY, GNUNET_TIME_UNIT_ZERO, GNUNET_YES, BenchmarkPeer::master, BenchmarkPartner::me, GNUNET_ATS_TEST_Topology::mps, BenchmarkPeer::no, GNUNET_ATS_TEST_Topology::num_masters, BenchmarkPeer::num_partners, GNUNET_ATS_TEST_Topology::num_slaves, BenchmarkPeer::partners, BenchmarkPeer::peer, BenchmarkPeer::peer_id_op, peerinformation_cb(), BenchmarkPeer::pref_partner, BenchmarkPeer::pref_value, BenchmarkPartner::props, GNUNET_ATS_Properties::scope, GNUNET_ATS_TEST_Topology::sps, TEST_ATS_PREFERENCE_DEFAULT, GNUNET_ATS_Properties::utilization_in, and GNUNET_ATS_Properties::utilization_out.

Referenced by GNUNET_ATS_TEST_create_topology().

{
  int c_m;
  int c_s;

  GNUNET_assert(NULL == cls);
  GNUNET_assert(top->num_masters + top->num_slaves == num_peers);
  GNUNET_assert(NULL != peers_);

  GNUNET_SCHEDULER_add_shutdown(&do_shutdown,
                                top);

  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
             "Setting up %u masters and %u slaves\n",
             top->num_masters,
             top->num_slaves);

  /* Setup master peers */
  for (c_m = 0; c_m < top->num_masters; c_m++)
    {
      GNUNET_assert(NULL != peers_[c_m]);
      top->mps[c_m].peer = peers_[c_m];
      top->mps[c_m].no = c_m;
      top->mps[c_m].master = GNUNET_YES;
      top->mps[c_m].pref_partner = &top->sps[c_m];
      top->mps[c_m].pref_value = TEST_ATS_PREFERENCE_DEFAULT;
      top->mps[c_m].partners =
        GNUNET_malloc(top->num_slaves * sizeof(struct BenchmarkPartner));
      top->mps[c_m].num_partners = top->num_slaves;
      /* Initialize partners */
      for (c_s = 0; c_s < top->num_slaves; c_s++)
        {
          top->mps[c_m].partners[c_s].me = &top->mps[c_m];
          top->mps[c_m].partners[c_s].dest = &top->sps[c_s];
        }
      /* Get configuration */
      top->mps[c_m].peer_id_op
        = GNUNET_TESTBED_peer_get_information(top->mps[c_m].peer,
                                              GNUNET_TESTBED_PIT_IDENTITY,
                                              &peerinformation_cb,
                                              &top->mps[c_m]);
    }

  /* Setup slave peers */
  for (c_s = 0; c_s < top->num_slaves; c_s++)
    {
      GNUNET_assert(NULL != peers_[c_s + top->num_masters]);
      top->sps[c_s].peer = peers_[c_s + top->num_masters];
      top->sps[c_s].no = c_s + top->num_masters;
      top->sps[c_s].master = GNUNET_NO;
      top->sps[c_s].partners =
        GNUNET_new_array(top->num_masters,
                         struct BenchmarkPartner);
      top->sps[c_s].num_partners = top->num_masters;
      /* Initialize partners */
      for (c_m = 0; c_m < top->num_masters; c_m++)
        {
          top->sps[c_s].partners[c_m].me = &top->sps[c_s];
          top->sps[c_s].partners[c_m].dest = &top->mps[c_m];

          /* Initialize properties */
          top->sps[c_s].partners[c_m].props.delay = GNUNET_TIME_UNIT_ZERO;
          top->sps[c_s].partners[c_m].props.distance = 0;
          top->sps[c_s].partners[c_m].props.scope = GNUNET_NT_UNSPECIFIED;
          top->sps[c_s].partners[c_m].props.utilization_in = 0;
          top->sps[c_s].partners[c_m].props.utilization_out = 0;
        }
      /* Get configuration */
      top->sps[c_s].peer_id_op
        = GNUNET_TESTBED_peer_get_information(top->sps[c_s].peer,
                                              GNUNET_TESTBED_PIT_IDENTITY,
                                              &peerinformation_cb,
                                              &top->sps[c_s]);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

controller_event_cb()

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

static

Controller event callback.

Parameters

cls	NULL
event	the controller event

Definition at line 874 of file ats-testing.c.

References GNUNET_break, GNUNET_SCHEDULER_shutdown(), GNUNET_TESTBED_ET_CONNECT, GNUNET_TESTBED_ET_OPERATION_FINISHED, and GNUNET_TESTBED_EventInformation::type.

Referenced by GNUNET_ATS_TEST_create_topology().

{
  switch (event->type)
    {
    case GNUNET_TESTBED_ET_CONNECT:
      break;

    case GNUNET_TESTBED_ET_OPERATION_FINISHED:
      break;

    default:
      GNUNET_break(0);
      GNUNET_SCHEDULER_shutdown();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_TEST_get_peer()

struct BenchmarkPeer* GNUNET_ATS_TEST_get_peer

(

int

src

)

Topology related functions.

Definition at line 893 of file ats-testing.c.

References GNUNET_ATS_TEST_Topology::mps, and GNUNET_ATS_TEST_Topology::num_masters.

Referenced by enforce_start_preference(), and enforce_start_send().

{
  if (src > top->num_masters)
    return NULL;
  return &top->mps[src];
}

Here is the caller graph for this function:

GNUNET_ATS_TEST_get_partner()

struct BenchmarkPartner* GNUNET_ATS_TEST_get_partner	(	int	src,
		int	dest
	)

Definition at line 902 of file ats-testing.c.

References BenchmarkPartner::dest, GNUNET_ATS_TEST_Topology::mps, GNUNET_ATS_TEST_Topology::num_masters, GNUNET_ATS_TEST_Topology::num_slaves, and BenchmarkPeer::partners.

Referenced by enforce_start_preference(), enforce_start_send(), enforce_stop_preference(), and enforce_stop_send().

{
  if (src > top->num_masters)
    return NULL;
  if (dest > top->num_slaves)
    return NULL;
  return &top->mps[src].partners[dest];
}

Here is the caller graph for this function:

GNUNET_ATS_TEST_create_topology()

void GNUNET_ATS_TEST_create_topology	(	char *	name,
		char *	cfg_file,
		unsigned int	num_slaves,
		unsigned int	num_masters,
		int	test_core,
		GNUNET_ATS_TEST_TopologySetupDoneCallback	done_cb,
		void *	done_cb_cls,
		GNUNET_ATS_AddressInformationCallback	log_request_cb
	)

Create a topology for ats testing.

Parameters

name	test name
cfg_file	configuration file to use for the peers
num_slaves	number of slaves
num_masters	number of masters
test_core	connect to CORE service (GNUNET_YES) or transport (GNUNET_NO)
done_cb	function to call when topology is setup
done_cb_cls	cls for callback
log_request_cb	callback to call when logging is required

Definition at line 926 of file ats-testing.c.

References GNUNET_ATS_TEST_Topology::ats_perf_cb, controller_event_cb(), GNUNET_ATS_TEST_Topology::done_cb, GNUNET_ATS_TEST_Topology::done_cb_cls, event_mask, GNUNET_new, GNUNET_new_array, GNUNET_TESTBED_ET_CONNECT, GNUNET_TESTBED_ET_OPERATION_FINISHED, GNUNET_TESTBED_test_run(), main_run(), GNUNET_ATS_TEST_Topology::mps, GNUNET_ATS_TEST_Topology::num_masters, GNUNET_ATS_TEST_Topology::num_slaves, GNUNET_ATS_TEST_Topology::sps, and GNUNET_ATS_TEST_Topology::test_core.

Referenced by main().

{
  top = GNUNET_new(struct GNUNET_ATS_TEST_Topology);
  top->num_masters = num_masters;
  top->num_slaves = num_slaves;
  top->done_cb = done_cb;
  top->done_cb_cls = done_cb_cls;
  top->test_core = test_core;
  top->ats_perf_cb = log_request_cb;
  top->mps = GNUNET_new_array(num_masters,
                              struct BenchmarkPeer);
  top->sps = GNUNET_new_array(num_slaves,
                              struct BenchmarkPeer);

  /* Start topology */
  uint64_t event_mask;
  event_mask = 0;
  event_mask |= (1LL << GNUNET_TESTBED_ET_CONNECT);
  event_mask |= (1LL << GNUNET_TESTBED_ET_OPERATION_FINISHED);
  (void)GNUNET_TESTBED_test_run(name,
                                cfg_file,
                                num_slaves + num_masters,
                                event_mask,
                                &controller_event_cb, NULL,
                                &main_run, NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_TEST_shutdown_topology()

void GNUNET_ATS_TEST_shutdown_topology

(

void

)

Shutdown topology.

Definition at line 964 of file ats-testing.c.

References GNUNET_SCHEDULER_shutdown().

Referenced by do_shutdown().

{
  if (NULL == top)
    return;
  GNUNET_SCHEDULER_shutdown();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

cfg

struct GNUNET_CONFIGURATION_Handle* cfg

Handle to our configuration.

Definition at line 50 of file ats-testing.c.

top

struct GNUNET_ATS_TEST_Topology* top

Definition at line 52 of file ats-testing.c.

Referenced by exchange().