ats-testing.h File Reference

ats testing library: setup topology and provide logging to test ats More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_testbed_service.h"
#include "gnunet_ats_service.h"
#include "gnunet_core_service.h"
#include "gnunet_transport_service.h"

Include dependency graph for ats-testing.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	TestMessage
struct	BenchmarkPeer
	Information we track for a peer in the testbed. More...
struct	TrafficGenerator
struct	PreferenceGenerator
struct	BenchmarkPartner
	Information about a benchmarking partner. More...
struct	BenchmarkState
	Overall state of the performance benchmark. More...
struct	GNUNET_ATS_TEST_Topology
struct	GNUNET_ATS_TEST_Operation
	An operation in an experiment. More...
struct	Episode
struct	Experiment

Macros
#define	TEST_ATS_PREFERENCE_DEFAULT   1.0
#define	TEST_MESSAGE_TYPE_PING   12345
	Message type sent for traffic generation. More...
#define	TEST_MESSAGE_TYPE_PONG   12346
	Message type sent as response during traffic generation. More...
#define	TEST_MESSAGE_SIZE   100
	Size of test messages. More...

Typedefs
typedef void(*	GNUNET_ATS_TEST_TopologySetupDoneCallback) (void *cls, struct BenchmarkPeer *masters, struct BenchmarkPeer *slaves)
	Callback to call when topology setup is completed. More...
typedef void(*	GNUNET_ATS_TEST_LogRequest) (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 *prop)
	Callback called when logging is required for the data contained. More...
typedef void(*	GNUNET_ATS_TESTING_EpisodeDoneCallback) (struct Episode *e)
typedef void(*	GNUNET_ATS_TESTING_ExperimentDoneCallback) (struct Experiment *e, struct GNUNET_TIME_Relative duration, int success)

Enumerations
enum	GeneratorType {   GNUNET_ATS_TEST_TG_LINEAR, GNUNET_ATS_TEST_TG_CONSTANT, GNUNET_ATS_TEST_TG_RANDOM, GNUNET_ATS_TEST_TG_SINUS,   GNUNET_ATS_TEST_TG_LINEAR, GNUNET_ATS_TEST_TG_CONSTANT, GNUNET_ATS_TEST_TG_RANDOM, GNUNET_ATS_TEST_TG_SINUS }
enum	OperationType {   SOLVER_OP_ADD_ADDRESS, SOLVER_OP_DEL_ADDRESS, SOLVER_OP_START_SET_PROPERTY, SOLVER_OP_STOP_SET_PROPERTY,   SOLVER_OP_START_SET_PREFERENCE, SOLVER_OP_STOP_SET_PREFERENCE, SOLVER_OP_START_REQUEST, SOLVER_OP_STOP_REQUEST,   START_SEND, STOP_SEND, START_PREFERENCE, STOP_PREFERENCE,   OP_PEER_CREATE, OP_PEER_START, OP_PEER_STOP, OP_PEER_DESTROY,   OP_PEER_INFO, OP_PEER_RECONFIGURE, OP_OVERLAY_CONNECT, OP_FORWARDED,   OP_LINK_CONTROLLERS, OP_GET_SLAVE_CONFIG, OP_SHUTDOWN_PEERS, OP_MANAGE_SERVICE }

Functions
void	GNUNET_ATS_TEST_experimentation_run (struct Experiment *e, GNUNET_ATS_TESTING_EpisodeDoneCallback ep_done_cb, GNUNET_ATS_TESTING_ExperimentDoneCallback e_done_cb)
	Execute the specified experiment. More...
struct Experiment *	GNUNET_ATS_TEST_experimentation_load (const char *filename)
	Load an experiment from a file. More...
void	GNUNET_ATS_TEST_experimentation_stop (struct Experiment *e)
	Stop an experiment. More...
void	GNUNET_ATS_TEST_traffic_handle_ping (struct BenchmarkPartner *p)
void	GNUNET_ATS_TEST_traffic_handle_pong (struct BenchmarkPartner *p)
struct TrafficGenerator *	GNUNET_ATS_TEST_generate_traffic_start (struct BenchmarkPeer *src, struct BenchmarkPartner *dest, enum GeneratorType type, unsigned int base_rate, unsigned int max_rate, struct GNUNET_TIME_Relative period, struct GNUNET_TIME_Relative duration)
	Generate between the source master and the partner and send traffic with a maximum rate. More...
void	GNUNET_ATS_TEST_generate_traffic_stop (struct TrafficGenerator *tg)
void	GNUNET_ATS_TEST_generate_traffic_stop_all (void)
	Stop all traffic generators. More...
struct PreferenceGenerator *	GNUNET_ATS_TEST_generate_preferences_start (struct BenchmarkPeer *src, struct BenchmarkPartner *dest, enum GeneratorType type, unsigned int base_value, unsigned int value_rate, struct GNUNET_TIME_Relative period, struct GNUNET_TIME_Relative frequency, enum GNUNET_ATS_PreferenceKind kind)
	Generate between the source master and the partner and set preferences with a value depending on the generator. More...
void	GNUNET_ATS_TEST_generate_preferences_stop (struct PreferenceGenerator *pg)
void	GNUNET_ATS_TEST_generate_preferences_stop_all (void)
	Stop all preferences generators. More...
struct LoggingHandle *	GNUNET_ATS_TEST_logging_start (struct GNUNET_TIME_Relative log_frequency, const char *testname, struct BenchmarkPeer *masters, int num_masters, int num_slaves, int verbose)
	Start logging. More...
void	GNUNET_ATS_TEST_logging_clean_up (struct LoggingHandle *l)
	Stop logging. More...
void	GNUNET_ATS_TEST_logging_stop (struct LoggingHandle *l)
	Stop logging. More...
void	GNUNET_ATS_TEST_logging_now (struct LoggingHandle *l)
	Log all data now. More...
void	GNUNET_ATS_TEST_logging_write_to_file (struct LoggingHandle *l, const char *test_name, int plots)
	Write logging data to file. 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_TEST_LogRequest ats_perf_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...

Detailed Description

ats testing library: setup topology and provide logging to test ats

Author

Christian Grothoff

Matthias Wachs

Definition in file ats-testing.h.

Macro Definition Documentation

TEST_ATS_PREFERENCE_DEFAULT

#define TEST_ATS_PREFERENCE_DEFAULT   1.0

Definition at line 33 of file ats-testing.h.

Referenced by main_run().

TEST_MESSAGE_TYPE_PING

#define TEST_MESSAGE_TYPE_PING   12345

Message type sent for traffic generation.

Definition at line 38 of file ats-testing.h.

Referenced by comm_schedule_send(), core_connect_adapter(), GNUNET_ATS_TEST_traffic_handle_ping(), and transport_connect_adapter().

TEST_MESSAGE_TYPE_PONG

#define TEST_MESSAGE_TYPE_PONG   12346

Message type sent as response during traffic generation.

Definition at line 43 of file ats-testing.h.

Referenced by core_connect_adapter(), and transport_connect_adapter().

TEST_MESSAGE_SIZE

