GNUnet  0.11.x
Data Structures | Functions | Variables
ats-testing.c File Reference

ats testing library: setup topology solvers More...

#include "ats-testing.h"
Include dependency graph for ats-testing.c:

Go to the source code of this file.

Data Structures

struct  TestbedConnectOperation
 Connect peers with testbed. More...
 

Functions

static void do_shutdown (void *cls)
 Shutdown nicely. More...
 
static struct BenchmarkPartnerfind_partner (struct BenchmarkPeer *me, const struct GNUNET_PeerIdentity *peer)
 
static struct BenchmarkPeerfind_peer (const struct GNUNET_PeerIdentity *peer)
 
static void * comm_connect_cb (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
 Method called whenever a given peer connects. More...
 
static void comm_disconnect_cb (void *cls, const struct GNUNET_PeerIdentity *peer, void *internal_cls)
 
static void handle_pong (void *cls, const struct TestMessage *message)
 
static void handle_ping (void *cls, const struct TestMessage *message)
 
static void * transport_connect_adapter (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
 
static void transport_disconnect_adapter (void *cls, void *op_result)
 
static void * core_connect_adapter (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
 
static void core_disconnect_adapter (void *cls, void *op_result)
 
static void connect_completion_callback (void *cls, struct GNUNET_TESTBED_Operation *op, const char *emsg)
 
static void do_connect_peers (void *cls)
 
static void comm_connect_completion_cb (void *cls, struct GNUNET_TESTBED_Operation *op, void *ca_result, const char *emsg)
 
static void do_comm_connect (void *cls)
 
static void ats_performance_info_cb (void *cls, const struct GNUNET_HELLO_Address *address, int address_active, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in, const struct GNUNET_ATS_Properties *ats_prop)
 
static void * ats_perf_connect_adapter (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
 
static void ats_perf_disconnect_adapter (void *cls, void *op_result)
 
static void ats_connect_completion_cb (void *cls, struct GNUNET_TESTBED_Operation *op, void *ca_result, const char *emsg)
 
static void do_connect_ats (void *cls)
 
static void peerinformation_cb (void *cb_cls, struct GNUNET_TESTBED_Operation *op, const struct GNUNET_TESTBED_PeerInformation *pinfo, const char *emsg)
 
static void main_run (void *cls, struct GNUNET_TESTBED_RunHandle *h, unsigned int num_peers, struct GNUNET_TESTBED_Peer **peers_, unsigned int links_succeeded, unsigned int links_failed)
 Signature of a main function for a testcase. More...
 
static void controller_event_cb (void *cls, const struct GNUNET_TESTBED_EventInformation *event)
 Controller event callback. More...
 
struct BenchmarkPeerGNUNET_ATS_TEST_get_peer (int src)
 Topology related functions. More...
 
struct BenchmarkPartnerGNUNET_ATS_TEST_get_partner (int src, int dest)
 
void GNUNET_ATS_TEST_create_topology (char *name, char *cfg_file, unsigned int num_slaves, unsigned int num_masters, int test_core, GNUNET_ATS_TEST_TopologySetupDoneCallback done_cb, void *done_cb_cls, GNUNET_ATS_AddressInformationCallback log_request_cb)
 Create a topology for ats testing. More...
 
void GNUNET_ATS_TEST_shutdown_topology (void)
 Shutdown topology. More...
 

Variables

struct GNUNET_CONFIGURATION_Handlecfg
 Handle to our configuration. More...
 
struct GNUNET_ATS_TEST_Topologytop
 

Detailed Description

ats testing library: setup topology solvers

Author
Christian Grothoff
Matthias Wachs

Definition in file ats-testing.c.

Function Documentation

◆ do_shutdown()

static void do_shutdown ( void *  cls)
static

Shutdown nicely.

Parameters
clsNULL

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

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

Referenced by main_run().

63 {
64  int c_m;
65  int c_s;
66  int c_op;
67  struct BenchmarkPeer *p;
68 
70 
72  "Benchmarking done\n");
73 
75 
76  for (c_m = 0; c_m < top->num_masters; c_m++)
77  {
78  p = &top->mps[c_m];
79  if (NULL != top->mps[c_m].peer_id_op)
80  {
82  p->peer_id_op = NULL;
83  }
84 
85  if (NULL != p->ats_task)
87  p->ats_task = NULL;
88 
89  for (c_op = 0; c_op < p->num_partners; c_op++)
90  {
91  if ((NULL != p->core_connect_ops) &&
92  (NULL != p->core_connect_ops[c_op].connect_op))
93  {
95  "Failed to connect peer 0 and %u\n",
96  c_op);
98  p->core_connect_ops[c_op].connect_op = NULL;
99  }
100  }
101 
102  if (NULL != p->ats_perf_op)
103  {
105  p->ats_perf_op = NULL;
106  }
107 
108  if (NULL != p->comm_op)
109  {
111  p->comm_op = NULL;
112  }
114  GNUNET_free (p->partners);
115  p->partners = NULL;
116  }
117 
118  for (c_s = 0; c_s < top->num_slaves; c_s++)
119  {
120  p = &top->sps[c_s];
121  if (NULL != p->peer_id_op)
122  {
124  p->peer_id_op = NULL;
125  }
126  if (NULL != p->ats_perf_op)
127  {
129  p->ats_perf_op = NULL;
130  }
131  if (NULL != p->comm_op)
132  {
134  p->comm_op = NULL;
135  }
136  GNUNET_free (p->partners);
137  p->partners = NULL;
138  }
140  GNUNET_free (top);
141  top = NULL;
142 }
struct GNUNET_TESTBED_Operation * comm_op
Testbed operation to connect to core.
Definition: ats-testing.h:146
struct GNUNET_TESTBED_Operation * peer_id_op
Testbed operation to get peer information.
Definition: ats-testing.h:136
struct GNUNET_TESTBED_Operation * ats_perf_op
Testbed operation to connect to ATS performance service.
Definition: ats-testing.h:141
struct BenchmarkPartner * partners
Array of partners with num_slaves entries (if master) or num_master entries (if slave) ...
Definition: ats-testing.h:191
struct GNUNET_ATS_TEST_Topology * top
Definition: ats-testing.c:53
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:526
int num_partners
Number of partners.
Definition: ats-testing.h:196
int benchmarking
Are we connected to CORE service of all peers: GNUNET_YES/NO.
Definition: ats-testing.h:387
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
Information we track for a peer in the testbed.
Definition: ats-testing.h:111
struct BenchmarkState state
Benchmark state.
Definition: ats-testing.h:461
void GNUNET_TESTBED_operation_done(struct GNUNET_TESTBED_Operation *operation)
This function is used to signal that the event information (struct GNUNET_TESTBED_EventInformation) f...
Definition: testbed_api.c:2044
unsigned int num_slaves
Number slave peers.
Definition: ats-testing.h:441
struct BenchmarkPeer * sps
Array of slave peers.
Definition: ats-testing.h:446
struct BenchmarkPeer * mps
Array of master peers.
Definition: ats-testing.h:436
struct GNUNET_SCHEDULER_Task * ats_task
Masters only Progress task.
Definition: ats-testing.h:179
#define GNUNET_log(kind,...)
void GNUNET_ATS_TEST_generate_traffic_stop_all()
Stop all traffic generators.
struct TestbedConnectOperation * core_connect_ops
Masters only: Testbed connect operations to connect masters to slaves.
Definition: ats-testing.h:157
unsigned int num_masters
Number master peers.
Definition: ats-testing.h:431
struct GNUNET_TESTBED_Operation * connect_op
Testbed operation to connect peers.
Definition: ats-testing.c:48
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
Here is the call graph for this function:
Here is the caller graph for this function:

◆ find_partner()

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

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

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

Referenced by ats_performance_info_cb(), and comm_connect_cb().

148 {
149  int c_m;
150 
151  for (c_m = 0; c_m < me->num_partners; c_m++)
152  {
153  /* Find a partner with other as destination */
154  if (0 == GNUNET_memcmp (peer,
155  &me->partners[c_m].dest->id))
156  {
157  return &me->partners[c_m];
158  }
159  }
160 
161  return NULL;
162 }
struct BenchmarkPartner * partners
Array of partners with num_slaves entries (if master) or num_master entries (if slave) ...
Definition: ats-testing.h:191
int num_partners
Number of partners.
Definition: ats-testing.h:196
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
struct BenchmarkPeer * dest
The partner peer.
Definition: ats-testing.h:285
struct GNUNET_PeerIdentity id
Peer ID.
Definition: ats-testing.h:131
Here is the caller graph for this function:

◆ find_peer()

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

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

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

Referenced by comm_connect_cb().

167 {
168  int c_p;
169 
170  for (c_p = 0; c_p < top->num_masters; c_p++)
171  {
172  if (0 == GNUNET_memcmp (&top->mps[c_p].id,
173  peer))
174  return &top->mps[c_p];
175  }
176 
177  for (c_p = 0; c_p < top->num_slaves; c_p++)
178  {
179  if (0 == GNUNET_memcmp (&top->sps[c_p].id,
180  peer))
181  return &top->sps[c_p];
182  }
183  return NULL;
184 }
struct GNUNET_ATS_TEST_Topology * top
Definition: ats-testing.c:53
unsigned int num_slaves
Number slave peers.
Definition: ats-testing.h:441
struct BenchmarkPeer * sps
Array of slave peers.
Definition: ats-testing.h:446
struct BenchmarkPeer * mps
Array of master peers.
Definition: ats-testing.h:436
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
unsigned int num_masters
Number master peers.
Definition: ats-testing.h:431
struct GNUNET_PeerIdentity id
Peer ID.
Definition: ats-testing.h:131
Here is the caller graph for this function:

◆ comm_connect_cb()

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

Method called whenever a given peer connects.

Parameters
clsclosure
peerpeer identity this notification is about
mqqueue to use to send messages to peer
Returns
the struct BenchmarkPartner of peer

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

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

Referenced by core_connect_adapter(), and transport_connect_adapter().

199 {
200  struct BenchmarkPeer *me = cls;
201  struct BenchmarkPeer *remote;
202  struct BenchmarkPartner *p;
203  char *id;
204  int c;
205  int completed;
206 
207  remote = find_peer (peer);
208  if (NULL == remote)
209  {
211  "Unknown peer connected: `%s'\n",
212  GNUNET_i2s (peer));
213  GNUNET_break (0);
214  return NULL;
215  }
216 
217  id = GNUNET_strdup (GNUNET_i2s (&me->id));
219  "%s [%u] `%s' connected to %s [%u] %s\n",
220  (me->master == GNUNET_YES) ? "Master" : "Slave",
221  me->no,
222  id,
223  (remote->master == GNUNET_YES) ? "Master" : "Slave",
224  remote->no,
225  GNUNET_i2s (peer));
226 
227  me->core_connections++;
228  if ((GNUNET_YES == me->master) &&
229  (GNUNET_NO == remote->master) &&
231  {
233 
235  {
237  "Master [%u] connected all slaves\n",
238  me->no);
239  }
240  completed = GNUNET_YES;
241  for (c = 0; c < top->num_masters; c++)
242  {
244  completed = GNUNET_NO;
245  }
246  if (GNUNET_YES == completed)
247  {
249  "All master peers connected all slave peers\n");
251  /* Notify about setup done */
252  if (NULL != top->done_cb)
254  top->mps,
255  top->sps);
256  }
257  }
258  GNUNET_free (id);
259  p = find_partner (me,
260  peer);
261  if (NULL != p)
262  p->mq = mq;
263  return p;
264 }
static GNUNET_NETWORK_STRUCT_END struct GNUNET_PeerIdentity me
Our own peer identity.
int connected_CORE
Are we connected to all slave peers on CORE level: GNUNET_YES/NO.
Definition: ats-testing.h:382
static struct BenchmarkPartner * find_partner(struct BenchmarkPeer *me, const struct GNUNET_PeerIdentity *peer)
Definition: ats-testing.c:146
struct GNUNET_ATS_TEST_Topology * top
Definition: ats-testing.c:53
#define GNUNET_NO
Definition: gnunet_common.h:78
static struct GNUNET_IDENTITY_Handle * id
Handle to identity service.
int core_connections
Number of core connections.
Definition: ats-testing.h:201
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
int no
Unique identifier.
Definition: ats-testing.h:121
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
Information we track for a peer in the testbed.
Definition: ats-testing.h:111
struct BenchmarkState state
Benchmark state.
Definition: ats-testing.h:461
int master
Is this peer a measter: GNUNET_YES/GNUNET_NO.
Definition: ats-testing.h:126
Information about a benchmarking partner.
Definition: ats-testing.h:275
int core_slave_connections
Masters only: Number of connections to slave peers.
Definition: ats-testing.h:207
unsigned int num_slaves
Number slave peers.
Definition: ats-testing.h:441
struct BenchmarkPeer * sps
Array of slave peers.
Definition: ats-testing.h:446
struct BenchmarkPeer * mps
Array of master peers.
Definition: ats-testing.h:436
struct GNUNET_MQ_Handle * mq
Message queue handle.
Definition: ats-testing.h:290
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
#define GNUNET_log(kind,...)
#define GNUNET_YES
Definition: gnunet_common.h:77
GNUNET_ATS_TEST_TopologySetupDoneCallback done_cb
Definition: ats-testing.h:463
unsigned int num_masters
Number master peers.
Definition: ats-testing.h:431
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct GNUNET_PeerIdentity id
Peer ID.
Definition: ats-testing.h:131
#define GNUNET_free(ptr)
Wrapper around free.
static struct BenchmarkPeer * find_peer(const struct GNUNET_PeerIdentity *peer)
Definition: ats-testing.c:166
Here is the call graph for this function:
Here is the caller graph for this function:

◆ comm_disconnect_cb()

static void comm_disconnect_cb ( void *  cls,
const struct GNUNET_PeerIdentity peer,
void *  internal_cls 
)
static
Parameters
clsthis peer
peerid of disconnecting peer
internal_clsthe struct BenchmarkPartner of peer

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

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

Referenced by core_connect_adapter(), and transport_connect_adapter().

276 {
277  struct BenchmarkPeer *me = cls;
278  struct BenchmarkPartner *p = internal_cls;
279  char *id;
280 
281  if (NULL == p)
282  return;
283 
284  id = GNUNET_strdup (GNUNET_i2s (&me->id));
286  "%s disconnected from %s\n",
287  id,
288  GNUNET_i2s (peer));
290  me->core_connections--;
291 
292  if ((GNUNET_YES == top->state.benchmarking) &&
293  ((GNUNET_YES == me->master) ||
294  (GNUNET_YES == p->dest->master)))
295  {
297  "%s disconnected from %s while benchmarking\n",
298  id,
299  GNUNET_i2s (peer));
300  }
301  GNUNET_free (id);
302 }
static GNUNET_NETWORK_STRUCT_END struct GNUNET_PeerIdentity me
Our own peer identity.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_ATS_TEST_Topology * top
Definition: ats-testing.c:53
static struct GNUNET_IDENTITY_Handle * id
Handle to identity service.
int core_connections
Number of core connections.
Definition: ats-testing.h:201
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
int benchmarking
Are we connected to CORE service of all peers: GNUNET_YES/NO.
Definition: ats-testing.h:387
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
Information we track for a peer in the testbed.
Definition: ats-testing.h:111
struct BenchmarkState state
Benchmark state.
Definition: ats-testing.h:461
int master
Is this peer a measter: GNUNET_YES/GNUNET_NO.
Definition: ats-testing.h:126
Information about a benchmarking partner.
Definition: ats-testing.h:275
#define GNUNET_log(kind,...)
#define GNUNET_YES
Definition: gnunet_common.h:77
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
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_pong()

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

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

