ats benchmark: traffic generator More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "ats-testing.h"

Include dependency graph for ats-testing-traffic.c:

Functions
static struct GNUNET_TIME_Relative	get_delay (struct TrafficGenerator *tg)

static void	update_ping_data (void *cls)

static void	comm_schedule_send (void *cls)

static void	update_pong_data (void *cls)

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 ()
	Stop all traffic generators. More...

Variables
static struct TrafficGenerator *	tg_head

static struct TrafficGenerator *	tg_tail

struct GNUNET_ATS_TEST_Topology *	top

Detailed Description

ats benchmark: traffic generator

Author: Christian Grothoff; Matthias Wachs

Definition in file ats-testing-traffic.c.

Function Documentation

◆ get_delay()

static struct GNUNET_TIME_Relative get_delay ( struct TrafficGenerator * tg )

static

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

References delay, GNUNET_ATS_TEST_TG_CONSTANT, GNUNET_ATS_TEST_TG_LINEAR, GNUNET_ATS_TEST_TG_RANDOM, GNUNET_ATS_TEST_TG_SINUS, GNUNET_break, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_UNIT_SECONDS, GNUNET_TIME_UNIT_ZERO, GNUNET_TIME_Relative::rel_value_us, and TEST_MESSAGE_SIZE.

Referenced by update_ping_data().

 {
   struct GNUNET_TIME_Relative delay;
   struct GNUNET_TIME_Relative time_delta;
   long long int cur_rate;
   long long int delta_rate;
 
   delay.rel_value_us = 0;
 
   /* Calculate the current transmission rate based on the type of traffic */
   switch (tg->type)
     {
     case GNUNET_ATS_TEST_TG_CONSTANT:
       if (UINT32_MAX == tg->base_rate)
         return GNUNET_TIME_UNIT_ZERO;
       cur_rate = tg->base_rate;
       break;
 
     case GNUNET_ATS_TEST_TG_LINEAR:
       time_delta = GNUNET_TIME_absolute_get_duration(tg->time_start);
       /* Calculate point of time in the current period */
       time_delta.rel_value_us = time_delta.rel_value_us % tg->duration_period.rel_value_us;
       delta_rate = ((double)time_delta.rel_value_us / tg->duration_period.rel_value_us) *
                    (tg->max_rate - tg->base_rate);
       if ((tg->max_rate < tg->base_rate) && ((tg->max_rate - tg->base_rate) > tg->base_rate))
         {
           /* This will cause an underflow */
           GNUNET_break(0);
         }
       cur_rate = tg->base_rate + delta_rate;
       break;
 
     case GNUNET_ATS_TEST_TG_RANDOM:
       cur_rate = tg->base_rate + GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
                                                           tg->max_rate - tg->base_rate);
       break;
 
     case GNUNET_ATS_TEST_TG_SINUS:
       time_delta = GNUNET_TIME_absolute_get_duration(tg->time_start);
       /* Calculate point of time in the current period */
       time_delta.rel_value_us = time_delta.rel_value_us % tg->duration_period.rel_value_us;
       if ((tg->max_rate - tg->base_rate) > tg->base_rate)
         {
           /* This will cause an underflow for second half of sinus period,
            * will be detected in general when experiments are loaded */
           GNUNET_break(0);
         }
       delta_rate = (tg->max_rate - tg->base_rate) *
                    sin((2 * M_PI) / ((double)tg->duration_period.rel_value_us) * time_delta.rel_value_us);
       cur_rate = tg->base_rate + delta_rate;
       break;
 
     default:
       return delay;
       break;
     }
 
   if (cur_rate < 0)
     {
       cur_rate = 1;
     }
   /* Calculate the delay for the next message based on the current delay  */
   delay.rel_value_us = GNUNET_TIME_UNIT_SECONDS.rel_value_us * TEST_MESSAGE_SIZE / cur_rate;
 
   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
              "Current rate is %lld, calculated delay is %llu\n",
              cur_rate,
              (unsigned long long)delay.rel_value_us);
   return delay;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_ping_data()

static void update_ping_data ( void * cls )

static

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

References BenchmarkPartner::bytes_sent, get_delay(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_add(), GNUNET_TIME_absolute_get(), GNUNET_YES, BenchmarkPartner::me, BenchmarkPartner::messages_sent, TrafficGenerator::next_ping_transmission, p, TEST_MESSAGE_SIZE, BenchmarkPartner::tg, BenchmarkPeer::total_bytes_sent, and BenchmarkPeer::total_messages_sent.

Referenced by comm_schedule_send().

 {
   struct BenchmarkPartner *p = cls;
   struct GNUNET_TIME_Relative delay;
 
   p->messages_sent++;
   p->bytes_sent += TEST_MESSAGE_SIZE;
   p->me->total_messages_sent++;
   p->me->total_bytes_sent += TEST_MESSAGE_SIZE;
 
   if (NULL == p->tg)
     {
       GNUNET_break(0);
       return;
     }
   delay = get_delay(p->tg);
   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
              "Delay for next transmission %s\n",
              GNUNET_STRINGS_relative_time_to_string(delay,
                                                     GNUNET_YES));
   p->tg->next_ping_transmission
     = GNUNET_TIME_absolute_add(GNUNET_TIME_absolute_get(),
                                delay);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ comm_schedule_send()

static void comm_schedule_send ( void * cls )

static

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

References BenchmarkPartner::dest, env, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MQ_msg, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), GNUNET_TIME_absolute_get(), BenchmarkPartner::last_message_sent, BenchmarkPartner::me, BenchmarkPartner::mq, msg, BenchmarkPeer::no, p, TestMessage::padding, TrafficGenerator::send_task, TEST_MESSAGE_TYPE_PING, BenchmarkPartner::tg, and update_ping_data().

Referenced by GNUNET_ATS_TEST_generate_traffic_start(), and GNUNET_ATS_TEST_traffic_handle_pong().

 {
   struct BenchmarkPartner *p = cls;
   struct TestMessage *msg;
   struct GNUNET_MQ_Envelope *env;
 
   p->tg->send_task = NULL;
   p->last_message_sent = GNUNET_TIME_absolute_get();
   env = GNUNET_MQ_msg(msg,
                       TEST_MESSAGE_TYPE_PING);
   memset(msg->padding,
          'a',
          sizeof(msg->padding));
   GNUNET_MQ_notify_sent(env,
                         &update_ping_data,
                         p);
   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
              "Master [%u]: Sending PING to [%u]\n",
              p->me->no,
              p->dest->no);
   GNUNET_MQ_send(p->mq,
                  env);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_pong_data()

static void update_pong_data ( void * cls )

static

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

References BenchmarkPartner::bytes_sent, BenchmarkPartner::me, BenchmarkPartner::messages_sent, p, TEST_MESSAGE_SIZE, BenchmarkPeer::total_bytes_sent, and BenchmarkPeer::total_messages_sent.

Referenced by GNUNET_ATS_TEST_traffic_handle_ping().

 {
   struct BenchmarkPartner *p = cls;
 
   p->messages_sent++;
   p->bytes_sent += TEST_MESSAGE_SIZE;
   p->me->total_messages_sent++;
   p->me->total_bytes_sent += TEST_MESSAGE_SIZE;
 }

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);
     }
 }