#define TEST_MESSAGE_SIZE   100

Size of test messages.

Definition at line 48 of file ats-testing.h.

Referenced by get_delay(), GNUNET_ATS_TEST_traffic_handle_ping(), GNUNET_ATS_TEST_traffic_handle_pong(), update_ping_data(), and update_pong_data().

Typedef Documentation

GNUNET_ATS_TEST_TopologySetupDoneCallback

typedef void(* GNUNET_ATS_TEST_TopologySetupDoneCallback) (void *cls, struct BenchmarkPeer *masters, struct BenchmarkPeer *slaves)

Callback to call when topology setup is completed.

Parameters

cls	the closure
masters	array of master peers
slaves	array of master peers

Definition at line 83 of file ats-testing.h.

GNUNET_ATS_TEST_LogRequest

typedef void(* GNUNET_ATS_TEST_LogRequest) (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 *prop)

Callback called when logging is required for the data contained.

Parameters

cls	the closure
address	an address
address_active	is address active
bandwidth_out	bandwidth outbound
bandwidth_in	bandwidth inbound
prop	performance information

Definition at line 98 of file ats-testing.h.

GNUNET_ATS_TESTING_EpisodeDoneCallback

typedef void(* GNUNET_ATS_TESTING_EpisodeDoneCallback) (struct Episode *e)

Definition at line 473 of file ats-testing.h.

GNUNET_ATS_TESTING_ExperimentDoneCallback

typedef void(* GNUNET_ATS_TESTING_ExperimentDoneCallback) (struct Experiment *e, struct GNUNET_TIME_Relative duration, int success)

Definition at line 475 of file ats-testing.h.

Enumeration Type Documentation

GeneratorType

enum GeneratorType

Enumerator
GNUNET_ATS_TEST_TG_LINEAR
GNUNET_ATS_TEST_TG_CONSTANT
GNUNET_ATS_TEST_TG_RANDOM
GNUNET_ATS_TEST_TG_SINUS
GNUNET_ATS_TEST_TG_LINEAR
GNUNET_ATS_TEST_TG_CONSTANT
GNUNET_ATS_TEST_TG_RANDOM
GNUNET_ATS_TEST_TG_SINUS

Definition at line 68 of file ats-testing.h.

                   {
  GNUNET_ATS_TEST_TG_LINEAR,
  GNUNET_ATS_TEST_TG_CONSTANT,
  GNUNET_ATS_TEST_TG_RANDOM,
  GNUNET_ATS_TEST_TG_SINUS
};

OperationType

enum OperationType

Enumerator
SOLVER_OP_ADD_ADDRESS
SOLVER_OP_DEL_ADDRESS
SOLVER_OP_START_SET_PROPERTY
SOLVER_OP_STOP_SET_PROPERTY
SOLVER_OP_START_SET_PREFERENCE
SOLVER_OP_STOP_SET_PREFERENCE
SOLVER_OP_START_REQUEST
SOLVER_OP_STOP_REQUEST
START_SEND
STOP_SEND
START_PREFERENCE
STOP_PREFERENCE
OP_PEER_CREATE	Peer create operation.
OP_PEER_START	Peer start operation.
OP_PEER_STOP	Peer stop operation.
OP_PEER_DESTROY	Peer destroy operation.
OP_PEER_INFO	Get peer information operation.
OP_PEER_RECONFIGURE	Reconfigure a peer.
OP_OVERLAY_CONNECT	Overlay connection operation.
OP_FORWARDED	Forwarded operation.
OP_LINK_CONTROLLERS	Link controllers operation.
OP_GET_SLAVE_CONFIG	Get slave config operation.
OP_SHUTDOWN_PEERS	Stop and destroy all peers.
OP_MANAGE_SERVICE	Start/stop service at a peer.

Definition at line 462 of file ats-testing.h.

                   {
  START_SEND,
  STOP_SEND,
  START_PREFERENCE,
  STOP_PREFERENCE
};

Function Documentation

GNUNET_ATS_TEST_experimentation_run()

void GNUNET_ATS_TEST_experimentation_run	(	struct Experiment *	e,
		GNUNET_ATS_TESTING_EpisodeDoneCallback	ep_done_cb,
		GNUNET_ATS_TESTING_ExperimentDoneCallback	e_done_cb
	)

Execute the specified experiment.

Parameters

e	the Experiment
ep_done_cb	a episode is completed
e_done_cb	the experiment is completed

Definition at line 629 of file ats-testing-experiment.c.

References Experiment::cur, Episode::duration, Experiment::e_done_cb, enforce_episode(), Experiment::ep_done_cb, Experiment::episode_timeout_task, Experiment::experiment_timeout_task, GNUNET_SCHEDULER_add_delayed(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get(), GNUNET_YES, Episode::id, Experiment::max_duration, Experiment::name, Experiment::start, Experiment::start_time, timeout_episode(), and timeout_experiment().

Referenced by topology_setup_done().

{
  fprintf(stderr, "Running experiment `%s'  with timeout %s\n", e->name,
          GNUNET_STRINGS_relative_time_to_string(e->max_duration, GNUNET_YES));
  e->e_done_cb = e_done_cb;
  e->ep_done_cb = ep_done_cb;
  e->start_time = GNUNET_TIME_absolute_get();

  /* Start total time out */
  e->experiment_timeout_task = GNUNET_SCHEDULER_add_delayed(e->max_duration,
                                                            &timeout_experiment, e);

  /* Start */
  e->cur = e->start;
  fprintf(stderr, "Running episode %u with timeout %s\n",
          e->cur->id,
          GNUNET_STRINGS_relative_time_to_string(e->cur->duration, GNUNET_YES));
  enforce_episode(e->cur);
  e->episode_timeout_task = GNUNET_SCHEDULER_add_delayed(e->cur->duration,
                                                         &timeout_episode, e);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_TEST_experimentation_load()

struct Experiment* GNUNET_ATS_TEST_experimentation_load

(

const char *

filename

)

Load an experiment from a file.

Parameters

filename

the file

Returns

the Experiment or NULL on failure

Definition at line 655 of file ats-testing-experiment.c.

References cfg, Experiment::cfg_file, create_experiment(), e, free_experiment(), GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_destroy(), GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_get_value_time(), GNUNET_CONFIGURATION_load(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_SYSERR, GNUNET_YES, load_episodes(), Experiment::log_freq, Experiment::max_duration, Experiment::name, Experiment::num_episodes, Experiment::num_masters, Experiment::num_slaves, and Experiment::total_duration.

Referenced by main().

{
  struct Experiment *e;
  struct GNUNET_CONFIGURATION_Handle *cfg;

  e = NULL;

  cfg = GNUNET_CONFIGURATION_create();
  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load(cfg, filename))
    {
      fprintf(stderr, "Failed to load `%s'\n", filename);
      GNUNET_CONFIGURATION_destroy(cfg);
      return NULL;
    }

  e = create_experiment();

  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string(cfg, "experiment",
                                                             "name", &e->name))
    {
      fprintf(stderr, "Invalid %s", "name");
      free_experiment(e);
      return NULL;
    }
  else
    fprintf(stderr, "Experiment name: `%s'\n", e->name);

  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_filename(cfg, "experiment",
                                                               "cfg_file", &e->cfg_file))
    {
      fprintf(stderr, "Invalid %s", "cfg_file");
      free_experiment(e);
      return NULL;
    }
  else
    fprintf(stderr, "Experiment name: `%s'\n", e->cfg_file);

  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg, "experiment",
                                                             "masters", &e->num_masters))
    {
      fprintf(stderr, "Invalid %s", "masters");
      free_experiment(e);
      return NULL;
    }
  else
    fprintf(stderr, "Experiment masters: `%llu'\n",
            e->num_masters);

  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number(cfg, "experiment",
                                                             "slaves", &e->num_slaves))
    {
      fprintf(stderr, "Invalid %s", "slaves");
      free_experiment(e);
      return NULL;
    }
  else
    fprintf(stderr, "Experiment slaves: `%llu'\n",
            e->num_slaves);

  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time(cfg, "experiment",
                                                           "log_freq", &e->log_freq))
    {
      fprintf(stderr, "Invalid %s", "log_freq");
      free_experiment(e);
      return NULL;
    }
  else
    fprintf(stderr, "Experiment logging frequency: `%s'\n",
            GNUNET_STRINGS_relative_time_to_string(e->log_freq, GNUNET_YES));

  if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time(cfg, "experiment",
                                                           "max_duration", &e->max_duration))
    {
      fprintf(stderr, "Invalid %s", "max_duration");
      free_experiment(e);
      return NULL;
    }
  else
    fprintf(stderr, "Experiment duration: `%s'\n",
            GNUNET_STRINGS_relative_time_to_string(e->max_duration, GNUNET_YES));

  load_episodes(e, cfg);
  fprintf(stderr, "Loaded %u episodes with total duration %s\n",
          e->num_episodes,
          GNUNET_STRINGS_relative_time_to_string(e->total_duration, GNUNET_YES));

  GNUNET_CONFIGURATION_destroy(cfg);
  return e;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_TEST_experimentation_stop()