References GNUNET_ATS_TEST_traffic_handle_pong(), and p.

308 {
309  struct BenchmarkPartner *p = cls;
310 
312 }
void GNUNET_ATS_TEST_traffic_handle_pong(struct BenchmarkPartner *p)
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
Information about a benchmarking partner.
Definition: ats-testing.h:275
Here is the call graph for this function:

◆ handle_ping()

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

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

References GNUNET_ATS_TEST_traffic_handle_ping(), and p.

318 {
319  struct BenchmarkPartner *p = cls;
320 
322 }
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
Information about a benchmarking partner.
Definition: ats-testing.h:275
Here is the call graph for this function:

◆ transport_connect_adapter()

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

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

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

Referenced by do_comm_connect().

328 {
329  struct BenchmarkPeer *me = cls;
333  struct TestMessage,
334  me),
337  struct TestMessage,
338  me),
340  };
341 
343  &me->id,
344  handlers,
345  me,
348  NULL);
349  if (NULL == me->th)
351  "Failed to create transport connection \n");
352  return me->th;
353 }
static GNUNET_NETWORK_STRUCT_END struct GNUNET_PeerIdentity me
Our own peer identity.
static void ping(void *cls)
Send a ping to destination.
#define TEST_MESSAGE_TYPE_PONG
Message type sent as response during traffic generation.
Definition: ats-testing.h:43
static void * comm_connect_cb(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
Method called whenever a given peer connects.
Definition: ats-testing.c:196
struct GNUNET_TRANSPORT_CoreHandle * th
Transport handle.
Definition: ats-testing.h:167
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define TEST_MESSAGE_TYPE_PING
Message type sent for traffic generation.
Definition: ats-testing.h:38
struct GNUNET_TRANSPORT_CoreHandle * GNUNET_TRANSPORT_core_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_PeerIdentity *self, const struct GNUNET_MQ_MessageHandler *handlers, void *cls, GNUNET_TRANSPORT_NotifyConnect nc, GNUNET_TRANSPORT_NotifyDisconnect nd)
Connect to the transport service.
static void comm_disconnect_cb(void *cls, const struct GNUNET_PeerIdentity *peer, void *internal_cls)
Definition: ats-testing.c:273
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
Information we track for a peer in the testbed.
Definition: ats-testing.h:111
Message handler for a specific message type.
static void pong(struct GNUNET_CADET_Channel *channel, const struct CadetPingMessage *ping)
Reply with a pong to origin.
#define GNUNET_log(kind,...)
struct GNUNET_PeerIdentity id
Peer ID.
Definition: ats-testing.h:131
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ transport_disconnect_adapter()

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

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

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

Referenced by do_comm_connect().

359 {
360  struct BenchmarkPeer *me = cls;
361 
363  me->th = NULL;
364 }
static GNUNET_NETWORK_STRUCT_END struct GNUNET_PeerIdentity me
Our own peer identity.
struct GNUNET_TRANSPORT_CoreHandle * th
Transport handle.
Definition: ats-testing.h:167
Information we track for a peer in the testbed.
Definition: ats-testing.h:111
void GNUNET_TRANSPORT_core_disconnect(struct GNUNET_TRANSPORT_CoreHandle *handle)
Disconnect from the transport service.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ core_connect_adapter()

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

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

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

Referenced by do_comm_connect().

