GNUnet  0.10.x
ats-testing-traffic.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2010-2013, 2016 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your option) any later version.
9 
10  GNUnet is distributed in the hope that it will be useful, but
11  WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
26 #include "platform.h"
27 #include "gnunet_util_lib.h"
28 #include "ats-testing.h"
29 
30 static struct TrafficGenerator *tg_head;
31 static struct TrafficGenerator *tg_tail;
32 
33 extern struct GNUNET_ATS_TEST_Topology *top;
34 
35 static struct GNUNET_TIME_Relative
37 {
38  struct GNUNET_TIME_Relative delay;
39  struct GNUNET_TIME_Relative time_delta;
40  long long int cur_rate;
41  long long int delta_rate;
42 
43  delay.rel_value_us = 0;
44 
45  /* Calculate the current transmission rate based on the type of traffic */
46  switch (tg->type) {
48  if (UINT32_MAX == tg->base_rate)
49  return GNUNET_TIME_UNIT_ZERO;
50  cur_rate = tg->base_rate;
51  break;
53  time_delta = GNUNET_TIME_absolute_get_duration(tg->time_start);
54  /* Calculate point of time in the current period */
55  time_delta.rel_value_us = time_delta.rel_value_us % tg->duration_period.rel_value_us;
56  delta_rate = ((double) time_delta.rel_value_us / tg->duration_period.rel_value_us) *
57  (tg->max_rate - tg->base_rate);
58  if ((tg->max_rate < tg->base_rate) && ((tg->max_rate - tg->base_rate) > tg->base_rate))
59  {
60  /* This will cause an underflow */
61  GNUNET_break (0);
62  }
63  cur_rate = tg->base_rate + delta_rate;
64  break;
66  cur_rate = tg->base_rate + GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
67  tg->max_rate - tg->base_rate);
68  break;
70  time_delta = GNUNET_TIME_absolute_get_duration(tg->time_start);
71  /* Calculate point of time in the current period */
72  time_delta.rel_value_us = time_delta.rel_value_us % tg->duration_period.rel_value_us;
73  if ((tg->max_rate - tg->base_rate) > tg->base_rate)
74  {
75  /* This will cause an underflow for second half of sinus period,
76  * will be detected in general when experiments are loaded */
77  GNUNET_break (0);
78  }
79  delta_rate = (tg->max_rate - tg->base_rate) *
80  sin ( (2 * M_PI) / ((double) tg->duration_period.rel_value_us) * time_delta.rel_value_us);
81  cur_rate = tg->base_rate + delta_rate;
82  break;
83  default:
84  return delay;
85  break;
86  }
87 
88  if (cur_rate < 0)
89  {
90  cur_rate = 1;
91  }
92  /* Calculate the delay for the next message based on the current delay */
93  delay.rel_value_us = GNUNET_TIME_UNIT_SECONDS.rel_value_us * TEST_MESSAGE_SIZE / cur_rate;
94 
96  "Current rate is %lld, calculated delay is %llu\n",
97  cur_rate,
98  (unsigned long long) delay.rel_value_us);
99  return delay;
100 }
101 
102 
103 static void
104 update_ping_data (void *cls)
105 {
106  struct BenchmarkPartner *p = cls;
107  struct GNUNET_TIME_Relative delay;
108 
109  p->messages_sent++;
111  p->me->total_messages_sent++;
113 
114  if (NULL == p->tg)
115  {
116  GNUNET_break (0);
117  return;
118  }
119  delay = get_delay (p->tg);
121  "Delay for next transmission %s\n",
123  GNUNET_YES));
126  delay);
127 }
128 
129 
130 static void
132 {
133  struct BenchmarkPartner *p = cls;
134  struct TestMessage *msg;
135  struct GNUNET_MQ_Envelope *env;
136 
137  p->tg->send_task = NULL;
139  env = GNUNET_MQ_msg (msg,
141  memset (msg->padding,
142  'a',
143  sizeof (msg->padding));
146  p);
148  "Master [%u]: Sending PING to [%u]\n",
149  p->me->no,
150  p->dest->no);
151  GNUNET_MQ_send (p->mq,
152  env);
153 }
154 
155 
156 static void
157 update_pong_data (void *cls)
158 {
159  struct BenchmarkPartner *p = cls;
160 
161  p->messages_sent++;
163  p->me->total_messages_sent++;
165 }
166 
167 
168 void
170 {
171  struct TestMessage *msg;
172  struct GNUNET_MQ_Envelope *env;
173 
175  "Slave [%u]: Received PING from [%u], sending PONG\n",
176  p->me->no,
177  p->dest->no);
178  p->messages_received++;
182 
183 
184  env = GNUNET_MQ_msg (msg,
186  memset (msg->padding,
187  'a',
188  sizeof (msg->padding));
191  p);
192  GNUNET_MQ_send (p->mq,
193  env);
194 }
195 
196 
197 void
199 {
200  struct GNUNET_TIME_Relative left;
202  "Master [%u]: Received PONG from [%u], next message\n",
203  p->me->no,
204  p->dest->no);
205 
206  p->messages_received++;
212 
213  /* Schedule next send event */
214  if (NULL == p->tg)
215  return;
216 
218  if (UINT32_MAX == p->tg->base_rate)
219  {
221  }
222  else if (0 == left.rel_value_us)
223  {
225  }
226  else
227  {
228  /* Enforce minimum transmission rate 1 msg / sec */
231  "Enforcing minimum send rate between master [%u] and slave [%u]\n",
232  p->me->no, p->dest->no);
234  &comm_schedule_send, p);
235  }
236 }
237 
238 
252 struct TrafficGenerator *
254  struct BenchmarkPartner *dest,
255  enum GeneratorType type,
256  unsigned int base_rate,
257  unsigned int max_rate,
258  struct GNUNET_TIME_Relative period,
260 {
261  struct TrafficGenerator *tg;
262 
263  if (NULL != dest->tg)
264  {
265  GNUNET_break (0);
266  return NULL;
267  }
268 
269  tg = GNUNET_new (struct TrafficGenerator);
271  tg_tail,
272  tg);
273  tg->type = type;
274  tg->src = src;
275  tg->dest = dest;
276  tg->base_rate = base_rate;
277  tg->max_rate = max_rate;
278  tg->duration_period = period;
281 
282  switch (type) {
285  "Setting up constant traffic generator master[%u] `%s' and slave [%u] `%s' max %u Bips\n",
286  dest->me->no,
287  GNUNET_i2s (&dest->me->id),
288  dest->dest->no,
289  GNUNET_i2s (&dest->dest->id),
290  base_rate);
291  break;
294  "Setting up linear traffic generator master[%u] `%s' and slave [%u] `%s' min %u Bips max %u Bips\n",
295  dest->me->no,
296  GNUNET_i2s (&dest->me->id),
297  dest->dest->no,
298  GNUNET_i2s (&dest->dest->id),
299  base_rate,
300  max_rate);
301  break;
304  "Setting up sinus traffic generator master[%u] `%s' and slave [%u] `%s' baserate %u Bips, amplitude %u Bps\n",
305  dest->me->no,
306  GNUNET_i2s (&dest->me->id),
307  dest->dest->no,
308  GNUNET_i2s (&dest->dest->id),
309  base_rate,
310  max_rate);
311  break;
314  "Setting up random traffic generator master[%u] `%s' and slave [%u] `%s' min %u Bips max %u Bps\n",
315  dest->me->no,
316  GNUNET_i2s (&dest->me->id),
317  dest->dest->no,
318  GNUNET_i2s (&dest->dest->id),
319  base_rate,
320  max_rate);
321  break;
322  default:
323  break;
324  }
325 
326  dest->tg = tg;
327  tg->send_task
329  dest);
330  return tg;
331 }
332 
333 
334 void
336 {
338  tg_tail,
339  tg);
340  tg->dest->tg = NULL;
341  if (NULL != tg->send_task)
342  {
344  tg->send_task = NULL;
345  }
346  GNUNET_free (tg);
347 }
348 
349 
353 void
355 {
356  struct TrafficGenerator *cur;
357  struct TrafficGenerator *next;
358 
359  next = tg_head;
360  for (cur = next; NULL != cur; cur = next)
361  {
362  next = cur->next;
364  }
365 }
366 
367 /* end of file ats-testing-traffic.c */
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
unsigned int total_bytes_sent
Total number of bytes this peer has sent.
Definition: ats-testing.h:217
unsigned int messages_sent
Number of messages sent to this partner.
Definition: ats-testing.h:315
unsigned int total_bytes_received
Total number of bytes this peer has received.
Definition: ats-testing.h:227
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
uint64_t rel_value_us
The actual value.
struct TrafficGenerator * next
Definition: ats-testing.h:233
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
struct GNUNET_ATS_TEST_Topology * top
Definition: ats-testing.c:53
static void update_ping_data(void *cls)
static struct TrafficGenerator * tg_head
static void comm_schedule_send(void *cls)
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
long int max_rate
Definition: ats-testing.h:241
#define GNUNET_TIME_UNIT_SECONDS
One second.
void GNUNET_ATS_TEST_traffic_handle_pong(struct BenchmarkPartner *p)
unsigned int total_messages_received
Total number of messages this peer has received.
Definition: ats-testing.h:222
#define TEST_MESSAGE_TYPE_PING
Message type sent for traffic generation.
Definition: ats-testing.h:38
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
unsigned int bytes_received
Number of bytes received from this partner.
Definition: ats-testing.h:330
uint8_t padding[100 - sizeof(struct GNUNET_MessageHeader)]
Definition: ats-testing.h:55
struct GNUNET_SCHEDULER_Task * send_task
Definition: ats-testing.h:244
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_add(struct GNUNET_TIME_Absolute start, struct GNUNET_TIME_Relative duration)
Add a given relative duration to the given start time.
Definition: time.c:393
#define GNUNET_new(type)
Allocate a struct or union of the given type.
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...
struct BenchmarkPartner * dest
Definition: ats-testing.h:238
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
unsigned int total_messages_sent
Total number of messages this peer has sent.
Definition: ats-testing.h:212
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
struct TrafficGenerator * tg
Handle for traffic generator.
Definition: ats-testing.h:295
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1246
int no
Unique identifier.
Definition: ats-testing.h:121
void GNUNET_ATS_TEST_traffic_handle_ping(struct BenchmarkPartner *p)
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
struct GNUNET_TIME_Absolute time_start
Definition: ats-testing.h:246
void GNUNET_MQ_notify_sent(struct GNUNET_MQ_Envelope *ev, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
Call a callback once the envelope has been sent, that is, sending it can not be canceled anymore...
Definition: mq.c:774
unsigned int total_app_rtt
Accumulated RTT for all messages.
Definition: ats-testing.h:310
static struct TrafficGenerator * tg_tail
Information we track for a peer in the testbed.
Definition: ats-testing.h:111
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1273
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:727
Information about a benchmarking partner.
Definition: ats-testing.h:275
unsigned int messages_received
Number of messages received from this partner.
Definition: ats-testing.h:325
ats testing library: setup topology and provide logging to test ats
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
struct GNUNET_TIME_Relative GNUNET_TIME_relative_min(struct GNUNET_TIME_Relative t1, struct GNUNET_TIME_Relative t2)
Return the minimum of two relative time values.
Definition: time.c:271
enum GeneratorType type
Definition: ats-testing.h:235
struct GNUNET_TIME_Absolute last_message_sent
Timestamp to calculate communication layer delay.
Definition: ats-testing.h:305
struct BenchmarkPeer * src
Definition: ats-testing.h:237
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static struct GNUNET_TIME_Relative delay
When should dkg communication start?
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
unsigned int bytes_sent
Number of bytes sent to this partner.
Definition: ats-testing.h:320
struct GNUNET_MQ_Handle * mq
Message queue handle.
Definition: ats-testing.h:290
long int base_rate
Definition: ats-testing.h:240
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:373
#define GNUNET_log(kind,...)
void GNUNET_ATS_TEST_generate_traffic_stop(struct TrafficGenerator *tg)
static struct GNUNET_TIME_Relative duration
How long do we run the test?
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:331
struct GNUNET_TIME_Relative duration_period
Definition: ats-testing.h:242
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
void GNUNET_ATS_TEST_generate_traffic_stop_all()
Stop all traffic generators.
#define GNUNET_YES
Definition: gnunet_common.h:80
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_difference(struct GNUNET_TIME_Absolute start, struct GNUNET_TIME_Absolute end)
Compute the time difference between the given start and end times.
Definition: time.c:353
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
static struct GNUNET_TIME_Relative get_delay(struct TrafficGenerator *tg)
static void update_pong_data(void *cls)
struct BenchmarkPeer * me
The peer itself this partner belongs to.
Definition: ats-testing.h:280
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct BenchmarkPeer * dest
The partner peer.
Definition: ats-testing.h:285
struct GNUNET_PeerIdentity id
Peer ID.
Definition: ats-testing.h:131
struct GNUNET_TIME_Absolute next_ping_transmission
Definition: ats-testing.h:245
#define TEST_MESSAGE_SIZE
Size of test messages.
Definition: ats-testing.h:48
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965