void GNUNET_ATS_TEST_experimentation_stop

(

struct Experiment *

e

)

Stop an experiment.

Parameters

e	the experiment

Definition at line 746 of file ats-testing-experiment.c.

References Experiment::episode_timeout_task, Experiment::experiment_timeout_task, free_experiment(), and GNUNET_SCHEDULER_cancel().

Referenced by do_shutdown().

{
  if (NULL != e->experiment_timeout_task)
    {
      GNUNET_SCHEDULER_cancel(e->experiment_timeout_task);
      e->experiment_timeout_task = NULL;
    }
  if (NULL != e->episode_timeout_task)
    {
      GNUNET_SCHEDULER_cancel(e->episode_timeout_task);
      e->episode_timeout_task = NULL;
    }
  free_experiment(e);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_TEST_traffic_handle_ping()

void GNUNET_ATS_TEST_traffic_handle_ping

(

struct BenchmarkPartner *

p

)

Definition at line 174 of file ats-testing-traffic.c.

References BenchmarkPartner::bytes_received, BenchmarkPartner::dest, env, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MQ_msg, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), BenchmarkPartner::me, BenchmarkPartner::messages_received, BenchmarkPartner::mq, msg, BenchmarkPeer::no, TestMessage::padding, TEST_MESSAGE_SIZE, TEST_MESSAGE_TYPE_PING, BenchmarkPeer::total_bytes_received, BenchmarkPeer::total_messages_received, and update_pong_data().

Referenced by handle_ping().

{
  struct TestMessage *msg;
  struct GNUNET_MQ_Envelope *env;

  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
             "Slave [%u]: Received PING from [%u], sending PONG\n",
             p->me->no,
             p->dest->no);
  p->messages_received++;
  p->bytes_received += TEST_MESSAGE_SIZE;
  p->me->total_messages_received++;
  p->me->total_bytes_received += TEST_MESSAGE_SIZE;


  env = GNUNET_MQ_msg(msg,
                      TEST_MESSAGE_TYPE_PING);
  memset(msg->padding,
         'a',
         sizeof(msg->padding));
  GNUNET_MQ_notify_sent(env,
                        &update_pong_data,
                        p);
  GNUNET_MQ_send(p->mq,
                 env);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_TEST_traffic_handle_pong()

void GNUNET_ATS_TEST_traffic_handle_pong

(

struct BenchmarkPartner *

p

)

Definition at line 203 of file ats-testing-traffic.c.