370 {
371  struct BenchmarkPeer *me = cls;
375  struct TestMessage,
376  me),
379  struct TestMessage,
380  me),
382  };
383 
384  me->ch = GNUNET_CORE_connect (cfg,
385  me,
386  NULL,
389  handlers);
390  if (NULL == me->ch)
392  "Failed to create core connection \n");
393  return me->ch;
394 }
static GNUNET_NETWORK_STRUCT_END struct GNUNET_PeerIdentity me
Our own peer identity.
static void ping(void *cls)
Send a ping to destination.
#define TEST_MESSAGE_TYPE_PONG
Message type sent as response during traffic generation.
Definition: ats-testing.h:43
static void * comm_connect_cb(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
Method called whenever a given peer connects.
Definition: ats-testing.c:196
struct GNUNET_CORE_Handle * ch
Core handle.
Definition: ats-testing.h:162
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define TEST_MESSAGE_TYPE_PING
Message type sent for traffic generation.
Definition: ats-testing.h:38
static void comm_disconnect_cb(void *cls, const struct GNUNET_PeerIdentity *peer, void *internal_cls)
Definition: ats-testing.c:273
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
Information we track for a peer in the testbed.
Definition: ats-testing.h:111
Message handler for a specific message type.
static void pong(struct GNUNET_CADET_Channel *channel, const struct CadetPingMessage *ping)
Reply with a pong to origin.
struct GNUNET_CORE_Handle * GNUNET_CORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, void *cls, GNUNET_CORE_StartupCallback init, GNUNET_CORE_ConnectEventHandler connects, GNUNET_CORE_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Connect to the core service.
Definition: core_api.c:692
#define GNUNET_log(kind,...)
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ core_disconnect_adapter()

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

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

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

Referenced by do_comm_connect().

400 {
401  struct BenchmarkPeer *me = cls;
402 
404  me->ch = NULL;
405 }
static GNUNET_NETWORK_STRUCT_END struct GNUNET_PeerIdentity me
Our own peer identity.
struct GNUNET_CORE_Handle * ch
Core handle.
Definition: ats-testing.h:162
Information we track for a peer in the testbed.
Definition: ats-testing.h:111
void GNUNET_CORE_disconnect(struct GNUNET_CORE_Handle *handle)
Disconnect from the core service.
Definition: core_api.c:730
Here is the call graph for this function:
Here is the caller graph for this function:

◆ connect_completion_callback()

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

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

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

Referenced by do_connect_peers().

412 {
413  struct TestbedConnectOperation *cop = cls;
414  static int ops = 0;
415  int c;
416 
417  if (NULL == emsg)
418  {
420  _ ("Connected master [%u] with slave [%u]\n"),
421  cop->master->no,
422  cop->slave->no);
423  }
424  else
425  {
427  _ ("Failed to connect master peer [%u] with slave [%u]\n"),
428  cop->master->no, cop->slave->no);
429  GNUNET_break (0);
431  }
433  ops++;
434  for (c = 0; c < top->num_slaves; c++)
435  {
436  if (cop == &cop->master->core_connect_ops[c])
437  cop->master->core_connect_ops[c].connect_op = NULL;
438  }
439  if (ops == top->num_masters * top->num_slaves)
440  {
442  }
443 }
struct BenchmarkPeer * slave
The benchmarking slave to connect to.
Definition: ats-testing.c:43
struct BenchmarkPeer * master
The benchmarking master initiating this connection.
Definition: ats-testing.c:38
Connect peers with testbed.
Definition: ats-testing.c:33
struct GNUNET_ATS_TEST_Topology * top
Definition: ats-testing.c:53
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:526
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
int no
Unique identifier.
Definition: ats-testing.h:121
struct BenchmarkState state
Benchmark state.
Definition: ats-testing.h:461
void GNUNET_TESTBED_operation_done(struct GNUNET_TESTBED_Operation *operation)
This function is used to signal that the event information (struct GNUNET_TESTBED_EventInformation) f...
Definition: testbed_api.c:2044
unsigned int num_slaves
Number slave peers.
Definition: ats-testing.h:441
int connected_PEERS
Are we connected to all peers: GNUNET_YES/NO.
Definition: ats-testing.h:377
#define GNUNET_log(kind,...)
#define GNUNET_YES
Definition: gnunet_common.h:77
struct TestbedConnectOperation * core_connect_ops
Masters only: Testbed connect operations to connect masters to slaves.
Definition: ats-testing.h:157
unsigned int num_masters
Number master peers.
Definition: ats-testing.h:431
struct GNUNET_TESTBED_Operation * connect_op
Testbed operation to connect peers.
Definition: ats-testing.c:48
Here is the call graph for this function:
Here is the caller graph for this function:

◆ do_connect_peers()

static void do_connect_peers ( void *  cls)
static

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

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

Referenced by comm_connect_completion_cb().

448 {
449  int c_m;
450  int c_s;
451  struct BenchmarkPeer *p;
452 
455  return;
456 
458  "Connecting peers on CORE level\n");
459  for (c_m = 0; c_m < top->num_masters; c_m++)
460  {
461  p = &top->mps[c_m];
463  * sizeof(struct
465 
466  for (c_s = 0; c_s < top->num_slaves; c_s++)
467  {
469  "Connecting master [%u] with slave [%u]\n",
470  p->no,
471  top->sps[c_s].no);
472  p->core_connect_ops[c_s].master = p;
473  p->core_connect_ops[c_s].slave = &top->sps[c_s];
477  &p->core_connect_ops[c_s],
478  top->sps[c_s].peer,
479  p->peer);
480  if (NULL == p->core_connect_ops[c_s].connect_op)
481  {
483  "Could not connect master [%u] and slave [%u]\n",
484  p->no,
485  top->sps[c_s].no);
486  GNUNET_break (0);
488  return;
489  }
490  }
491  }
492 }
struct BenchmarkPeer * slave
The benchmarking slave to connect to.
Definition: ats-testing.c:43
static void connect_completion_callback(void *cls, struct GNUNET_TESTBED_Operation *op, const char *emsg)
Definition: ats-testing.c:409
struct BenchmarkPeer * master
The benchmarking master initiating this connection.
Definition: ats-testing.c:38
Connect peers with testbed.
Definition: ats-testing.c:33
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_overlay_connect(void *op_cls, GNUNET_TESTBED_OperationCompletionCallback cb, void *cb_cls, struct GNUNET_TESTBED_Peer *p1, struct GNUNET_TESTBED_Peer *p2)
Both peers must have been started before calling this function.
struct GNUNET_ATS_TEST_Topology * top
Definition: ats-testing.c:53
#define GNUNET_NO
Definition: gnunet_common.h:78
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:526
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
int no
Unique identifier.
Definition: ats-testing.h:121
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
Information we track for a peer in the testbed.
Definition: ats-testing.h:111
struct BenchmarkState state
Benchmark state.
Definition: ats-testing.h:461
unsigned int num_slaves
Number slave peers.
Definition: ats-testing.h:441
struct BenchmarkPeer * sps
Array of slave peers.
Definition: ats-testing.h:446
struct BenchmarkPeer * mps
Array of master peers.
Definition: ats-testing.h:436
#define GNUNET_log(kind,...)
int connected_ATS_service
Are we connected to ATS service of all peers: GNUNET_YES/NO.
Definition: ats-testing.h:367
struct TestbedConnectOperation * core_connect_ops
Masters only: Testbed connect operations to connect masters to slaves.
Definition: ats-testing.h:157
int connected_COMM_service
Are we connected to CORE service of all peers: GNUNET_YES/NO.
Definition: ats-testing.h:372
unsigned int num_masters
Number master peers.
Definition: ats-testing.h:431
struct GNUNET_TESTBED_Operation * connect_op
Testbed operation to connect peers.
Definition: ats-testing.c:48
struct GNUNET_TESTBED_Peer * peer
Handle with testbed.
Definition: ats-testing.h:116
#define GNUNET_malloc(size)
Wrapper around malloc.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ comm_connect_completion_cb()

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

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

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

