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 85 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 100 of file ats-testing.h.

GNUNET_ATS_TESTING_EpisodeDoneCallback

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

Definition at line 482 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 484 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 69 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 470 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 673 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 704 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 804 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 183 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 212 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 273 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 360 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 379 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 157 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 232 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 251 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 941 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 906 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 883 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 674 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 447 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;%llu;%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.rel_value_us,
                         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 894 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 903 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 927 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 967 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 51 of file ats-testing.c.