References TrafficGenerator::base_rate, BenchmarkPartner::bytes_received, comm_schedule_send(), BenchmarkPartner::dest, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_difference(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_relative_min(), GNUNET_TIME_UNIT_SECONDS, BenchmarkPartner::last_message_sent, BenchmarkPartner::me, BenchmarkPartner::messages_received, TrafficGenerator::next_ping_transmission, BenchmarkPeer::no, GNUNET_TIME_Relative::rel_value_us, TrafficGenerator::send_task, TEST_MESSAGE_SIZE, BenchmarkPartner::tg, BenchmarkPartner::total_app_rtt, BenchmarkPeer::total_bytes_received, and BenchmarkPeer::total_messages_received.

Referenced by handle_pong().

{
  struct GNUNET_TIME_Relative left;

  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
             "Master [%u]: Received PONG from [%u], next message\n",
             p->me->no,
             p->dest->no);

  p->messages_received++;
  p->bytes_received += TEST_MESSAGE_SIZE;
  p->me->total_messages_received++;
  p->me->total_bytes_received += TEST_MESSAGE_SIZE;
  p->total_app_rtt += GNUNET_TIME_absolute_get_difference(p->last_message_sent,
                                                          GNUNET_TIME_absolute_get()).rel_value_us;

  /* Schedule next send event */
  if (NULL == p->tg)
    return;

  left = GNUNET_TIME_absolute_get_remaining(p->tg->next_ping_transmission);
  if (UINT32_MAX == p->tg->base_rate)
    {
      p->tg->send_task = GNUNET_SCHEDULER_add_now(&comm_schedule_send, p);
    }
  else if (0 == left.rel_value_us)
    {
      p->tg->send_task = GNUNET_SCHEDULER_add_now(&comm_schedule_send, p);
    }
  else
    {
      /* Enforce minimum transmission rate 1 msg / sec */
      if (GNUNET_TIME_UNIT_SECONDS.rel_value_us == (left = GNUNET_TIME_relative_min(left, GNUNET_TIME_UNIT_SECONDS)).rel_value_us)
        GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
                   "Enforcing minimum send rate between master [%u] and slave [%u]\n",
                   p->me->no, p->dest->no);
      p->tg->send_task = GNUNET_SCHEDULER_add_delayed(left,
                                                      &comm_schedule_send, p);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_TEST_generate_traffic_start()

struct TrafficGenerator* GNUNET_ATS_TEST_generate_traffic_start	(	struct BenchmarkPeer *	src,
		struct BenchmarkPartner *	dest,
		enum GeneratorType	type,
		unsigned int	base_rate,
		unsigned int	max_rate,
		struct GNUNET_TIME_Relative	period,
		struct GNUNET_TIME_Relative	duration
	)

Generate between the source master and the partner and send traffic with a maximum rate.

Parameters

src	traffic source
dest	traffic partner
type	type of traffic to generate
base_rate	traffic base rate to send data with
max_rate	traffic maximum rate to send data with
period	duration of a period of traffic generation (~ 1/frequency)
duration	how long to generate traffic

Returns

the traffic generator

Definition at line 259 of file ats-testing-traffic.c.

References TrafficGenerator::base_rate, comm_schedule_send(), TrafficGenerator::dest, BenchmarkPartner::dest, TrafficGenerator::duration_period, GNUNET_ATS_TEST_TG_CONSTANT, GNUNET_ATS_TEST_TG_LINEAR, GNUNET_ATS_TEST_TG_RANDOM, GNUNET_ATS_TEST_TG_SINUS, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, GNUNET_new, GNUNET_SCHEDULER_add_now(), GNUNET_TIME_absolute_get(), GNUNET_TIME_UNIT_FOREVER_ABS, BenchmarkPeer::id, TrafficGenerator::max_rate, BenchmarkPartner::me, TrafficGenerator::next_ping_transmission, BenchmarkPeer::no, TrafficGenerator::send_task, TrafficGenerator::src, BenchmarkPartner::tg, TrafficGenerator::time_start, type, and TrafficGenerator::type.

Referenced by enforce_start_send(), and topology_setup_done().

{
  struct TrafficGenerator *tg;

  if (NULL != dest->tg)
    {
      GNUNET_break(0);
      return NULL;
    }

  tg = GNUNET_new(struct TrafficGenerator);
  GNUNET_CONTAINER_DLL_insert(tg_head,
                              tg_tail,
                              tg);
  tg->type = type;
  tg->src = src;
  tg->dest = dest;
  tg->base_rate = base_rate;
  tg->max_rate = max_rate;
  tg->duration_period = period;
  tg->time_start = GNUNET_TIME_absolute_get();
  tg->next_ping_transmission = GNUNET_TIME_UNIT_FOREVER_ABS;

  switch (type)
    {
    case GNUNET_ATS_TEST_TG_CONSTANT:
      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                 "Setting up constant traffic generator master[%u] `%s' and slave [%u] `%s' max %u Bips\n",
                 dest->me->no,
                 GNUNET_i2s(&dest->me->id),
                 dest->dest->no,
                 GNUNET_i2s(&dest->dest->id),
                 base_rate);
      break;

    case GNUNET_ATS_TEST_TG_LINEAR:
      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                 "Setting up linear traffic generator master[%u] `%s' and slave [%u] `%s' min %u Bips max %u Bips\n",
                 dest->me->no,
                 GNUNET_i2s(&dest->me->id),
                 dest->dest->no,
                 GNUNET_i2s(&dest->dest->id),
                 base_rate,
                 max_rate);
      break;

    case GNUNET_ATS_TEST_TG_SINUS:
      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                 "Setting up sinus traffic generator master[%u] `%s' and slave [%u] `%s' baserate %u Bips, amplitude %u Bps\n",
                 dest->me->no,
                 GNUNET_i2s(&dest->me->id),
                 dest->dest->no,
                 GNUNET_i2s(&dest->dest->id),
                 base_rate,
                 max_rate);
      break;

    case GNUNET_ATS_TEST_TG_RANDOM:
      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                 "Setting up random traffic generator master[%u] `%s' and slave [%u] `%s' min %u Bips max %u Bps\n",
                 dest->me->no,
                 GNUNET_i2s(&dest->me->id),
                 dest->dest->no,
                 GNUNET_i2s(&dest->dest->id),
                 base_rate,
                 max_rate);
      break;

    default:
      break;
    }

  dest->tg = tg;
  tg->send_task
    = GNUNET_SCHEDULER_add_now(&comm_schedule_send,
                               dest);
  return tg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_TEST_generate_traffic_stop()

void GNUNET_ATS_TEST_generate_traffic_stop

(

struct TrafficGenerator *

tg

)

Definition at line 346 of file ats-testing-traffic.c.

References TrafficGenerator::dest, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_SCHEDULER_cancel(), TrafficGenerator::send_task, and BenchmarkPartner::tg.

Referenced by enforce_start_send(), enforce_stop_send(), and GNUNET_ATS_TEST_generate_traffic_stop_all().