Referenced by do_comm_connect().

500 {
501  static int comm_done = 0;
502 
503  if ((NULL != emsg) || (NULL == ca_result))
504  {
506  "Initialization failed, shutdown\n");
507  GNUNET_break (0);
509  return;
510  }
511  comm_done++;
512 
513  if (comm_done == top->num_slaves + top->num_masters)
514  {
516  "Connected to all %s services\n",
517  (GNUNET_YES == top->test_core) ? "CORE" : "TRANSPORT");
520  NULL);
521  }
522 }
int test_core
Test core (GNUNET_YES) or transport (GNUNET_NO)
Definition: ats-testing.h:406
struct GNUNET_ATS_TEST_Topology * top
Definition: ats-testing.c:53
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:526
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct BenchmarkState state
Benchmark state.
Definition: ats-testing.h:461
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:1280
unsigned int num_slaves
Number slave peers.
Definition: ats-testing.h:441
static void do_connect_peers(void *cls)
Definition: ats-testing.c:447
#define GNUNET_log(kind,...)
#define GNUNET_YES
Definition: gnunet_common.h:77
int connected_COMM_service
Are we connected to CORE service of all peers: GNUNET_YES/NO.
Definition: ats-testing.h:372
unsigned int num_masters
Number master peers.
Definition: ats-testing.h:431
Here is the call graph for this function:
Here is the caller graph for this function:

◆ do_comm_connect()

static void do_comm_connect ( void *  cls)
static

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

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

Referenced by ats_connect_completion_cb().

527 {
528  int c_s;
529  int c_m;
530 
532  "Connecting to all %s services\n",
533  (GNUNET_YES == top->test_core) ? "CORE" : "TRANSPORT");
534  for (c_m = 0; c_m < top->num_masters; c_m++)
535  {
536  if (GNUNET_YES == top->test_core)
537  top->mps[c_m].comm_op
539  top->mps[c_m].peer,
540  "core",
542  NULL,
545  &top->mps[c_m]);
546  else
547  {
548  top->mps[c_m].comm_op
550  top->mps[c_m].peer,
551  "transport",
553  NULL,
556  &top->mps[c_m]);
557  }
558  }
559 
560  for (c_s = 0; c_s < top->num_slaves; c_s++)
561  {
562  if (GNUNET_YES == top->test_core)
563  top->sps[c_s].comm_op
565  top->sps[c_s].peer,
566  "core",
568  NULL,
571  &top->sps[c_s]);
572  else
573  {
574  top->sps[c_s].comm_op
576  top->sps[c_s].peer,
577  "transport",
579  NULL,
582  &top->sps[c_s]);
583  }
584  }
585 }
int test_core
Test core (GNUNET_YES) or transport (GNUNET_NO)
Definition: ats-testing.h:406
struct GNUNET_TESTBED_Operation * comm_op
Testbed operation to connect to core.
Definition: ats-testing.h:146
struct GNUNET_ATS_TEST_Topology * top
Definition: ats-testing.c:53
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_service_connect(void *op_cls, struct GNUNET_TESTBED_Peer *peer, const char *service_name, GNUNET_TESTBED_ServiceConnectCompletionCallback cb, void *cb_cls, GNUNET_TESTBED_ConnectAdapter ca, GNUNET_TESTBED_DisconnectAdapter da, void *cada_cls)
Connect to a service offered by the given peer.
static void * core_connect_adapter(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
Definition: ats-testing.c:368
unsigned int num_slaves
Number slave peers.
Definition: ats-testing.h:441
static void comm_connect_completion_cb(void *cls, struct GNUNET_TESTBED_Operation *op, void *ca_result, const char *emsg)
Definition: ats-testing.c:496
struct BenchmarkPeer * sps
Array of slave peers.
Definition: ats-testing.h:446
struct BenchmarkPeer * mps
Array of master peers.
Definition: ats-testing.h:436
static void * transport_connect_adapter(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
Definition: ats-testing.c:326
#define GNUNET_log(kind,...)
#define GNUNET_YES
Definition: gnunet_common.h:77
static void core_disconnect_adapter(void *cls, void *op_result)
Definition: ats-testing.c:398
unsigned int num_masters
Number master peers.
Definition: ats-testing.h:431
struct GNUNET_TESTBED_Peer * peer
Handle with testbed.
Definition: ats-testing.h:116
static void transport_disconnect_adapter(void *cls, void *op_result)
Definition: ats-testing.c:357
Here is the call graph for this function:
Here is the caller graph for this function:

◆ ats_performance_info_cb()

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

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

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

Referenced by ats_perf_connect_adapter().

595 {
596  struct BenchmarkPeer *me = cls;
597  struct BenchmarkPartner *p;
598  int log;
599  char *peer_id;
600 
601  if (NULL == address)
602  {
604  "Peer %u: ATS Service disconnected!\n",
605  me->no);
606  return;
607  }
608 
609  p = find_partner (me,
610  &address->peer);
611  if (NULL == p)
612  {
613  /* This is not one of my partners
614  * Will happen since the peers will connect to each other due to gossiping
615  */
616  return;
617  }
618  peer_id = GNUNET_strdup (GNUNET_i2s (&me->id));
619 
620  log = GNUNET_NO;
621  if ((p->bandwidth_in != ntohl (bandwidth_in.value__)) ||
622  (p->bandwidth_out != ntohl (bandwidth_out.value__)))
623  log = GNUNET_YES;
624  p->bandwidth_in = ntohl (bandwidth_in.value__);
625  p->bandwidth_out = ntohl (bandwidth_out.value__);
626 
628  "%s [%u] received ATS information: %s\n",
629  (GNUNET_YES == p->me->master) ? "Master" : "Slave",
630  p->me->no,
631  GNUNET_i2s (&p->dest->id));
632 
633  p->props.utilization_out = ats_prop->utilization_out;
634  p->props.utilization_in = ats_prop->utilization_in;
635  p->props.scope = ats_prop->scope;
636  p->props.delay = ats_prop->delay;
637  p->props.distance = ats_prop->distance;
638 
639  if (GNUNET_YES == log)
640  top->ats_perf_cb (cls, address,
641  address_active,
642  bandwidth_out,
643  bandwidth_in,
644  ats_prop);
645  GNUNET_free (peer_id);
646 }
static GNUNET_NETWORK_STRUCT_END struct GNUNET_PeerIdentity me
Our own peer identity.
uint32_t utilization_in
Actual traffic on this connection from the other peer to this peer.
static struct BenchmarkPartner * find_partner(struct BenchmarkPeer *me, const struct GNUNET_PeerIdentity *peer)
Definition: ats-testing.c:146
struct GNUNET_ATS_TEST_Topology * top
Definition: ats-testing.c:53
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
uint32_t value__
The actual value (bytes per second).
int no
Unique identifier.
Definition: ats-testing.h:121
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
uint32_t bandwidth_in
Bandwidth assigned inbound.
Definition: ats-testing.h:340
Information we track for a peer in the testbed.
Definition: ats-testing.h:111
int master
Is this peer a measter: GNUNET_YES/GNUNET_NO.
Definition: ats-testing.h:126
Information about a benchmarking partner.
Definition: ats-testing.h:275
struct GNUNET_TIME_Relative delay
Delay.
uint32_t bandwidth_out
Bandwidth assigned outbound.
Definition: ats-testing.h:345
struct GNUNET_PeerIdentity peer
For which peer is this an address?
GNUNET_ATS_AddressInformationCallback ats_perf_cb
Definition: ats-testing.h:465
enum GNUNET_NetworkType scope
Which network scope does the respective address belong to? This property does not change...
#define GNUNET_log(kind,...)
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_ATS_Properties props
Current ATS properties.
Definition: ats-testing.h:335
struct BenchmarkPeer * me
The peer itself this partner belongs to.
Definition: ats-testing.h:280
unsigned int distance
Distance on network layer (required for distance-vector routing) in hops.
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
#define GNUNET_free(ptr)
Wrapper around free.
uint32_t utilization_out
Actual traffic on this connection from this peer to the other peer.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ ats_perf_connect_adapter()

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

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

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