{
  GNUNET_CONTAINER_DLL_remove(tg_head,
                              tg_tail,
                              tg);
  tg->dest->tg = NULL;
  if (NULL != tg->send_task)
    {
      GNUNET_SCHEDULER_cancel(tg->send_task);
      tg->send_task = NULL;
    }
  GNUNET_free(tg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_TEST_generate_traffic_stop_all()

void GNUNET_ATS_TEST_generate_traffic_stop_all

(

void

)

Stop all traffic generators.

Definition at line 365 of file ats-testing-traffic.c.

References GNUNET_ATS_TEST_generate_traffic_stop(), TrafficGenerator::next, and tg_head.

Referenced by do_shutdown(), and experiment_done_cb().

{
  struct TrafficGenerator *cur;
  struct TrafficGenerator *next;

  next = tg_head;
  for (cur = next; NULL != cur; cur = next)
    {
      next = cur->next;
      GNUNET_ATS_TEST_generate_traffic_stop(cur);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_TEST_generate_preferences_start()

struct PreferenceGenerator* GNUNET_ATS_TEST_generate_preferences_start	(	struct BenchmarkPeer *	src,
		struct BenchmarkPartner *	dest,
		enum GeneratorType	type,
		unsigned int	base_value,
		unsigned int	value_rate,
		struct GNUNET_TIME_Relative	period,
		struct GNUNET_TIME_Relative	frequency,
		enum GNUNET_ATS_PreferenceKind	kind
	)

Generate between the source master and the partner and set preferences with a value depending on the generator.

Parameters

src	source
dest	partner
type	type of preferences to generate
base_value	traffic base rate to send data with
value_rate	traffic maximum rate to send data with
period	duration of a period of preferences generation (~ 1/frequency)
frequency	how long to generate preferences
kind	ATS preference to generate

Returns

the traffic generator

Parameters

src	source
dest	partner
type	type of preferences to generate
base_value	traffic base rate to send data with
value_rate	traffic maximum rate to send data with
period	duration of a period of preferences generation (~ 1/frequency)
frequency	how long to generate preferences
kind	ATS preference to generate

Returns

the preference generator

Definition at line 153 of file ats-testing-preferences.c.

References PreferenceGenerator::base_value, PreferenceGenerator::dest, BenchmarkPartner::dest, PreferenceGenerator::duration_period, PreferenceGenerator::frequency, GNUNET_ATS_TEST_TG_CONSTANT, GNUNET_ATS_TEST_TG_LINEAR, GNUNET_ATS_TEST_TG_RANDOM, GNUNET_ATS_TEST_TG_SINUS, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, GNUNET_new, GNUNET_SCHEDULER_add_now(), GNUNET_TIME_absolute_get(), BenchmarkPeer::id, PreferenceGenerator::kind, PreferenceGenerator::max_value, BenchmarkPartner::me, BenchmarkPeer::no, BenchmarkPartner::pg, set_pref_task(), PreferenceGenerator::set_task, PreferenceGenerator::src, PreferenceGenerator::time_start, type, and PreferenceGenerator::type.

Referenced by enforce_start_preference().

{
  struct PreferenceGenerator *pg;

  if (NULL != dest->pg)
    {
      GNUNET_break(0);
      return NULL;
    }

  pg = GNUNET_new(struct PreferenceGenerator);
  GNUNET_CONTAINER_DLL_insert(pg_head, pg_tail, pg);
  pg->type = type;
  pg->src = src;
  pg->dest = dest;
  pg->kind = kind;
  pg->base_value = base_value;
  pg->max_value = value_rate;
  pg->duration_period = period;
  pg->frequency = frequency;
  pg->time_start = GNUNET_TIME_absolute_get();

  switch (type)
    {
    case GNUNET_ATS_TEST_TG_CONSTANT:
      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                 "Setting up constant preference generator master[%u] `%s' and slave [%u] `%s' max %u Bips\n",
                 dest->me->no, GNUNET_i2s(&dest->me->id),
                 dest->dest->no, GNUNET_i2s(&dest->dest->id),
                 base_value);
      break;

    case GNUNET_ATS_TEST_TG_LINEAR:
      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                 "Setting up linear preference generator master[%u] `%s' and slave [%u] `%s' min %u Bips max %u Bips\n",
                 dest->me->no, GNUNET_i2s(&dest->me->id),
                 dest->dest->no, GNUNET_i2s(&dest->dest->id),
                 base_value, value_rate);
      break;

    case GNUNET_ATS_TEST_TG_SINUS:
      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                 "Setting up sinus preference generator master[%u] `%s' and slave [%u] `%s' baserate %u Bips, amplitude %u Bps\n",
                 dest->me->no, GNUNET_i2s(&dest->me->id),
                 dest->dest->no, GNUNET_i2s(&dest->dest->id),
                 base_value, value_rate);
      break;

    case GNUNET_ATS_TEST_TG_RANDOM:
      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                 "Setting up random preference generator master[%u] `%s' and slave [%u] `%s' min %u Bips max %u Bps\n",
                 dest->me->no, GNUNET_i2s(&dest->me->id),
                 dest->dest->no, GNUNET_i2s(&dest->dest->id),
                 base_value, value_rate);
      break;

    default:
      break;
    }

  dest->pg = pg;
  pg->set_task = GNUNET_SCHEDULER_add_now(&set_pref_task, dest);
  return pg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_TEST_generate_preferences_stop()

void GNUNET_ATS_TEST_generate_preferences_stop

(

struct PreferenceGenerator *

pg

)

Definition at line 227 of file ats-testing-preferences.c.

References PreferenceGenerator::dest, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_SCHEDULER_cancel(), BenchmarkPartner::pg, and PreferenceGenerator::set_task.

Referenced by enforce_start_preference(), enforce_stop_preference(), and GNUNET_ATS_TEST_generate_preferences_stop_all().

{
  GNUNET_CONTAINER_DLL_remove(pg_head, pg_tail, pg);
  pg->dest->pg = NULL;

  if (NULL != pg->set_task)
    {
      GNUNET_SCHEDULER_cancel(pg->set_task);
      pg->set_task = NULL;
    }

  GNUNET_free(pg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_TEST_generate_preferences_stop_all()

void GNUNET_ATS_TEST_generate_preferences_stop_all

(

void

)

Stop all preferences generators.

Definition at line 246 of file ats-testing-preferences.c.

References GNUNET_ATS_TEST_generate_preferences_stop(), PreferenceGenerator::next, and pg_head.

Referenced by do_shutdown(), and experiment_done_cb().

{
  struct PreferenceGenerator *cur;
  struct PreferenceGenerator *next;

  next = pg_head;
  for (cur = next; NULL != cur; cur = next)
    {
      next = cur->next;
      GNUNET_ATS_TEST_generate_preferences_stop(cur);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_TEST_logging_start()

struct LoggingHandle* GNUNET_ATS_TEST_logging_start	(	struct GNUNET_TIME_Relative	log_frequency,
		const char *	testname,
		struct BenchmarkPeer *	masters,
		int	num_masters,
		int	num_slaves,
		int	verbose
	)

Start logging.

Parameters

log_frequency	the logging frequency
testname	the testname
masters	the master peers used for benchmarking
num_masters	the number of master peers
num_slaves	the number of slave peers
verbose	verbose logging

Returns

the logging handle or NULL on error

Definition at line 876 of file ats-testing-log.c.

References _, collect_log_task(), LoggingHandle::frequency, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_malloc, GNUNET_new, GNUNET_SCHEDULER_add_now(), GNUNET_TIME_absolute_get(), GNUNET_YES, l, LoggingHandle::log_task, LoggingHandle::lp, LoggingHandle::name, LoggingHandle::num_masters, LoggingHandle::num_slaves, LoggingPeer::peer, LoggingHandle::running, LoggingPeer::start, verbose, and LoggingHandle::verbose.

Referenced by topology_setup_done().

{
  struct LoggingHandle *l;
  int c_m;

  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
             _("Start logging `%s'\n"), testname);

  l = GNUNET_new(struct LoggingHandle);
  l->num_masters = num_masters;
  l->num_slaves = num_slaves;
  l->name = testname;
  l->frequency = log_frequency;
  l->verbose = verbose;
  l->lp = GNUNET_malloc(num_masters * sizeof(struct LoggingPeer));

  for (c_m = 0; c_m < num_masters; c_m++)
    {
      l->lp[c_m].peer = &masters[c_m];
      l->lp[c_m].start = GNUNET_TIME_absolute_get();
    }

  /* Schedule logging task */
  l->log_task = GNUNET_SCHEDULER_add_now(&collect_log_task, l);
  l->running = GNUNET_YES;

  return l;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_TEST_logging_clean_up()

void GNUNET_ATS_TEST_logging_clean_up

(

struct LoggingHandle *

l

)

Stop logging.

Parameters

l	the logging handle

Stop logging.

Parameters

l	the logging handle

Definition at line 841 of file ats-testing-log.c.

References GNUNET_ATS_TEST_logging_stop(), GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_YES, LoggingPeer::head, LoggingHandle::lp, LoggingHandle::num_masters, LoggingHandle::running, PeerLoggingTimestep::slaves_log, and LoggingPeer::tail.

Referenced by do_shutdown().

{
  int c_m;
  struct PeerLoggingTimestep *cur;

  if (GNUNET_YES == l->running)
    GNUNET_ATS_TEST_logging_stop(l);

  for (c_m = 0; c_m < l->num_masters; c_m++)
    {
      while (NULL != (cur = l->lp[c_m].head))
        {
          GNUNET_CONTAINER_DLL_remove(l->lp[c_m].head, l->lp[c_m].tail, cur);
          GNUNET_free(cur->slaves_log);
          GNUNET_free(cur);
        }
    }

  GNUNET_free(l->lp);
  GNUNET_free(l);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_TEST_logging_stop()

void GNUNET_ATS_TEST_logging_stop

(

struct LoggingHandle *

l

)

Stop logging.

Parameters

l	the logging handle

Definition at line 819 of file ats-testing-log.c.

References _, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_YES, LoggingHandle::log_task, and LoggingHandle::running.

Referenced by do_shutdown(), experiment_done_cb(), and GNUNET_ATS_TEST_logging_clean_up().

{
  if (GNUNET_YES != l->running)
    return;

  if (NULL != l->log_task)
    {
      GNUNET_SCHEDULER_cancel(l->log_task);
      l->log_task = NULL;
    }
  l->running = GNUNET_NO;

  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
             _("Stop logging\n"));
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_TEST_logging_now()

void GNUNET_ATS_TEST_logging_now

(

struct LoggingHandle *

l

)

Log all data now.

Parameters

l	logging handle to use

Definition at line 618 of file ats-testing-log.c.

References PartnerLoggingTimestep::app_rtt, PartnerLoggingTimestep::ats_delay, PartnerLoggingTimestep::ats_distance, PartnerLoggingTimestep::ats_network_type, PartnerLoggingTimestep::ats_utilization_in, PartnerLoggingTimestep::ats_utilization_out, PartnerLoggingTimestep::bandwidth_in, BenchmarkPartner::bandwidth_in, PartnerLoggingTimestep::bandwidth_out, BenchmarkPartner::bandwidth_out, BenchmarkPartner::bytes_received, BenchmarkPartner::bytes_sent, GNUNET_ATS_Properties::delay, BenchmarkPartner::dest, GNUNET_ATS_Properties::distance, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_malloc, GNUNET_new, GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_difference(), GNUNET_TIME_UNIT_SECONDS, GNUNET_YES, LoggingPeer::head, LoggingHandle::lp, BenchmarkPartner::messages_received, BenchmarkPartner::messages_sent, BenchmarkPeer::no, LoggingHandle::num_masters, BenchmarkPeer::num_partners, p, BenchmarkPeer::partners, LoggingPeer::peer, PartnerLoggingTimestep::pref_bandwidth, BenchmarkPartner::pref_bandwidth, PartnerLoggingTimestep::pref_delay, BenchmarkPartner::pref_delay, PeerLoggingTimestep::prev, BenchmarkPartner::props, GNUNET_TIME_Relative::rel_value_us, LoggingHandle::running, GNUNET_ATS_Properties::scope, PartnerLoggingTimestep::slave, PeerLoggingTimestep::slaves_log, LoggingPeer::start, LoggingPeer::tail, PartnerLoggingTimestep::throughput_recv, PartnerLoggingTimestep::throughput_sent, PeerLoggingTimestep::timestamp, PartnerLoggingTimestep::total_app_rtt, BenchmarkPartner::total_app_rtt, PartnerLoggingTimestep::total_bytes_received, PeerLoggingTimestep::total_bytes_received, BenchmarkPeer::total_bytes_received, PartnerLoggingTimestep::total_bytes_sent, PeerLoggingTimestep::total_bytes_sent, BenchmarkPeer::total_bytes_sent, PartnerLoggingTimestep::total_messages_received, PeerLoggingTimestep::total_messages_received, BenchmarkPeer::total_messages_received, PartnerLoggingTimestep::total_messages_sent, PeerLoggingTimestep::total_messages_sent, BenchmarkPeer::total_messages_sent, PeerLoggingTimestep::total_throughput_recv, PeerLoggingTimestep::total_throughput_send, GNUNET_ATS_Properties::utilization_out, and LoggingHandle::verbose.

Referenced by collect_log_task().

{
  struct LoggingPeer *bp;
  struct PeerLoggingTimestep *mlt;
  struct PeerLoggingTimestep *prev_log_mlt;
  struct PartnerLoggingTimestep *slt;
  struct PartnerLoggingTimestep *prev_log_slt;
  struct BenchmarkPartner *p;
  struct GNUNET_TIME_Relative delta;
  int c_s;
  int c_m;
  unsigned int app_rtt;
  double mult;

  if (GNUNET_YES != l->running)
    return;

  for (c_m = 0; c_m < l->num_masters; c_m++)
    {
      bp = &l->lp[c_m];
      mlt = GNUNET_new(struct PeerLoggingTimestep);
      GNUNET_CONTAINER_DLL_insert_tail(l->lp[c_m].head, l->lp[c_m].tail, mlt);
      prev_log_mlt = mlt->prev;

      /* Collect data */
      /* Current master state */
      mlt->timestamp = GNUNET_TIME_absolute_get();
      mlt->total_bytes_sent = bp->peer->total_bytes_sent;
      mlt->total_messages_sent = bp->peer->total_messages_sent;
      mlt->total_bytes_received = bp->peer->total_bytes_received;
      mlt->total_messages_received = bp->peer->total_messages_received;

      /* Throughput */
      if (NULL == prev_log_mlt)
        {
          /* Get difference to start */
          delta = GNUNET_TIME_absolute_get_difference(l->lp[c_m].start, mlt->timestamp);
        }
      else
        {
          /* Get difference to last timestep */
          delta = GNUNET_TIME_absolute_get_difference(mlt->prev->timestamp, mlt->timestamp);
        }

      /* Multiplication factor for throughput calculation */
      mult = (double)GNUNET_TIME_UNIT_SECONDS.rel_value_us / (delta.rel_value_us);

      /* Total throughput */
      if (NULL != prev_log_mlt)
        {
          if (mlt->total_bytes_sent - mlt->prev->total_bytes_sent > 0)
            {
              mlt->total_throughput_send = mult * (mlt->total_bytes_sent - mlt->prev->total_bytes_sent);
            }
          else
            {
              mlt->total_throughput_send = 0;
              // mlt->total_throughput_send = prev_log_mlt->total_throughput_send; /* no msgs send */
            }

          if (mlt->total_bytes_received - mlt->prev->total_bytes_received > 0)
            {
              mlt->total_throughput_recv = mult * (mlt->total_bytes_received - mlt->prev->total_bytes_received);
            }
          else
            {
              mlt->total_throughput_recv = 0;
              //mlt->total_throughput_recv = prev_log_mlt->total_throughput_recv; /* no msgs received */
            }
        }
      else
        {
          mlt->total_throughput_send = mult * mlt->total_bytes_sent;
          mlt->total_throughput_recv = mult * mlt->total_bytes_received;
        }

      if (GNUNET_YES == l->verbose)
        {
          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
                     "Master[%u] delta: %llu us, bytes (sent/received): %u / %u; throughput send/recv: %u / %u\n",
                     c_m,
                     (unsigned long long)delta.rel_value_us,
                     mlt->total_bytes_sent,
                     mlt->total_bytes_received,
                     mlt->total_throughput_send,
                     mlt->total_throughput_recv);
        }

      mlt->slaves_log = GNUNET_malloc(bp->peer->num_partners *
                                      sizeof(struct PartnerLoggingTimestep));

      for (c_s = 0; c_s < bp->peer->num_partners; c_s++)
        {
          GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                     "Collect logging data master[%u] slave [%u]\n", c_m, c_s);

          p = &bp->peer->partners[c_s];
          slt = &mlt->slaves_log[c_s];

          slt->slave = p->dest;
          /* Bytes sent from master to this slave */
          slt->total_bytes_sent = p->bytes_sent;
          /* Messages sent from master to this slave */
          slt->total_messages_sent = p->messages_sent;
          /* Bytes master received from this slave */
          slt->total_bytes_received = p->bytes_received;
          /* Messages master received from this slave */
          slt->total_messages_received = p->messages_received;
          slt->total_app_rtt = p->total_app_rtt;
          /* ats performance information */
          slt->ats_delay = p->props.delay;
          slt->ats_distance = p->props.distance;
          slt->ats_network_type = p->props.scope;
          slt->ats_utilization_in = p->props.utilization_out;
          slt->ats_utilization_out = p->props.utilization_out;
          slt->bandwidth_in = p->bandwidth_in;
          slt->bandwidth_out = p->bandwidth_out;
          slt->pref_bandwidth = p->pref_bandwidth;
          slt->pref_delay = p->pref_delay;

          /* Total application level rtt  */
          if (NULL == prev_log_mlt)
            {
              if (0 != slt->total_messages_sent)
                app_rtt = slt->total_app_rtt / slt->total_messages_sent;
              else
                app_rtt = 0;
            }
          else
            {
              prev_log_slt = &prev_log_mlt->slaves_log[c_s];
              if ((slt->total_messages_sent - prev_log_slt->total_messages_sent) > 0)
                app_rtt = (slt->total_app_rtt - prev_log_slt->total_app_rtt) /
                          (slt->total_messages_sent - prev_log_slt->total_messages_sent);
              else
                {
                  app_rtt = prev_log_slt->app_rtt; /* No messages were */
                }
            }
          slt->app_rtt = app_rtt;

          /* Partner throughput */
          if (NULL != prev_log_mlt)
            {
              prev_log_slt = &prev_log_mlt->slaves_log[c_s];
              if (slt->total_bytes_sent > prev_log_slt->total_bytes_sent)
                slt->throughput_sent = mult * (slt->total_bytes_sent - prev_log_slt->total_bytes_sent);
              else
                slt->throughput_sent = 0;

              if (slt->total_bytes_received > prev_log_slt->total_bytes_received)
                slt->throughput_recv = mult *
                                       (slt->total_bytes_received - prev_log_slt->total_bytes_received);
              else
                slt->throughput_recv = 0;
            }
          else
            {
              slt->throughput_sent = mult * slt->total_bytes_sent;
              slt->throughput_recv = mult * slt->total_bytes_received;
            }

          if (GNUNET_YES == l->verbose)
            {
              GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
                         "Master [%u] -> Slave [%u]: delta: %llu us, bytes (sent/received): %u / %u; throughput send/recv: %u / %u\n",
                         c_m, c_s,
                         (unsigned long long)delta.rel_value_us,
                         mlt->total_bytes_sent,
                         mlt->total_bytes_received,
                         slt->throughput_sent,
                         slt->throughput_recv);
            }
          else
            GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
                       "Master [%u]: slave [%u]\n",
                       bp->peer->no, p->dest->no);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_TEST_logging_write_to_file()

void GNUNET_ATS_TEST_logging_write_to_file	(	struct LoggingHandle *	l,
		const char *	test_name,
		int	plots
	)

Write logging data to file.

Parameters

l	logging handle to use
test_name	name of the current test
plots	create gnuplots: GNUNET_YES or GNUNET_NO

Definition at line 417 of file ats-testing-log.c.

References GNUNET_TIME_Absolute::abs_value_us, PartnerLoggingTimestep::app_rtt, PartnerLoggingTimestep::ats_delay, PartnerLoggingTimestep::ats_distance, PartnerLoggingTimestep::ats_network_type, PartnerLoggingTimestep::ats_utilization_in, PartnerLoggingTimestep::ats_utilization_out, PartnerLoggingTimestep::bandwidth_in, PartnerLoggingTimestep::bandwidth_out, data, removetrailingwhitespace::f, GNUNET_asprintf(), GNUNET_break, GNUNET_DISK_file_close(), GNUNET_DISK_file_open(), GNUNET_DISK_file_write(), GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_OPEN_WRITE, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_log_strerror_file, GNUNET_OK, GNUNET_SYSERR, GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_difference(), GNUNET_YES, LoggingPeer::head, LoggingHandle::lp, LoggingHandle::name, PeerLoggingTimestep::next, BenchmarkPeer::no, LoggingHandle::num_masters, BenchmarkPeer::num_partners, LoggingHandle::num_slaves, LoggingPeer::peer, PartnerLoggingTimestep::pref_bandwidth, PartnerLoggingTimestep::pref_delay, GNUNET_TIME_Relative::rel_value_us, PartnerLoggingTimestep::slave, PeerLoggingTimestep::slaves_log, LoggingPeer::start, PartnerLoggingTimestep::throughput_recv, PartnerLoggingTimestep::throughput_sent, PeerLoggingTimestep::timestamp, PartnerLoggingTimestep::total_bytes_received, PeerLoggingTimestep::total_bytes_received, PartnerLoggingTimestep::total_bytes_sent, PeerLoggingTimestep::total_bytes_sent, PartnerLoggingTimestep::total_messages_received, PeerLoggingTimestep::total_messages_received, PartnerLoggingTimestep::total_messages_sent, PeerLoggingTimestep::total_messages_sent, PeerLoggingTimestep::total_throughput_recv, PeerLoggingTimestep::total_throughput_send, LoggingHandle::verbose, write_bw_gnuplot_script(), write_rtt_gnuplot_script(), and write_throughput_gnuplot_script().

Referenced by experiment_done_cb().

{
  struct GNUNET_DISK_FileHandle *f[l->num_slaves];
  struct GNUNET_DISK_FileHandle *f_m;
  const char *tmp_exp_name;
  char *filename_master;
  char *filename_slaves[l->num_slaves];
  char *data;
  struct PeerLoggingTimestep *cur_lt;
  struct PartnerLoggingTimestep *plt;
  struct GNUNET_TIME_Absolute timestamp;
  int c_m;
  int c_s;


  timestamp = GNUNET_TIME_absolute_get();

  tmp_exp_name = experiment_name;
  for (c_m = 0; c_m < l->num_masters; c_m++)
    {
      GNUNET_asprintf(&filename_master, "%s_%llu_master%u_%s",
                      experiment_name, timestamp.abs_value_us, c_m, l->name);
      fprintf(stderr, "Writing data for master %u to file `%s'\n",
              c_m, filename_master);

      f_m = GNUNET_DISK_file_open(filename_master,
                                  GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE,
                                  GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
      if (NULL == f_m)
        {
          GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Cannot open log file `%s'\n", filename_master);
          GNUNET_free(filename_master);
          return;
        }

      GNUNET_asprintf(&data, "# master %u; experiment : %s\n"
                      "timestamp; timestamp delta; #messages sent; #bytes sent; #throughput sent; #messages received; #bytes received; #throughput received; \n",
                      c_m, experiment_name);
      if (GNUNET_SYSERR == GNUNET_DISK_file_write(f_m, data, strlen(data)))
        GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
                   "Cannot write data to log file `%s'\n", filename_master);
      GNUNET_free(data);

      for (c_s = 0; c_s < l->lp[c_m].peer->num_partners; c_s++)
        {
          GNUNET_asprintf(&filename_slaves[c_s], "%s_%llu_master%u_slave_%u_%s",
                          tmp_exp_name, timestamp.abs_value_us, c_m, c_s, l->name);

          fprintf(stderr, "Writing data for master %u slave %u to file `%s'\n",
                  c_m, c_s, filename_slaves[c_s]);

          f[c_s] = GNUNET_DISK_file_open(filename_slaves[c_s],
                                         GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE,
                                         GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
          if (NULL == f[c_s])
            {
              GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Cannot open log file `%s'\n", filename_slaves[c_s]);
              GNUNET_free(filename_slaves[c_s]);
              GNUNET_break(GNUNET_OK == GNUNET_DISK_file_close(f_m));
              GNUNET_free(filename_master);
              return;
            }

          /* Header */
          GNUNET_asprintf(&data, "# master %u; slave %u ; experiment : %s\n"
                          "timestamp; timestamp delta; #messages sent; #bytes sent; #throughput sent; #messages received; #bytes received; #throughput received; " \
                          "rtt; bw in; bw out; ats_cost_lan; ats_cost_wlan; ats_delay; ats_distance; ats_network_type; ats_utilization_up ;ats_utilization_down;" \
                          "pref bandwidth; pref delay\n",
                          c_m, c_s, experiment_name);
          if (GNUNET_SYSERR == GNUNET_DISK_file_write(f[c_s], data, strlen(data)))
            GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
                       "Cannot write data to log file `%s'\n", filename_slaves[c_s]);
          GNUNET_free(data);
        }

      for (cur_lt = l->lp[c_m].head; NULL != cur_lt; cur_lt = cur_lt->next)
        {
          if (l->verbose)
            fprintf(stderr,
                    "Master [%u]: timestamp %llu %llu ; %u %u %u ; %u %u %u\n",
                    l->lp[c_m].peer->no,
                    (long long unsigned int)cur_lt->timestamp.abs_value_us,
                    (long long unsigned int)GNUNET_TIME_absolute_get_difference(l->lp[c_m].start,
                                                                                cur_lt->timestamp).rel_value_us / 1000,
                    cur_lt->total_messages_sent,
                    cur_lt->total_bytes_sent,
                    cur_lt->total_throughput_send,
                    cur_lt->total_messages_received,
                    cur_lt->total_bytes_received,
                    cur_lt->total_throughput_recv);

          /* Assembling master string */
          GNUNET_asprintf(&data, "%llu;%llu;%u;%u;%u;%u;%u;%u;\n",
                          (long long unsigned int)cur_lt->timestamp.abs_value_us,
                          (long long unsigned int)GNUNET_TIME_absolute_get_difference(l->lp[c_m].start,
                                                                                      cur_lt->timestamp).rel_value_us / 1000,
                          cur_lt->total_messages_sent,
                          cur_lt->total_bytes_sent,
                          cur_lt->total_throughput_send,
                          cur_lt->total_messages_received,
                          cur_lt->total_bytes_received,
                          cur_lt->total_throughput_recv);

          if (GNUNET_SYSERR == GNUNET_DISK_file_write(f_m, data, strlen(data)))
            GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
                       "Cannot write data to master file %u\n", c_m);
          GNUNET_free(data);


          for (c_s = 0; c_s < l->lp[c_m].peer->num_partners; c_s++)
            {
              plt = &cur_lt->slaves_log[c_s];
              /* Log partners */

              /* Assembling slave string */
              GNUNET_asprintf(&data,
                              "%llu;%llu;%u;%u;%u;%u;%u;%u;%.3f;%u;%u;%u;%u;%u;%u;%u;%.3f;%.3f\n",
                              (long long unsigned int)cur_lt->timestamp.abs_value_us,
                              (long long unsigned int)GNUNET_TIME_absolute_get_difference(l->lp[c_m].start,
                                                                                          cur_lt->timestamp).rel_value_us / 1000,
                              plt->total_messages_sent,
                              plt->total_bytes_sent,
                              plt->throughput_sent,
                              plt->total_messages_received,
                              plt->total_bytes_received,
                              plt->throughput_recv,
                              (double)plt->app_rtt / 1000,
                              plt->bandwidth_in,
                              plt->bandwidth_out,
                              plt->ats_delay,
                              plt->ats_distance,
                              plt->ats_network_type,
                              plt->ats_utilization_out,
                              plt->ats_utilization_in,
                              plt->pref_bandwidth,
                              plt->pref_delay);

              if (l->verbose)
                fprintf(stderr,
                        "\t Slave [%u]: %u %u %u ; %u %u %u rtt %u delay %llu bw_in %u bw_out %u \n",
                        plt->slave->no,
                        plt->total_messages_sent,
                        plt->total_bytes_sent,
                        plt->throughput_sent,
                        plt->total_messages_received,
                        plt->total_bytes_received,
                        plt->throughput_recv,
                        plt->app_rtt,
                        (long long unsigned int)plt->ats_delay.rel_value_us,
                        plt->bandwidth_in,
                        plt->bandwidth_out);

              if (GNUNET_SYSERR == GNUNET_DISK_file_write(f[c_s], data, strlen(data)))
                GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
                           "Cannot write data to log file `%s'\n", filename_slaves[c_s]);
              GNUNET_free(data);
            }
        }

      for (c_s = 0; c_s < l->lp[c_m].peer->num_partners; c_s++)
        {
          if (GNUNET_SYSERR == GNUNET_DISK_file_close(f[c_s]))
            {
              GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
                         "Cannot close log file for master[%u] slave[%u]\n", c_m, c_s);
              continue;
            }
          GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                     "Data file successfully written to log file for `%s'\n",
                     filename_slaves[c_s]);
        }

      if (GNUNET_SYSERR == GNUNET_DISK_file_close(f_m))
        {
          GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR,
                                   "close",
                                   filename_master);
          GNUNET_free(filename_master);
          return;
        }
      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                 "Data file successfully written to log file for master `%s'\n", filename_master);

      if (GNUNET_YES == plots)
        {
          write_throughput_gnuplot_script(filename_master, &l->lp[c_m], filename_slaves, l->num_slaves);
          write_rtt_gnuplot_script(filename_master, &l->lp[c_m], filename_slaves, l->num_slaves);
          write_bw_gnuplot_script(filename_master, &l->lp[c_m], filename_slaves, l->num_slaves);
        }
    }
  GNUNET_free(filename_master);
}

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
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.

Handle to our configuration.

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