Referenced by do_connect_ats().

652 {
653  struct BenchmarkPeer *me = cls;
654 
655  me->ats_perf_handle
658  me);
659  if (NULL == me->ats_perf_handle)
661  "Failed to create ATS performance handle \n");
662  return me->ats_perf_handle;
663 }
static GNUNET_NETWORK_STRUCT_END struct GNUNET_PeerIdentity me
Our own peer identity.
static void ats_performance_info_cb(void *cls, const struct GNUNET_HELLO_Address *address, int address_active, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in, const struct GNUNET_ATS_Properties *ats_prop)
Definition: ats-testing.c:589
Information we track for a peer in the testbed.
Definition: ats-testing.h:111
struct GNUNET_ATS_PerformanceHandle * ats_perf_handle
ATS performance handle.
Definition: ats-testing.h:151
struct GNUNET_ATS_PerformanceHandle * GNUNET_ATS_performance_init(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_ATS_AddressInformationCallback addr_info_cb, void *addr_info_cb_cls)
Get handle to access performance API of the ATS subsystem.
#define GNUNET_log(kind,...)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ ats_perf_disconnect_adapter()

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

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

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

Referenced by do_connect_ats().

669 {
670  struct BenchmarkPeer *me = cls;
671 
673  me->ats_perf_handle = NULL;
674 }
static GNUNET_NETWORK_STRUCT_END struct GNUNET_PeerIdentity me
Our own peer identity.
void GNUNET_ATS_performance_done(struct GNUNET_ATS_PerformanceHandle *ph)
Client is done using the ATS performance subsystem, release resources.
Information we track for a peer in the testbed.
Definition: ats-testing.h:111
struct GNUNET_ATS_PerformanceHandle * ats_perf_handle
ATS performance handle.
Definition: ats-testing.h:151
Here is the call graph for this function:
Here is the caller graph for this function:

◆ ats_connect_completion_cb()

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

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

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

Referenced by do_connect_ats().

682 {
683  static int op_done = 0;
684 
685  if ((NULL != emsg) || (NULL == ca_result))
686  {
688  "Initialization failed, shutdown\n");
689  GNUNET_break (0);
691  return;
692  }
693  op_done++;
694  if (op_done == (top->num_masters + top->num_slaves))
695  {
697  "Connected to all ATS services\n");
700  NULL);
701  }
702 }
struct GNUNET_ATS_TEST_Topology * top
Definition: ats-testing.c:53
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:526
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct BenchmarkState state
Benchmark state.
Definition: ats-testing.h:461
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:1280
unsigned int num_slaves
Number slave peers.
Definition: ats-testing.h:441
#define GNUNET_log(kind,...)
int connected_ATS_service
Are we connected to ATS service of all peers: GNUNET_YES/NO.
Definition: ats-testing.h:367
#define GNUNET_YES
Definition: gnunet_common.h:77
static void do_comm_connect(void *cls)
Definition: ats-testing.c:526
unsigned int num_masters
Number master peers.
Definition: ats-testing.h:431
Here is the call graph for this function:
Here is the caller graph for this function:

◆ do_connect_ats()

static void do_connect_ats ( void *  cls)
static

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

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

Referenced by peerinformation_cb().

707 {
708  int c_m;
709  int c_s;
710 
712  "Connecting to all ATS services\n");
713  for (c_m = 0; c_m < top->num_masters; c_m++)
714  {
715  top->mps[c_m].ats_perf_op
717  top->mps[c_m].peer,
718  "ats",
720  NULL,
723  &top->mps[c_m]);
724  }
725 
726  for (c_s = 0; c_s < top->num_slaves; c_s++)
727  {
728  top->sps[c_s].ats_perf_op
730  top->sps[c_s].peer,
731  "ats",
733  NULL,
736  &top->sps[c_s]);
737  }
738 }
struct GNUNET_TESTBED_Operation * ats_perf_op
Testbed operation to connect to ATS performance service.
Definition: ats-testing.h:141
struct GNUNET_ATS_TEST_Topology * top
Definition: ats-testing.c:53
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_service_connect(void *op_cls, struct GNUNET_TESTBED_Peer *peer, const char *service_name, GNUNET_TESTBED_ServiceConnectCompletionCallback cb, void *cb_cls, GNUNET_TESTBED_ConnectAdapter ca, GNUNET_TESTBED_DisconnectAdapter da, void *cada_cls)
Connect to a service offered by the given peer.
static void * ats_perf_connect_adapter(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
Definition: ats-testing.c:650
unsigned int num_slaves
Number slave peers.
Definition: ats-testing.h:441
struct BenchmarkPeer * sps
Array of slave peers.
Definition: ats-testing.h:446
struct BenchmarkPeer * mps
Array of master peers.
Definition: ats-testing.h:436
static void ats_perf_disconnect_adapter(void *cls, void *op_result)
Definition: ats-testing.c:667
#define GNUNET_log(kind,...)
unsigned int num_masters
Number master peers.
Definition: ats-testing.h:431
struct GNUNET_TESTBED_Peer * peer
Handle with testbed.
Definition: ats-testing.h:116
static void ats_connect_completion_cb(void *cls, struct GNUNET_TESTBED_Operation *op, void *ca_result, const char *emsg)
Definition: ats-testing.c:678
Here is the call graph for this function:
Here is the caller graph for this function:

◆ peerinformation_cb()

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

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

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

Referenced by main_run().

746 {
747  struct BenchmarkPeer *p = cb_cls;
748  static int done = 0;
749 
751 
752  p->id = *pinfo->result.id;
754  "%s [%u] has peer id `%s'\n",
755  (p->master == GNUNET_YES) ? "Master" : "Slave",
756  p->no,
757  GNUNET_i2s (&p->id));
758 
760  p->peer_id_op = NULL;
761  done++;
762 
763  if (done == top->num_slaves + top->num_masters)
764  {
766  "Retrieved all peer ID, connect to ATS\n");
768  NULL);
769  }
770 }
static void done()
struct GNUNET_TESTBED_Operation * peer_id_op
Testbed operation to get peer information.
Definition: ats-testing.h:136
enum GNUNET_TESTBED_PeerInformationType pit
Peer information type; captures which of the types in the &#39;op_result&#39; is actually in use...
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_ATS_TEST_Topology * top
Definition: ats-testing.c:53
static void do_connect_ats(void *cls)
Definition: ats-testing.c:706
struct GNUNET_PeerIdentity * id
The identity of the peer.
int no
Unique identifier.
Definition: ats-testing.h:121
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
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:1280
int master
Is this peer a measter: GNUNET_YES/GNUNET_NO.
Definition: ats-testing.h:126
void GNUNET_TESTBED_operation_done(struct GNUNET_TESTBED_Operation *operation)
This function is used to signal that the event information (struct GNUNET_TESTBED_EventInformation) f...
Definition: testbed_api.c:2044
unsigned int num_slaves
Number slave peers.
Definition: ats-testing.h:441
What is the identity of the peer? Returns a &#39;const struct GNUNET_PeerIdentity *&#39;. ...
#define GNUNET_log(kind,...)
#define GNUNET_YES
Definition: gnunet_common.h:77
union GNUNET_TESTBED_PeerInformation::@61 result
The result of the get information operation; Choose according to the pit.
unsigned int num_masters
Number master peers.
Definition: ats-testing.h:431
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct GNUNET_PeerIdentity id
Peer ID.
Definition: ats-testing.h:131
Here is the call graph for this function:
Here is the caller graph for this function:

◆ main_run()

static void main_run ( void *  cls,
struct GNUNET_TESTBED_RunHandle h,
unsigned int  num_peers,
struct GNUNET_TESTBED_Peer **  peers_,
unsigned int  links_succeeded,
unsigned int  links_failed 
)
static

Signature of a main function for a testcase.

Parameters
clsclosure
htestbed handle
num_peersnumber of peers in 'peers'
peers_handle to peers run in the testbed
links_succeededthe number of overlay link connection attempts that succeeded
links_failedthe number of overlay link connection attempts that failed

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

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

Referenced by GNUNET_ATS_TEST_create_topology().

792 {
793  int c_m;
794  int c_s;
795 
796  GNUNET_assert (NULL == cls);
798  GNUNET_assert (NULL != peers_);
799 
801  top);
802 
804  "Setting up %u masters and %u slaves\n",
805  top->num_masters,
806  top->num_slaves);
807 
808  /* Setup master peers */
809  for (c_m = 0; c_m < top->num_masters; c_m++)
810  {
811  GNUNET_assert (NULL != peers_[c_m]);
812  top->mps[c_m].peer = peers_[c_m];
813  top->mps[c_m].no = c_m;
814  top->mps[c_m].master = GNUNET_YES;
815  top->mps[c_m].pref_partner = &top->sps[c_m];
817  top->mps[c_m].partners =
818  GNUNET_malloc (top->num_slaves * sizeof(struct BenchmarkPartner));
819  top->mps[c_m].num_partners = top->num_slaves;
820  /* Initialize partners */
821  for (c_s = 0; c_s < top->num_slaves; c_s++)
822  {
823  top->mps[c_m].partners[c_s].me = &top->mps[c_m];
824  top->mps[c_m].partners[c_s].dest = &top->sps[c_s];
825  }
826  /* Get configuration */
827  top->mps[c_m].peer_id_op
831  &top->mps[c_m]);
832  }
833 
834  /* Setup slave peers */
835  for (c_s = 0; c_s < top->num_slaves; c_s++)
836  {
837  GNUNET_assert (NULL != peers_[c_s + top->num_masters]);
838  top->sps[c_s].peer = peers_[c_s + top->num_masters];
839  top->sps[c_s].no = c_s + top->num_masters;
840  top->sps[c_s].master = GNUNET_NO;
841  top->sps[c_s].partners =
843  struct BenchmarkPartner);
845  /* Initialize partners */
846  for (c_m = 0; c_m < top->num_masters; c_m++)
847  {
848  top->sps[c_s].partners[c_m].me = &top->sps[c_s];
849  top->sps[c_s].partners[c_m].dest = &top->mps[c_m];
850 
851  /* Initialize properties */
853  top->sps[c_s].partners[c_m].props.distance = 0;
855  top->sps[c_s].partners[c_m].props.utilization_in = 0;
856  top->sps[c_s].partners[c_m].props.utilization_out = 0;
857  }
858  /* Get configuration */
859  top->sps[c_s].peer_id_op
863  &top->sps[c_s]);
864  }
865 }
static void peerinformation_cb(void *cb_cls, struct GNUNET_TESTBED_Operation *op, const struct GNUNET_TESTBED_PeerInformation *pinfo, const char *emsg)
Definition: ats-testing.c:742
struct GNUNET_TESTBED_Operation * peer_id_op
Testbed operation to get peer information.
Definition: ats-testing.h:136
uint32_t utilization_in
Actual traffic on this connection from the other peer to this peer.
#define TEST_ATS_PREFERENCE_DEFAULT
Definition: ats-testing.h:33
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1300
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct BenchmarkPartner * partners
Array of partners with num_slaves entries (if master) or num_master entries (if slave) ...
Definition: ats-testing.h:191
struct GNUNET_ATS_TEST_Topology * top
Definition: ats-testing.c:53
#define GNUNET_NO
Definition: gnunet_common.h:78
double pref_value
Masters only Progress task.
Definition: ats-testing.h:185
static void do_shutdown(void *cls)
Shutdown nicely.
Definition: ats-testing.c:62
int num_partners
Number of partners.
Definition: ats-testing.h:196
int no
Unique identifier.
Definition: ats-testing.h:121
int master
Is this peer a measter: GNUNET_YES/GNUNET_NO.
Definition: ats-testing.h:126
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
Information about a benchmarking partner.
Definition: ats-testing.h:275
struct GNUNET_TIME_Relative delay
Delay.
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_peer_get_information(struct GNUNET_TESTBED_Peer *peer, enum GNUNET_TESTBED_PeerInformationType pit, GNUNET_TESTBED_PeerInfoCallback cb, void *cb_cls)
Request information about a peer.
unsigned int num_slaves
Number slave peers.
Definition: ats-testing.h:441
struct BenchmarkPeer * sps
Array of slave peers.
Definition: ats-testing.h:446
struct BenchmarkPeer * mps
Array of master peers.
Definition: ats-testing.h:436
static unsigned int num_peers
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
enum GNUNET_NetworkType scope
Which network scope does the respective address belong to? This property does not change...
What is the identity of the peer? Returns a &#39;const struct GNUNET_PeerIdentity *&#39;. ...
#define GNUNET_log(kind,...)
struct BenchmarkPeer * pref_partner
Masters only: Peer to set ATS preferences for.
Definition: ats-testing.h:173
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_ATS_Properties props
Current ATS properties.
Definition: ats-testing.h:335
struct BenchmarkPeer * me
The peer itself this partner belongs to.
Definition: ats-testing.h:280
unsigned int distance
Distance on network layer (required for distance-vector routing) in hops.
unsigned int num_masters
Number master peers.
Definition: ats-testing.h:431
struct BenchmarkPeer * dest
The partner peer.
Definition: ats-testing.h:285
struct GNUNET_TESTBED_Peer * peer
Handle with testbed.
Definition: ats-testing.h:116
#define GNUNET_malloc(size)
Wrapper around malloc.
uint32_t utilization_out
Actual traffic on this connection from this peer to the other peer.
Category of last resort.
Definition: gnunet_nt_lib.h:40
Here is the call graph for this function:
Here is the caller graph for this function:

◆ controller_event_cb()

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

Controller event callback.

Parameters
clsNULL
eventthe controller event

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

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

Referenced by GNUNET_ATS_TEST_create_topology().

877 {
878  switch (event->type)
879  {
881  break;
882 
884  break;
885 
886  default:
887  GNUNET_break (0);
889  }
890 }
enum GNUNET_TESTBED_EventType type
Type of the event.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:526
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
A requested testbed operation has been completed.
A connection between two peers was established.
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().

895 {
896  if (src > top->num_masters)
897  return NULL;
898  return &top->mps[src];
899 }
struct GNUNET_ATS_TEST_Topology * top
Definition: ats-testing.c:53
struct BenchmarkPeer * mps
Array of master peers.
Definition: ats-testing.h:436
unsigned int num_masters
Number master peers.
Definition: ats-testing.h:431
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().

905 {
906  if (src > top->num_masters)
907  return NULL;
908  if (dest > top->num_slaves)
909  return NULL;
910  return &top->mps[src].partners[dest];
911 }
struct BenchmarkPartner * partners
Array of partners with num_slaves entries (if master) or num_master entries (if slave) ...
Definition: ats-testing.h:191
struct GNUNET_ATS_TEST_Topology * top
Definition: ats-testing.c:53
unsigned int num_slaves
Number slave peers.
Definition: ats-testing.h:441
struct BenchmarkPeer * mps
Array of master peers.
Definition: ats-testing.h:436
unsigned int num_masters
Number master peers.
Definition: ats-testing.h:431
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
nametest name
cfg_fileconfiguration file to use for the peers
num_slavesnumber of slaves
num_mastersnumber of masters
test_coreconnect to CORE service (GNUNET_YES) or transport (GNUNET_NO)
done_cbfunction to call when topology is setup
done_cb_clscls for callback
log_request_cbcallback 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().

936 {
938  top->num_masters = num_masters;
939  top->num_slaves = num_slaves;
940  top->done_cb = done_cb;
941  top->done_cb_cls = done_cb_cls;
942  top->test_core = test_core;
943  top->ats_perf_cb = log_request_cb;
944  top->mps = GNUNET_new_array (num_masters,
945  struct BenchmarkPeer);
946  top->sps = GNUNET_new_array (num_slaves,
947  struct BenchmarkPeer);
948 
949  /* Start topology */
950  uint64_t event_mask;
951  event_mask = 0;
952  event_mask |= (1LL << GNUNET_TESTBED_ET_CONNECT);
953  event_mask |= (1LL << GNUNET_TESTBED_ET_OPERATION_FINISHED);
955  cfg_file,
956  num_slaves + num_masters,
957  event_mask,
958  &controller_event_cb, NULL,
959  &main_run, NULL);
960 }
int test_core
Test core (GNUNET_YES) or transport (GNUNET_NO)
Definition: ats-testing.h:406
int GNUNET_TESTBED_test_run(const char *testname, const char *cfg_filename, unsigned int num_peers, uint64_t event_mask, GNUNET_TESTBED_ControllerCallback cc, void *cc_cls, GNUNET_TESTBED_TestMaster test_master, void *test_master_cls)
Convenience method for running a "simple" test on the local system with a single call from &#39;main&#39;...
struct GNUNET_ATS_TEST_Topology * top
Definition: ats-testing.c:53
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static void main_run(void *cls, struct GNUNET_TESTBED_RunHandle *h, unsigned int num_peers, struct GNUNET_TESTBED_Peer **peers_, unsigned int links_succeeded, unsigned int links_failed)
Signature of a main function for a testcase.
Definition: ats-testing.c:786
Information we track for a peer in the testbed.
Definition: ats-testing.h:111
A requested testbed operation has been completed.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
static const char * cfg_file
Configuration filename.
uint64_t event_mask
Global event mask for all testbed events.
unsigned int num_slaves
Number slave peers.
Definition: ats-testing.h:441
struct BenchmarkPeer * sps
Array of slave peers.
Definition: ats-testing.h:446
struct BenchmarkPeer * mps
Array of master peers.
Definition: ats-testing.h:436
A connection between two peers was established.
GNUNET_ATS_AddressInformationCallback ats_perf_cb
Definition: ats-testing.h:465
const char * name
static void controller_event_cb(void *cls, const struct GNUNET_TESTBED_EventInformation *event)
Controller event callback.
Definition: ats-testing.c:875
GNUNET_ATS_TEST_TopologySetupDoneCallback done_cb
Definition: ats-testing.h:463
unsigned int num_masters
Number master peers.
Definition: ats-testing.h:431
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().

968 {
969  if (NULL == top)
970  return;
972 }
struct GNUNET_ATS_TEST_Topology * top
Definition: ats-testing.c:53
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:526
Here is the call graph for this function:
Here is the caller graph for this function:

Variable Documentation

◆ cfg

Handle to our configuration.

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

◆ top

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

Referenced by exchange().