GNUnet  0.11.x
Macros | Functions | Variables
gnunet-ats-solver-eval.c File Reference
#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet-ats-solver-eval.h"
#include "gnunet-service-ats_normalization.h"
#include "gnunet-service-ats_preferences.c"
Include dependency graph for gnunet-ats-solver-eval.c:

Go to the source code of this file.

Macros

#define BIG_M_STRING   "unlimited"
 

Functions

static void end_now ()
 Do shutdown. More...
 
static char * print_generator_type (enum GeneratorType g)
 
static struct TestPeerfind_peer_by_id (int id)
 
static struct TestPeerfind_peer_by_pid (const struct GNUNET_PeerIdentity *pid)
 
static struct TestAddressfind_address_by_id (struct TestPeer *peer, int aid)
 
void GNUNET_ATS_solver_logging_now (struct LoggingHandle *l)
 Logging. More...
 
static void logging_task (void *cls)
 
struct LoggingHandleGNUNET_ATS_solver_logging_start (struct GNUNET_TIME_Relative freq)
 
void GNUNET_ATS_solver_logging_stop (struct LoggingHandle *l)
 
static struct LoggingFileHandlefind_logging_file_handle (struct LoggingFileHandle *lf_head, struct LoggingFileHandle *lf_tail, int peer_id, int address_id)
 
void GNUNET_ATS_solver_logging_write_to_disk (struct LoggingHandle *l, int add_time_stamp, char *output_dir)
 
void GNUNET_ATS_solver_logging_eval (struct LoggingHandle *l)
 
void GNUNET_ATS_solver_logging_free (struct LoggingHandle *l)
 
static double get_property (struct PropertyGenerator *pg)
 
static void set_prop_task (void *cls)
 
static struct PropertyGeneratorfind_prop_gen (unsigned int peer, unsigned int address, uint32_t ats_property)
 Set ats_property to 0 to find all pgs. More...
 
void GNUNET_ATS_solver_generate_property_stop (struct PropertyGenerator *pg)
 
struct PropertyGeneratorGNUNET_ATS_solver_generate_property_start (unsigned int peer, unsigned int address_id, struct TestPeer *test_peer, struct TestAddress *test_address, enum GeneratorType type, long int base_value, long int value_rate, struct GNUNET_TIME_Relative period, struct GNUNET_TIME_Relative frequency, uint32_t ats_property)
 Generate between the source master and the partner and set property with a value depending on the generator. More...
 
void GNUNET_ATS_solver_generate_property_stop_all ()
 Stop all preferences generators. More...
 
static double get_preference (struct PreferenceGenerator *pg)
 
static void set_feedback_task (void *cls)
 
static void set_pref_task (void *cls)
 
static struct PreferenceGeneratorfind_pref_gen (unsigned int peer, enum GNUNET_ATS_PreferenceKind kind)
 
void GNUNET_ATS_solver_generate_preferences_stop (struct PreferenceGenerator *pg)
 
static struct TestAddressfind_active_address (struct TestPeer *p)
 
struct PreferenceGeneratorGNUNET_ATS_solver_generate_preferences_start (unsigned int peer, unsigned int address_id, unsigned int client_id, enum GeneratorType type, long int base_value, long int value_rate, struct GNUNET_TIME_Relative period, struct GNUNET_TIME_Relative frequency, enum GNUNET_ATS_PreferenceKind kind, struct GNUNET_TIME_Relative feedback_frequency)
 Generate between the source master and the partner and set property with a value depending on the generator. More...
 
void GNUNET_ATS_solver_generate_preferences_stop_all ()
 Stop all preferences generators. More...
 
static const char * print_op (enum OperationType op)
 Experiments. More...
 
static struct Experimentcreate_experiment ()
 
static void free_experiment (struct Experiment *e)
 
static int load_op_add_address (struct GNUNET_ATS_TEST_Operation *o, struct Episode *e, int op_counter, char *sec_name, const struct GNUNET_CONFIGURATION_Handle *cfg)
 
static int load_op_del_address (struct GNUNET_ATS_TEST_Operation *o, struct Episode *e, int op_counter, char *sec_name, const struct GNUNET_CONFIGURATION_Handle *cfg)
 
static enum GNUNET_ATS_Property parse_preference_string (const char *str)
 
static int load_op_start_set_preference (struct GNUNET_ATS_TEST_Operation *o, struct Episode *e, int op_counter, char *sec_name, const struct GNUNET_CONFIGURATION_Handle *cfg)
 
static int load_op_stop_set_preference (struct GNUNET_ATS_TEST_Operation *o, struct Episode *e, int op_counter, char *sec_name, const struct GNUNET_CONFIGURATION_Handle *cfg)
 
static enum GNUNET_ATS_Property parse_property_string (const char *str)
 
static int load_op_start_set_property (struct GNUNET_ATS_TEST_Operation *o, struct Episode *e, int op_counter, char *sec_name, const struct GNUNET_CONFIGURATION_Handle *cfg)
 
static int load_op_stop_set_property (struct GNUNET_ATS_TEST_Operation *o, struct Episode *e, int op_counter, char *sec_name, const struct GNUNET_CONFIGURATION_Handle *cfg)
 
static int load_op_start_request (struct GNUNET_ATS_TEST_Operation *o, struct Episode *e, int op_counter, char *sec_name, const struct GNUNET_CONFIGURATION_Handle *cfg)
 
static int load_op_stop_request (struct GNUNET_ATS_TEST_Operation *o, struct Episode *e, int op_counter, char *sec_name, const struct GNUNET_CONFIGURATION_Handle *cfg)
 
static int load_episode (struct Experiment *e, struct Episode *cur, struct GNUNET_CONFIGURATION_Handle *cfg)
 
static int load_episodes (struct Experiment *e, struct GNUNET_CONFIGURATION_Handle *cfg)
 
static void timeout_experiment (void *cls)
 
struct ATS_Addresscreate_ats_address (const struct GNUNET_PeerIdentity *peer, const char *plugin_name, const void *plugin_addr, size_t plugin_addr_len, uint32_t session_id, uint32_t network)
 
static void enforce_add_address (struct GNUNET_ATS_TEST_Operation *op)
 
static void enforce_del_address (struct GNUNET_ATS_TEST_Operation *op)
 
static void enforce_start_property (struct GNUNET_ATS_TEST_Operation *op)
 
static void enforce_stop_property (struct GNUNET_ATS_TEST_Operation *op)
 
static void enforce_start_preference (struct GNUNET_ATS_TEST_Operation *op)
 
static void enforce_stop_preference (struct GNUNET_ATS_TEST_Operation *op)
 
static void enforce_start_request (struct GNUNET_ATS_TEST_Operation *op)
 
static void enforce_stop_request (struct GNUNET_ATS_TEST_Operation *op)
 
static void enforce_episode (struct Episode *ep)
 
static void timeout_episode (void *cls)
 
void GNUNET_ATS_solvers_experimentation_run (struct Experiment *e, GNUNET_ATS_TESTING_EpisodeDoneCallback ep_done_cb, GNUNET_ATS_TESTING_ExperimentDoneCallback e_done_cb)
 
void GNUNET_ATS_solvers_experimentation_stop (struct Experiment *e)
 
struct ExperimentGNUNET_ATS_solvers_experimentation_load (char *filename)
 
static int free_all_it (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
 Solver. More...
 
void GNUNET_ATS_solvers_solver_stop (struct SolverHandle *sh)
 
unsigned int GNUNET_ATS_solvers_load_quotas (const struct GNUNET_CONFIGURATION_Handle *cfg, unsigned long long *out_dest, unsigned long long *in_dest, int dest_length)
 Load quotas for networks from configuration. More...
 
static void solver_info_cb (void *cls, enum GAS_Solver_Operation op, enum GAS_Solver_Status stat, enum GAS_Solver_Additional_Information add)
 Information callback for the solver. More...
 
static void solver_bandwidth_changed_cb (void *cls, struct ATS_Address *address)
 
const double * get_preferences_cb (void *cls, const struct GNUNET_PeerIdentity *id)
 
struct SolverHandleGNUNET_ATS_solvers_solver_start (enum GNUNET_ATS_Solvers type)
 
static void done ()
 
static void experiment_done_cb (struct Experiment *e, struct GNUNET_TIME_Relative duration, int success)
 
static void episode_done_cb (struct Episode *ep)
 
static void run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 
int main (int argc, char *argv[])
 Main function of the benchmark. More...
 

Variables

struct GNUNET_STATISTICS_HandleGSA_stats
 Handle for statistics. More...
 
static struct Experimente
 
static struct LoggingHandlel
 
static struct SolverHandlesh
 
static struct TestPeerpeer_head
 
static struct TestPeerpeer_tail
 
static double default_properties [GNUNET_ATS_PropertyCount]
 
static double default_preferences [GNUNET_ATS_PreferenceCount]
 
static char * opt_exp_file
 cmd option -e: experiment file More...
 
static char * opt_solver
 
static int opt_log
 cmd option -l: enable logging More...
 
static int opt_save
 cmd option -p: enable plots More...
 
static int opt_verbose
 cmd option -v: verbose logs More...
 
static int opt_print
 cmd option -p: print logs More...
 
static int opt_disable_normalization
 cmd option -d: disable normalization More...
 
static int res
 
static struct PropertyGeneratorprop_gen_head
 Property Generators. More...
 
static struct PropertyGeneratorprop_gen_tail
 
static struct PreferenceGeneratorpref_gen_head
 Preference Generators. More...
 
static struct PreferenceGeneratorpref_gen_tail
 

Macro Definition Documentation

◆ BIG_M_STRING

#define BIG_M_STRING   "unlimited"

Definition at line 32 of file gnunet-ats-solver-eval.c.

Function Documentation

◆ end_now()

static void end_now ( )
static

Do shutdown.

Definition at line 3434 of file gnunet-ats-solver-eval.c.

3435 {
3436  if (NULL != e)
3437  {
3439  e = NULL;
3440  }
3441  if (NULL != sh)
3442  {
3444  sh = NULL;
3445  }
3446 }
static struct Experiment * e
void GNUNET_ATS_solvers_solver_stop(struct SolverHandle *sh)
void GNUNET_ATS_solvers_experimentation_stop(struct Experiment *e)
static struct SolverHandle * sh

References e, GNUNET_ATS_solvers_experimentation_stop(), GNUNET_ATS_solvers_solver_stop(), and sh.

Referenced by done(), GNUNET_ATS_solvers_solver_start(), and run().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ print_generator_type()

static char* print_generator_type ( enum GeneratorType  g)
static

Definition at line 92 of file gnunet-ats-solver-eval.c.

93 {
94  switch (g)
95  {
97  return "CONSTANT";
98 
100  return "LINEAR";
101 
103  return "RANDOM";
104 
106  return "SINUS";
107 
108  default:
109  return "INVALID";
110  break;
111  }
112 }
@ GNUNET_ATS_TEST_TG_RANDOM
@ GNUNET_ATS_TEST_TG_CONSTANT
@ GNUNET_ATS_TEST_TG_SINUS
@ GNUNET_ATS_TEST_TG_LINEAR

References GNUNET_ATS_TEST_TG_CONSTANT, GNUNET_ATS_TEST_TG_LINEAR, GNUNET_ATS_TEST_TG_RANDOM, and GNUNET_ATS_TEST_TG_SINUS.

Referenced by GNUNET_ATS_solver_generate_preferences_start(), and GNUNET_ATS_solver_generate_property_start().

Here is the caller graph for this function:

◆ find_peer_by_id()

static struct TestPeer* find_peer_by_id ( int  id)
static

Definition at line 116 of file gnunet-ats-solver-eval.c.

117 {
118  struct TestPeer *cur;
119 
120  for (cur = peer_head; NULL != cur; cur = cur->next)
121  if (cur->id == id)
122  return cur;
123  return NULL;
124 }
static struct TestPeer * peer_head
struct TestPeer * next
long long unsigned int id

References TestPeer::id, TestPeer::next, and peer_head.

Referenced by enforce_add_address(), enforce_del_address(), enforce_start_preference(), enforce_start_property(), enforce_start_request(), enforce_stop_request(), GNUNET_ATS_solver_generate_preferences_start(), set_feedback_task(), set_pref_task(), and set_prop_task().

Here is the caller graph for this function:

◆ find_peer_by_pid()

static struct TestPeer* find_peer_by_pid ( const struct GNUNET_PeerIdentity pid)
static

Definition at line 128 of file gnunet-ats-solver-eval.c.

129 {
130  struct TestPeer *cur;
131 
132  for (cur = peer_head; NULL != cur; cur = cur->next)
133  if (0 == GNUNET_memcmp (&cur->peer_id, pid))
134  return cur;
135  return NULL;
136 }
static struct GNUNET_PeerIdentity pid
Identity of the peer we transmit to / connect to.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
struct GNUNET_PeerIdentity peer_id

References GNUNET_memcmp, TestPeer::next, peer_head, TestPeer::peer_id, and pid.

Referenced by get_preferences_cb(), and solver_bandwidth_changed_cb().

Here is the caller graph for this function:

◆ find_address_by_id()

static struct TestAddress* find_address_by_id ( struct TestPeer peer,
int  aid 
)
static

Definition at line 140 of file gnunet-ats-solver-eval.c.

141 {
142  struct TestAddress *cur;
143 
144  for (cur = peer->addr_head; NULL != cur; cur = cur->next)
145  if (cur->aid == aid)
146  return cur;
147  return NULL;
148 }
struct TestAddress * next
long long unsigned int aid
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.

References TestAddress::aid, TestAddress::next, and peer.

Referenced by enforce_add_address(), enforce_del_address(), enforce_start_property(), and set_prop_task().

Here is the caller graph for this function:

◆ GNUNET_ATS_solver_logging_now()

void GNUNET_ATS_solver_logging_now ( struct LoggingHandle l)

Logging.

Definition at line 155 of file gnunet-ats-solver-eval.c.

156 {
157  struct LoggingTimeStep *lts;
158  struct TestPeer *cur;
159  struct TestAddress *cur_addr;
160  struct LoggingPeer *log_p;
161  struct LoggingAddress *log_a;
162  int c;
163 
164  lts = GNUNET_new (struct LoggingTimeStep);
167  if (NULL == lts->prev)
169  else
171 
172  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Logging %llu, delta %llu\n",
174 
175 
176  /* Store logging data here */
177  for (cur = peer_head; NULL != cur; cur = cur->next)
178  {
180  "Logging peer id %llu\n", cur->id);
181 
182  log_p = GNUNET_new (struct LoggingPeer);
183  log_p->id = cur->id;
184  log_p->peer_id = cur->peer_id;
185  log_p->is_requested = cur->is_requested;
186  for (c = 0; c < GNUNET_ATS_PreferenceCount; c++)
187  {
188  log_p->pref_abs[c] = cur->pref_abs[c];
189  log_p->pref_norm[c] = cur->pref_norm[c];
191  "\t %s = %.2f %.2f [abs/rel]\n",
193  log_p->pref_abs[c], log_p->pref_norm[c]);
194  }
195  GNUNET_CONTAINER_DLL_insert_tail (lts->head, lts->tail, log_p);
196 
197  for (cur_addr = cur->addr_head; NULL != cur_addr; cur_addr = cur_addr->next)
198  {
200  "Logging peer id %llu address %llu\n",
201  cur->id, cur_addr->aid);
202  log_a = GNUNET_new (struct LoggingAddress);
203  log_a->aid = cur_addr->aid;
204  log_a->active = cur_addr->ats_addr->active;
205  log_a->network = cur_addr->network;
206  log_a->assigned_bw_in = cur_addr->ats_addr->assigned_bw_in;
207  log_a->assigned_bw_out = cur_addr->ats_addr->assigned_bw_out;
208  for (c = 0; c < GNUNET_ATS_PropertyCount; c++)
209  {
210  log_a->prop_abs[c] = cur_addr->prop_abs[c];
211  log_a->prop_norm[c] = cur_addr->prop_norm[c];
213  "\t %s = %.2f %.2f [abs/rel]\n",
214  GNUNET_ATS_print_property_type (c),
215  log_a->prop_abs[c],
216  log_a->prop_norm[c]);
217  }
218  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\t Active = %i\n", log_a->active);
219  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\t BW in = %llu\n",
220  log_a->assigned_bw_in);
221  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "\t BW out = %llu\n",
222  log_a->assigned_bw_out);
223 
225  log_a);
226  }
227  }
228 }
static struct LoggingHandle * l
#define GNUNET_log(kind,...)
const char * GNUNET_ATS_print_preference_type(enum GNUNET_ATS_PreferenceKind type)
Convert a enum GNUNET_ATS_PreferenceType to a string.
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
@ GNUNET_ERROR_TYPE_DEBUG
@ GNUNET_ERROR_TYPE_INFO
#define GNUNET_new(type)
Allocate a struct or union of the given type.
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:263
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:86
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
uint32_t assigned_bw_in
Inbound bandwidth assigned by solver.
int active
Is this the active address for this peer?
uint32_t assigned_bw_out
Outbound bandwidth assigned by solver.
uint64_t abs_value_us
The actual value.
uint64_t rel_value_us
The actual value.
long long unsigned int aid
double prop_abs[GNUNET_ATS_PropertyCount]
double prop_norm[GNUNET_ATS_PropertyCount]
struct LoggingTimeStep * head
struct LoggingTimeStep * tail
struct GNUNET_PeerIdentity peer_id
struct LoggingAddress * addr_tail
struct LoggingAddress * addr_head
double pref_abs[GNUNET_ATS_PREFERENCE_END]
double pref_norm[GNUNET_ATS_PREFERENCE_END]
long long unsigned int id
struct GNUNET_TIME_Absolute timestamp
struct LoggingPeer * head
struct LoggingPeer * tail
struct LoggingTimeStep * prev
struct GNUNET_TIME_Relative delta
double prop_norm[GNUNET_ATS_PropertyCount]
struct ATS_Address * ats_addr
double prop_abs[GNUNET_ATS_PropertyCount]
struct TestAddress * addr_head
double pref_norm[GNUNET_ATS_PreferenceCount]
double pref_abs[GNUNET_ATS_PreferenceCount]

References GNUNET_TIME_Absolute::abs_value_us, LoggingAddress::active, ATS_Address::active, LoggingPeer::addr_head, TestPeer::addr_head, LoggingPeer::addr_tail, LoggingAddress::aid, TestAddress::aid, LoggingAddress::assigned_bw_in, ATS_Address::assigned_bw_in, LoggingAddress::assigned_bw_out, ATS_Address::assigned_bw_out, TestAddress::ats_addr, LoggingTimeStep::delta, GNUNET_ATS_print_preference_type(), GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_new, GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_UNIT_ZERO, LoggingTimeStep::head, LoggingHandle::head, LoggingPeer::id, TestPeer::id, LoggingPeer::is_requested, TestPeer::is_requested, l, LoggingAddress::network, TestAddress::network, TestPeer::next, TestAddress::next, peer_head, LoggingPeer::peer_id, TestPeer::peer_id, LoggingPeer::pref_abs, TestPeer::pref_abs, LoggingPeer::pref_norm, TestPeer::pref_norm, LoggingTimeStep::prev, LoggingAddress::prop_abs, TestAddress::prop_abs, LoggingAddress::prop_norm, TestAddress::prop_norm, GNUNET_TIME_Relative::rel_value_us, LoggingTimeStep::tail, LoggingHandle::tail, and LoggingTimeStep::timestamp.

Referenced by enforce_del_address(), enforce_stop_request(), logging_task(), and solver_bandwidth_changed_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ logging_task()

static void logging_task ( void *  cls)
static

Definition at line 232 of file gnunet-ats-solver-eval.c.

233 {
234  struct LoggingHandle *l = cls;
235 
236  l->logging_task = NULL;
239  &logging_task,
240  l);
241 }
static void logging_task(void *cls)
void GNUNET_ATS_solver_logging_now(struct LoggingHandle *l)
Logging.
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:1269
struct GNUNET_TIME_Relative log_freq
struct GNUNET_SCHEDULER_Task * logging_task

References GNUNET_ATS_solver_logging_now(), GNUNET_SCHEDULER_add_delayed(), l, LoggingHandle::log_freq, and LoggingHandle::logging_task.

Referenced by GNUNET_ATS_solver_logging_start().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_ATS_solver_logging_start()

struct LoggingHandle* GNUNET_ATS_solver_logging_start ( struct GNUNET_TIME_Relative  freq)

Definition at line 245 of file gnunet-ats-solver-eval.c.

246 {
247  struct LoggingHandle *l;
248 
249  l = GNUNET_new (struct LoggingHandle);
250 
251  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Start logging every %s\n",
253  l->log_freq = freq;
255  return l;
256 }
@ GNUNET_NO
Definition: gnunet_common.h:94
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:1296
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:557

References GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_SCHEDULER_add_now(), GNUNET_STRINGS_relative_time_to_string(), l, LoggingHandle::log_freq, logging_task(), and LoggingHandle::logging_task.

Referenced by run().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_ATS_solver_logging_stop()

void GNUNET_ATS_solver_logging_stop ( struct LoggingHandle l)

Definition at line 260 of file gnunet-ats-solver-eval.c.

261 {
262  if (NULL != l->logging_task)
264 
265  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Stop logging\n");
266 
267  l->logging_task = NULL;
268 }
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972

References GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SCHEDULER_cancel(), l, and LoggingHandle::logging_task.

Referenced by done().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ find_logging_file_handle()

static struct LoggingFileHandle* find_logging_file_handle ( struct LoggingFileHandle lf_head,
struct LoggingFileHandle lf_tail,
int  peer_id,
int  address_id 
)
static

Definition at line 272 of file gnunet-ats-solver-eval.c.

275 {
276  struct LoggingFileHandle *res;
277 
278  for (res = lf_head; NULL != res; res = res->next)
279  if ((res->pid == peer_id) && (res->aid == address_id))
280  return res;
281  return NULL;
282 }
static int res
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42

References peer_id, and res.

Referenced by GNUNET_ATS_solver_logging_write_to_disk().

Here is the caller graph for this function:

◆ GNUNET_ATS_solver_logging_write_to_disk()

void GNUNET_ATS_solver_logging_write_to_disk ( struct LoggingHandle l,
int  add_time_stamp,
char *  output_dir 
)

Definition at line 286 of file gnunet-ats-solver-eval.c.

289 {
290  struct LoggingTimeStep *lts;
291  struct LoggingPeer *log_p;
292  struct LoggingAddress *log_a;
293  struct LoggingFileHandle *lf_head;
294  struct LoggingFileHandle *lf_tail;
295  struct LoggingFileHandle *cur;
296  struct LoggingFileHandle *next;
297  char *filename;
298  char *datastring;
299  char *propstring;
300  char *propstring_tmp;
301  char *prefstring;
302  char *prefstring_tmp;
303  int c;
304  int use_dir;
305 
306  use_dir = GNUNET_NO;
307  if (NULL != output_dir)
308  {
310  {
311  fprintf (stderr, "Failed to create directory `%s'\n", output_dir);
312  return;
313  }
314  else
315  {
316  fprintf (stderr, "Created directory `%s'\n", output_dir);
317  use_dir = GNUNET_YES;
318  }
319  }
320 
321  lf_head = NULL;
322  lf_tail = NULL;
323 
324  for (lts = l->head; NULL != lts; lts = lts->next)
325  {
326  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Writing log step %llu\n",
327  (long long unsigned int) lts->timestamp.abs_value_us);
328 
329  for (log_p = lts->head; NULL != log_p; log_p = log_p->next)
330  {
331  for (log_a = log_p->addr_head; NULL != log_a; log_a = log_a->next)
332  {
333  cur = find_logging_file_handle (lf_head, lf_tail, log_p->id,
334  log_a->aid);
335  if (NULL == cur)
336  {
337  cur = GNUNET_new (struct LoggingFileHandle);
338  cur->aid = log_a->aid;
339  cur->pid = log_p->id;
340 
341  if (GNUNET_YES == add_time_stamp)
342  GNUNET_asprintf (&filename, "%s%s%s_%s_p%u_a%u_%llu.log",
343  (GNUNET_YES == use_dir) ? output_dir : "",
344  (GNUNET_YES == use_dir) ? DIR_SEPARATOR_STR : "",
345  e->log_prefix,
346  opt_solver,
347  cur->pid,
348  cur->aid,
350  else
351  GNUNET_asprintf (&filename, "%s%s%s_%s_p%u_a%u.log",
352  (GNUNET_YES == use_dir) ? output_dir : "",
353  (GNUNET_YES == use_dir) ? DIR_SEPARATOR_STR : "",
354  e->log_prefix,
355  opt_solver,
356  cur->pid,
357  cur->aid);
358 
359  fprintf (stderr,
360  "Add writing log data for peer %llu address %llu to file `%s'\n",
361  cur->pid, cur->aid, filename);
362 
363 
372  if (NULL == cur->f_hd)
373  {
374  fprintf (stderr, "Cannot open `%s' to write log data!\n", filename);
376  GNUNET_free (cur);
377  goto cleanup;
378  }
380  GNUNET_CONTAINER_DLL_insert (lf_head, lf_tail, cur);
381 
382  GNUNET_asprintf (&datastring,
383  "#time delta;log duration;peer_requested;addr net; addr_active; bw in; bw out; " \
384  "UTILIZATION_UP [abs/rel]; UTILIZATION_UP; UTILIZATION_DOWN; UTILIZATION_DOWN; " \
385  "UTILIZATION_PAYLOAD_UP; UTILIZATION_PAYLOAD_UP; UTILIZATION_PAYLOAD_DOWN; UTILIZATION_PAYLOAD_DOWN;" \
386  "DELAY; DELAY; " \
387  "DISTANCE ;DISTANCE ; COST_WAN; COST_WAN; COST_LAN; COST_LAN; " \
388  "COST_WLAN; COST_WLAN;COST_BT; COST_BT; PREF BW abs; PREF BW rel; PREF LATENCY abs; PREF LATENCY rel;\n");
389  GNUNET_DISK_file_write (cur->f_hd, datastring, strlen (datastring));
390  GNUNET_free (datastring);
391  }
392 
393  prefstring = GNUNET_strdup ("");
394  for (c = 1; c < GNUNET_ATS_PreferenceCount; c++)
395  {
396  /*
397  fprintf(stderr,"\t %s = %.2f %.2f [abs/rel]\n",
398  GNUNET_ATS_print_preference_type(c),
399  log_p->pref_abs[c], log_p->pref_norm[c]);
400  */GNUNET_asprintf (&prefstring_tmp, "%s;%.3f;%.3f",
401  prefstring, log_p->pref_abs[c], log_p->pref_norm[c]);
402 
403 
404  GNUNET_free (prefstring);
405  prefstring = GNUNET_strdup (prefstring_tmp);
406  GNUNET_free (prefstring_tmp);
407  }
408 
409 
410  propstring = GNUNET_strdup ("");
411  for (c = 1; c < GNUNET_ATS_PropertyCount; c++)
412  {
413  if (GNUNET_ATS_NETWORK_TYPE == c)
414  continue;
415  /*
416  fprintf(stderr, "\t %s = %.2f %.2f [abs/rel]\n",
417  GNUNET_ATS_print_property_type(c),
418  log_a->prop_abs[c], log_a->prop_norm[c]);*/
419  GNUNET_asprintf (&propstring_tmp, "%s%.3f;%.3f;",
420  propstring,
421  log_a->prop_abs[c],
422  log_a->prop_norm[c]);
423  GNUNET_free (propstring);
424  propstring = GNUNET_strdup (propstring_tmp);
425  GNUNET_free (propstring_tmp);
426  }
427  GNUNET_asprintf (&datastring, "%llu;%llu;%u;%u;%i;%u;%u;%s;%s\n",
429  l->head->timestamp,
430  lts->timestamp).
431  rel_value_us / 1000, lts->delta,
432  log_p->is_requested, log_a->network, log_a->active,
433  log_a->assigned_bw_in, log_a->assigned_bw_out,
434  propstring,
435  prefstring);
436 
437  GNUNET_DISK_file_write (cur->f_hd, datastring, strlen (datastring));
438  GNUNET_free (datastring);
439  GNUNET_free (prefstring);
440  GNUNET_free (propstring);
441  }
442  }
443  }
444 
445 cleanup:
446  next = lf_head;
447  for (cur = next; NULL != cur; cur = next)
448  {
449  next = cur->next;
450  GNUNET_CONTAINER_DLL_remove (lf_head, lf_tail, cur);
451  if (NULL != cur->f_hd)
453  GNUNET_free (cur);
454  }
455 }
static struct LoggingFileHandle * find_logging_file_handle(struct LoggingFileHandle *lf_head, struct LoggingFileHandle *lf_tail, int peer_id, int address_id)
static char * opt_solver
static void cleanup(void *cls)
Function scheduled as very last function, cleans up after us.
static char * filename
@ GNUNET_OK
Definition: gnunet_common.h:95
@ GNUNET_YES
Definition: gnunet_common.h:97
struct GNUNET_DISK_FileHandle * GNUNET_DISK_file_open(const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
Open a file.
Definition: disk.c:1235
ssize_t GNUNET_DISK_file_write(const struct GNUNET_DISK_FileHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: disk.c:686
enum GNUNET_GenericReturnValue GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1306
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_create_for_file(const char *filename)
Create the directory structure for storing a file.
Definition: disk.c:582
@ GNUNET_DISK_OPEN_TRUNCATE
Truncate file if it exists.
@ GNUNET_DISK_OPEN_CREATE
Create file if it doesn't exist.
@ GNUNET_DISK_OPEN_READWRITE
Open the file for both reading and writing.
@ GNUNET_DISK_PERM_USER_READ
Owner can read.
@ GNUNET_DISK_PERM_GROUP_READ
Group can read.
@ GNUNET_DISK_PERM_USER_WRITE
Owner can write.
@ GNUNET_DISK_PERM_OTHER_READ
Everybody can read.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_free(ptr)
Wrapper around free.
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:248
#define DIR_SEPARATOR_STR
Definition: platform.h:165
struct LoggingAddress * next
struct GNUNET_DISK_FileHandle * f_hd
long long unsigned int pid
long long unsigned int aid
struct LoggingFileHandle * next
struct LoggingPeer * next
struct LoggingTimeStep * next

References GNUNET_TIME_Absolute::abs_value_us, LoggingAddress::active, LoggingPeer::addr_head, LoggingFileHandle::aid, LoggingAddress::aid, LoggingAddress::assigned_bw_in, LoggingAddress::assigned_bw_out, cleanup(), LoggingTimeStep::delta, DIR_SEPARATOR_STR, e, LoggingFileHandle::f_hd, filename, find_logging_file_handle(), GNUNET_asprintf(), GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_remove, GNUNET_DISK_directory_create_for_file(), GNUNET_DISK_file_close(), GNUNET_DISK_file_open(), GNUNET_DISK_file_write(), GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_OPEN_READWRITE, GNUNET_DISK_OPEN_TRUNCATE, GNUNET_DISK_PERM_GROUP_READ, GNUNET_DISK_PERM_OTHER_READ, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_strdup, GNUNET_TIME_absolute_get_difference(), GNUNET_YES, LoggingTimeStep::head, LoggingHandle::head, LoggingPeer::id, LoggingPeer::is_requested, l, Experiment::log_prefix, LoggingAddress::network, LoggingFileHandle::next, LoggingTimeStep::next, LoggingPeer::next, LoggingAddress::next, opt_solver, LoggingFileHandle::pid, LoggingPeer::pref_abs, LoggingPeer::pref_norm, LoggingAddress::prop_abs, LoggingAddress::prop_norm, and LoggingTimeStep::timestamp.

Referenced by done().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_ATS_solver_logging_eval()

void GNUNET_ATS_solver_logging_eval ( struct LoggingHandle l)

Definition at line 459 of file gnunet-ats-solver-eval.c.

460 {
461  struct LoggingTimeStep *lts;
462  struct LoggingPeer *log_p;
463  struct LoggingAddress *log_a;
464  int c;
465 
466  for (lts = l->head; NULL != lts; lts = lts->next)
467  {
468  fprintf (stderr, "Log step %llu %llu: \n",
469  (long long unsigned int) lts->timestamp.abs_value_us,
470  (long long unsigned int) lts->delta.rel_value_us);
471 
472  for (log_p = lts->head; NULL != log_p; log_p = log_p->next)
473  {
474  fprintf (stderr, "\tLogging peer pid %llu\n", log_p->id);
475  for (c = 1; c < GNUNET_ATS_PreferenceCount; c++)
476  {
477  fprintf (stderr, "\t %s = %.2f %.2f [abs/rel]\n",
479  log_p->pref_abs[c], log_p->pref_norm[c]);
480  }
481 
482  for (log_a = log_p->addr_head; NULL != log_a; log_a = log_a->next)
483  {
484  fprintf (stderr, "\tPeer pid %llu address %llu: %u %u %u\n",
485  log_p->id, log_a->aid, log_a->active,
486  log_a->assigned_bw_in,
487  log_a->assigned_bw_out);
488 
489  for (c = 1; c < GNUNET_ATS_PropertyCount; c++)
490  {
491  if (GNUNET_ATS_NETWORK_TYPE == c)
492  continue;
493  fprintf (stderr, "\t %s = %.2f %.2f [abs/rel]\n",
494  GNUNET_ATS_print_property_type (c),
495  log_a->prop_abs[c], log_a->prop_norm[c]);
496  }
497  }
498  }
499  }
500 }

References GNUNET_TIME_Absolute::abs_value_us, LoggingAddress::active, LoggingPeer::addr_head, LoggingAddress::aid, LoggingAddress::assigned_bw_in, LoggingAddress::assigned_bw_out, LoggingTimeStep::delta, GNUNET_ATS_print_preference_type(), LoggingTimeStep::head, LoggingHandle::head, LoggingPeer::id, l, LoggingTimeStep::next, LoggingPeer::next, LoggingAddress::next, LoggingPeer::pref_abs, LoggingPeer::pref_norm, LoggingAddress::prop_abs, LoggingAddress::prop_norm, GNUNET_TIME_Relative::rel_value_us, and LoggingTimeStep::timestamp.

Referenced by done().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_ATS_solver_logging_free()

void GNUNET_ATS_solver_logging_free ( struct LoggingHandle l)

Definition at line 504 of file gnunet-ats-solver-eval.c.

505 {
506  struct LoggingTimeStep *lts_cur;
507  struct LoggingTimeStep *lts_next;
508  struct LoggingPeer *log_p_cur;
509  struct LoggingPeer *log_p_next;
510  struct LoggingAddress *log_a_cur;
511  struct LoggingAddress *log_a_next;
512 
513  if (NULL != l->logging_task)
515  l->logging_task = NULL;
516 
517  lts_next = l->head;
518  while (NULL != (lts_cur = lts_next))
519  {
520  lts_next = lts_cur->next;
521 
522  log_p_next = lts_cur->head;
523  while (NULL != (log_p_cur = log_p_next))
524  {
525  log_p_next = log_p_cur->next;
526 
527  log_a_next = log_p_cur->addr_head;
528  while (NULL != (log_a_cur = log_a_next))
529  {
530  log_a_next = log_a_cur->next;
531 
532  GNUNET_CONTAINER_DLL_remove (log_p_cur->addr_head, log_p_cur->addr_tail,
533  log_a_cur);
534  GNUNET_free (log_a_cur);
535  }
536 
537  GNUNET_CONTAINER_DLL_remove (lts_cur->head, lts_cur->tail, log_p_cur);
538  GNUNET_free (log_p_cur);
539  }
540 
541  GNUNET_CONTAINER_DLL_remove (l->head, l->tail, lts_cur);
542  GNUNET_free (lts_cur);
543  }
544 
545  GNUNET_free (l);
546 }

References LoggingPeer::addr_head, LoggingPeer::addr_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_SCHEDULER_cancel(), LoggingTimeStep::head, LoggingHandle::head, l, LoggingHandle::logging_task, LoggingTimeStep::next, LoggingPeer::next, LoggingAddress::next, LoggingTimeStep::tail, and LoggingHandle::tail.

Referenced by done().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ get_property()

static double get_property ( struct PropertyGenerator pg)
static

Definition at line 557 of file gnunet-ats-solver-eval.c.

558 {
559  struct GNUNET_TIME_Relative time_delta;
560  double delta_value;
561  double pref_value;
562 
563  /* Calculate the current preference value */
564  switch (pg->type)
565  {
567  pref_value = pg->base_value;
568  break;
569 
572  /* Calculate point of time in the current period */
573  time_delta.rel_value_us = time_delta.rel_value_us
575  delta_value = ((double) time_delta.rel_value_us
577  - pg->base_value);
578  if ((pg->max_value < pg->base_value) &&
579  ((pg->max_value - pg->base_value) > pg->base_value))
580  {
581  /* This will cause an underflow */
582  GNUNET_break (0);
583  }
584  pref_value = pg->base_value + delta_value;
585  break;
586 
589  10000 * (pg->max_value
590  - pg->base_value))
591  / 10000;
592  pref_value = pg->base_value + delta_value;
593  break;
594 
597  /* Calculate point of time in the current period */
598  time_delta.rel_value_us = time_delta.rel_value_us
600  if ((pg->max_value - pg->base_value) > pg->base_value)
601  {
602  /* This will cause an underflow for second half of sinus period,
603  * will be detected in general when experiments are loaded */
604  GNUNET_break (0);
605  }
606  delta_value = (pg->max_value - pg->base_value)
607  * sin ((2 * M_PI)
608  / ((double) pg->duration_period.rel_value_us)
609  * time_delta.rel_value_us);
610  pref_value = pg->base_value + delta_value;
611  break;
612 
613  default:
614  pref_value = 0.0;
615  break;
616  }
617  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Current property value is %f\n",
618  pref_value);
619  return pref_value;
620 }
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
@ GNUNET_CRYPTO_QUALITY_WEAK
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
Time for relative time used by GNUnet, in microseconds.
struct GNUNET_TIME_Relative duration_period
struct GNUNET_TIME_Absolute time_start
enum GeneratorType type

References PropertyGenerator::base_value, PropertyGenerator::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_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_TIME_absolute_get_duration(), PropertyGenerator::max_value, GNUNET_TIME_Relative::rel_value_us, PropertyGenerator::time_start, and PropertyGenerator::type.

Referenced by set_prop_task().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ set_prop_task()

static void set_prop_task ( void *  cls)
static

Definition at line 624 of file gnunet-ats-solver-eval.c.

625 {
626  struct PropertyGenerator *pg = cls;
627  struct TestPeer *p;
628  struct TestAddress *a;
629  double prop_value;
630  struct GNUNET_ATS_Information atsi;
631 
632  pg->set_task = NULL;
633 
635  &pg->test_peer
636  ->peer_id,
637  pg->
638  test_address->
639  ats_addr))
640  {
641  GNUNET_break (0);
643  "Setting property generation for unknown address [%u:%u]\n",
644  pg->peer, pg->address_id);
645  return;
646  }
647  if (NULL == (p = find_peer_by_id (pg->peer)))
648  {
649  GNUNET_break (0);
651  "Setting property generation for unknown peer %u\n",
652  pg->peer);
653  return;
654  }
655  if (NULL == (a = find_address_by_id (p, pg->address_id)))
656  {
657  GNUNET_break (0);
659  "Setting property generation for unknown peer %u\n",
660  pg->peer);
661  return;
662  }
663 
664  prop_value = get_property (pg);
665  a->prop_abs[pg->ats_property] = prop_value;
666 
668  "Setting property for peer [%u] address [%u] for %s to %f\n",
669  pg->peer, pg->address_id,
670  GNUNET_ATS_print_property_type (pg->ats_property), prop_value);
671 
672  atsi.type = htonl (pg->ats_property);
673  atsi.value = htonl ((uint32_t) prop_value);
674 
675  /* set performance here! */
676  sh->sf->s_bulk_start (sh->sf->cls);
678  {
679  a->prop_abs[pg->ats_property] = prop_value;
680  a->prop_norm[pg->ats_property] = prop_value;
682  pg->ats_property, prop_value,
683  prop_value);
684  }
685  else
687  sh->sf->s_bulk_stop (sh->sf->cls);
688 
690  &set_prop_task, pg);
691 }
static struct TestPeer * find_peer_by_id(int id)
static struct TestAddress * find_address_by_id(struct TestPeer *peer, int aid)
static int opt_disable_normalization
cmd option -d: disable normalization
static void set_prop_task(void *cls)
static double get_property(struct PropertyGenerator *pg)
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
void GAS_normalization_update_property(struct ATS_Address *address)
Update and normalize atsi performance information.
static int test_address(void *cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_TIME_Absolute expiration)
Test for checking whether HELLO message is empty.
int GNUNET_CONTAINER_multipeermap_contains_value(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Check if the map contains the given value under the given key.
@ GNUNET_ERROR_TYPE_ERROR
GAS_solver_address_property_changed s_address_update_property
Update the properties of an address in the solver.
void * cls
Closure to pass to all solver functions in this struct.
GAS_solver_bulk_start s_bulk_start
Start a bulk operation.
GAS_solver_bulk_stop s_bulk_stop
Bulk operation done.
struct TestPeer * test_peer
struct GNUNET_TIME_Relative frequency
struct GNUNET_SCHEDULER_Task * set_task
long long unsigned int address_id
long long unsigned int peer
struct TestAddress * test_address
struct GNUNET_ATS_SolverFunctions * sf
Solver handle.
struct GNUNET_CONTAINER_MultiPeerMap * addresses
Address hashmap.

References PropertyGenerator::address_id, SolverHandle::addresses, TestAddress::ats_addr, PropertyGenerator::ats_property, GNUNET_ATS_SolverFunctions::cls, find_address_by_id(), find_peer_by_id(), PropertyGenerator::frequency, GAS_normalization_update_property(), get_property(), GNUNET_break, GNUNET_CONTAINER_multipeermap_contains_value(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_YES, opt_disable_normalization, p, PropertyGenerator::peer, TestPeer::peer_id, TestAddress::prop_abs, TestAddress::prop_norm, GNUNET_ATS_SolverFunctions::s_address_update_property, GNUNET_ATS_SolverFunctions::s_bulk_start, GNUNET_ATS_SolverFunctions::s_bulk_stop, PropertyGenerator::set_task, SolverHandle::sf, sh, PropertyGenerator::test_address, test_address(), and PropertyGenerator::test_peer.

Referenced by GNUNET_ATS_solver_generate_property_start().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ find_prop_gen()

static struct PropertyGenerator* find_prop_gen ( unsigned int  peer,
unsigned int  address,
uint32_t  ats_property 
)
static

Set ats_property to 0 to find all pgs.

Definition at line 698 of file gnunet-ats-solver-eval.c.

700 {
701  struct PropertyGenerator *cur;
702 
703  for (cur = prop_gen_head; NULL != cur; cur = cur->next)
704  if ((cur->peer == peer) && (cur->address_id == address))
705  {
706  if ((cur->ats_property == ats_property) || (0 == ats_property))
707  return cur;
708  }
709  return NULL;
710 }
static struct PropertyGenerator * prop_gen_head
Property Generators.
static char * address
GNS address for this phone.
struct PropertyGenerator * next

References address, PropertyGenerator::address_id, PropertyGenerator::ats_property, PropertyGenerator::next, PropertyGenerator::peer, peer, and prop_gen_head.

Referenced by enforce_del_address(), enforce_start_property(), and enforce_stop_property().

Here is the caller graph for this function:

◆ GNUNET_ATS_solver_generate_property_stop()

void GNUNET_ATS_solver_generate_property_stop ( struct PropertyGenerator pg)

Definition at line 714 of file gnunet-ats-solver-eval.c.

715 {
717 
718  if (NULL != pg->set_task)
719  {
721  pg->set_task = NULL;
722  }
724  "Removing old up preference generator peer [%u] address [%u] `%s'\n",
725  pg->peer, pg->address_id,
726  GNUNET_ATS_print_property_type (pg->ats_property));
727 
728  GNUNET_free (pg);
729 }
static struct PropertyGenerator * prop_gen_tail

References PropertyGenerator::address_id, PropertyGenerator::ats_property, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_SCHEDULER_cancel(), PropertyGenerator::peer, prop_gen_head, prop_gen_tail, and PropertyGenerator::set_task.

Referenced by enforce_del_address(), enforce_start_property(), enforce_stop_property(), and GNUNET_ATS_solver_generate_property_stop_all().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_ATS_solver_generate_property_start()

struct PropertyGenerator* GNUNET_ATS_solver_generate_property_start ( unsigned int  peer,
unsigned int  address_id,
struct TestPeer test_peer,
struct TestAddress test_address,
enum GeneratorType  type,
long int  base_value,
long int  value_rate,
struct GNUNET_TIME_Relative  period,
struct GNUNET_TIME_Relative  frequency,
uint32_t  ats_property 
)

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

Parameters
peersource
address_idpartner
test_peerthe peer
test_addressthe address
typetype of generator
base_valuebase value
value_ratemaximum value
periodduration of a period of generation (~ 1/frequency)
frequencyhow long to generate property
ats_propertyATS property to generate
Returns
the property generator

Definition at line 749 of file gnunet-ats-solver-eval.c.

760 {
761  struct PropertyGenerator *pg;
762 
763  pg = GNUNET_new (struct PropertyGenerator);
765  pg->type = type;
766  pg->peer = peer;
768  pg->test_peer = test_peer;
769  pg->address_id = address_id;
771  pg->base_value = base_value;
772  pg->max_value = value_rate;
773  pg->duration_period = period;
774  pg->frequency = frequency;
776 
777  switch (type)
778  {
781  "Setting up %s property generator peer [%u] address [%u] `%s'" \
782  "max %u Bips\n",
784  GNUNET_ATS_print_property_type (ats_property),
785  base_value);
786  break;
787 
790  "Setting up %s property generator peer [%u] address [%u] `%s' " \
791  "min %u Bips max %u Bips\n",
793  GNUNET_ATS_print_property_type (ats_property),
794  base_value, value_rate);
795  break;
796 
799  "Setting up %s property generator peer [%u] address [%u] `%s' " \
800  "baserate %u Bips, amplitude %u Bps\n",
802  GNUNET_ATS_print_property_type (ats_property),
803  base_value, value_rate);
804  break;
805 
808  "Setting up %s property generator peer [%u] address [%u] `%s' " \
809  "min %u Bips max %u Bps\n",
811  GNUNET_ATS_print_property_type (ats_property),
812  base_value, value_rate);
813  break;
814 
815  default:
816  break;
817  }
818 
820  return pg;
821 }
static char * print_generator_type(enum GeneratorType g)
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model

References PropertyGenerator::address_id, PropertyGenerator::ats_property, PropertyGenerator::base_value, PropertyGenerator::duration_period, PropertyGenerator::frequency, GNUNET_ATS_TEST_TG_CONSTANT, GNUNET_ATS_TEST_TG_LINEAR, GNUNET_ATS_TEST_TG_RANDOM, GNUNET_ATS_TEST_TG_SINUS, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_new, GNUNET_SCHEDULER_add_now(), GNUNET_TIME_absolute_get(), PropertyGenerator::max_value, PropertyGenerator::peer, peer, print_generator_type(), prop_gen_head, prop_gen_tail, set_prop_task(), PropertyGenerator::set_task, PropertyGenerator::test_address, test_address(), PropertyGenerator::test_peer, PropertyGenerator::time_start, PropertyGenerator::type, and type.

Referenced by enforce_start_property().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_ATS_solver_generate_property_stop_all()

void GNUNET_ATS_solver_generate_property_stop_all ( )

Stop all preferences generators.

Definition at line 828 of file gnunet-ats-solver-eval.c.

829 {
830  struct PropertyGenerator *cur;
831  struct PropertyGenerator *next;
832 
834  for (cur = next; NULL != cur; cur = next)
835  {
836  next = cur->next;
838  }
839 }
void GNUNET_ATS_solver_generate_property_stop(struct PropertyGenerator *pg)

References GNUNET_ATS_solver_generate_property_stop(), PropertyGenerator::next, and prop_gen_head.

Referenced by done().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ get_preference()

static double get_preference ( struct PreferenceGenerator pg)
static

Definition at line 850 of file gnunet-ats-solver-eval.c.

851 {
852  struct GNUNET_TIME_Relative time_delta;
853  double delta_value;
854  double pref_value;
855 
856  /* Calculate the current preference value */
857  switch (pg->type)
858  {
860  pref_value = pg->base_value;
861  break;
862 
865  /* Calculate point of time in the current period */
866  time_delta.rel_value_us = time_delta.rel_value_us
868  delta_value = ((double) time_delta.rel_value_us
870  - pg->base_value);
871  if ((pg->max_value < pg->base_value) &&
872  ((pg->max_value - pg->base_value) > pg->base_value))
873  {
874  /* This will cause an underflow */
875  GNUNET_break (0);
876  }
877  pref_value = pg->base_value + delta_value;
878  break;
879 
882  10000 * (pg->max_value
883  - pg->base_value))
884  / 10000;
885  pref_value = pg->base_value + delta_value;
886  break;
887 
890  /* Calculate point of time in the current period */
891  time_delta.rel_value_us = time_delta.rel_value_us
893  if ((pg->max_value - pg->base_value) > pg->base_value)
894  {
895  /* This will cause an underflow for second half of sinus period,
896  * will be detected in general when experiments are loaded */
897  GNUNET_break (0);
898  }
899  delta_value = (pg->max_value - pg->base_value)
900  * sin ((2 * M_PI)
901  / ((double) pg->duration_period.rel_value_us)
902  * time_delta.rel_value_us);
903  pref_value = pg->base_value + delta_value;
904  break;
905 
906  default:
907  pref_value = 0.0;
908  break;
909  }
910  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Current preference value is %f\n",
911  pref_value);
912  return pref_value;
913 }
struct GNUNET_TIME_Relative duration_period
struct GNUNET_TIME_Absolute time_start

References PreferenceGenerator::base_value, PreferenceGenerator::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_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_TIME_absolute_get_duration(), PreferenceGenerator::max_value, GNUNET_TIME_Relative::rel_value_us, PreferenceGenerator::time_start, and PreferenceGenerator::type.

Referenced by set_feedback_task(), and set_pref_task().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ set_feedback_task()

static void set_feedback_task ( void *  cls)
static

Definition at line 917 of file gnunet-ats-solver-eval.c.

918 {
919  struct PreferenceGenerator *pg = cls;
920  struct TestPeer *p;
921  double feedback;
922  uint32_t bw_acc_out;
923  uint32_t bw_acc_in;
924  uint32_t delay_acc_in;
925  struct GNUNET_TIME_Relative dur;
926  double p_new;
927 
928  pg->feedback_task = NULL;
929 
930  if (NULL == (p = find_peer_by_id (pg->peer)))
931  {
932  GNUNET_break (0);
934  "Setting feedback for unknown peer %u\n", pg->peer);
935  return;
936  }
937 
938  switch (pg->kind)
939  {
942  bw_acc_in = dur.rel_value_us * pg->last_assigned_bw_in
943  + pg->feedback_bw_in_acc;
944  pg->feedback_bw_in_acc = 0;
945 
946  bw_acc_out = dur.rel_value_us * pg->last_assigned_bw_out
947  + pg->feedback_bw_out_acc;
948  p_new = get_preference (pg);
949  feedback = (p_new / pg->pref_bw_old) * (bw_acc_in + bw_acc_out)
952 
953  break;
954 
957  delay_acc_in = dur.rel_value_us * pg->last_delay_value
958  + pg->feedback_delay_acc;
959  pg->feedback_delay_acc = 0;
960 
961  p_new = get_preference (pg);
962  feedback = (p_new / pg->pref_latency_old) * (delay_acc_in)
965 
966  break;
967 
968  default:
969  GNUNET_break (0);
970  feedback = 0.0;
971  break;
972  }
974  "Giving feedback for peer [%u] for client %p pref %s of %.3f\n",
975  pg->peer, NULL + (pg->client_id),
977  feedback);
978 
979  sh->sf->s_feedback (sh->sf->cls, NULL + (pg->client_id), &p->peer_id,
980  pg->feedback_frequency, pg->kind, feedback);
982 
983 
984  pg->feedback_bw_out_acc = 0;
985  pg->feedback_bw_in_acc = 0;
987 
988  pg->feedback_delay_acc = 0;
990 
991 
993  &set_feedback_task, pg);
994 }
static double get_preference(struct PreferenceGenerator *pg)
static void set_feedback_task(void *cls)
@ GNUNET_ATS_PREFERENCE_BANDWIDTH
Change the peer's bandwidth value (value per byte of bandwidth in the goal function) to the given amo...
@ GNUNET_ATS_PREFERENCE_LATENCY
Change the peer's latency value to the given amount.
GAS_solver_address_feedback_preference s_feedback
Give feedback about the current assignment.
struct GNUNET_SCHEDULER_Task * feedback_task
struct GNUNET_TIME_Absolute feedback_last_delay_update
long long unsigned int peer
enum GNUNET_ATS_PreferenceKind kind
struct GNUNET_TIME_Absolute feedback_last
struct GNUNET_TIME_Relative feedback_frequency
struct GNUNET_TIME_Absolute feedback_last_bw_update

References PreferenceGenerator::client_id, GNUNET_ATS_SolverFunctions::cls, PreferenceGenerator::feedback_bw_in_acc, PreferenceGenerator::feedback_bw_out_acc, PreferenceGenerator::feedback_delay_acc, PreferenceGenerator::feedback_frequency, PreferenceGenerator::feedback_last, PreferenceGenerator::feedback_last_bw_update, PreferenceGenerator::feedback_last_delay_update, PreferenceGenerator::feedback_task, find_peer_by_id(), get_preference(), GNUNET_ATS_PREFERENCE_BANDWIDTH, GNUNET_ATS_PREFERENCE_LATENCY, GNUNET_ATS_print_preference_type(), GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_duration(), PreferenceGenerator::kind, PreferenceGenerator::last_assigned_bw_in, PreferenceGenerator::last_assigned_bw_out, PreferenceGenerator::last_delay_value, p, PreferenceGenerator::peer, PreferenceGenerator::pref_bw_old, PreferenceGenerator::pref_latency_old, GNUNET_TIME_Relative::rel_value_us, GNUNET_ATS_SolverFunctions::s_feedback, SolverHandle::sf, and sh.

Referenced by GNUNET_ATS_solver_generate_preferences_start().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ set_pref_task()

static void set_pref_task ( void *  cls)
static

Definition at line 998 of file gnunet-ats-solver-eval.c.

999 {
1000  struct PreferenceGenerator *pg = cls;
1001  struct TestPeer *p;
1002  double pref_value;
1003 
1004  pg->set_task = NULL;
1005 
1006  if (NULL == (p = find_peer_by_id (pg->peer)))
1007  {
1008  GNUNET_break (0);
1010  "Setting preference for unknown peer %u\n", pg->peer);
1011  return;
1012  }
1013 
1014  pref_value = get_preference (pg);
1015  switch (pg->kind)
1016  {
1018  pg->pref_bw_old = pref_value;
1019  break;
1020 
1022  pg->pref_latency_old = pref_value;
1023  break;
1024 
1025  default:
1026  break;
1027  }
1028 
1029  p->pref_abs[pg->kind] = pref_value;
1030 
1032  "Setting preference for peer [%u] for client %p pref %s to %f\n",
1033  pg->peer, NULL + (pg->client_id),
1034  GNUNET_ATS_print_preference_type (pg->kind), pref_value);
1035 
1037  {
1038  p->pref_abs[pg->kind] = pref_value;
1039  p->pref_norm[pg->kind] = pref_value;
1040  sh->sf->s_pref (sh->sf->cls, &p->peer_id, pg->kind, pref_value);
1041  }
1042  else
1043  update_preference (NULL + (pg->client_id),
1044  &p->peer_id,
1045  pg->kind,
1046  pref_value);
1047 
1049  &set_pref_task,
1050  pg);
1051 }
static void set_pref_task(void *cls)
static void update_preference(struct GNUNET_SERVICE_Client *client, const struct GNUNET_PeerIdentity *peer, enum GNUNET_ATS_PreferenceKind kind, float score_abs)
Update the absolute preference and calculate the new relative preference value.
GAS_solver_address_change_preference s_pref
Change relative preference for quality in solver.
struct GNUNET_TIME_Relative frequency
struct GNUNET_SCHEDULER_Task * set_task

References PreferenceGenerator::client_id, GNUNET_ATS_SolverFunctions::cls, find_peer_by_id(), PreferenceGenerator::frequency, get_preference(), GNUNET_ATS_PREFERENCE_BANDWIDTH, GNUNET_ATS_PREFERENCE_LATENCY, GNUNET_ATS_print_preference_type(), GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_YES, PreferenceGenerator::kind, opt_disable_normalization, p, PreferenceGenerator::peer, PreferenceGenerator::pref_bw_old, PreferenceGenerator::pref_latency_old, GNUNET_ATS_SolverFunctions::s_pref, PreferenceGenerator::set_task, SolverHandle::sf, sh, and update_preference().

Referenced by GNUNET_ATS_solver_generate_preferences_start().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ find_pref_gen()

static struct PreferenceGenerator* find_pref_gen ( unsigned int  peer,
enum GNUNET_ATS_PreferenceKind  kind 
)
static

Definition at line 1055 of file gnunet-ats-solver-eval.c.

1056 {
1057  struct PreferenceGenerator *cur;
1058 
1059  for (cur = pref_gen_head; NULL != cur; cur = cur->next)
1060  if (cur->peer == peer)
1061  {
1062  if ((cur->kind == kind) || (GNUNET_ATS_PREFERENCE_END == kind))
1063  return cur;
1064  }
1065  return NULL;
1066 }
static struct PreferenceGenerator * pref_gen_head
Preference Generators.
@ GNUNET_ATS_PREFERENCE_END
End of preference list.
struct PreferenceGenerator * next

References GNUNET_ATS_PREFERENCE_END, PreferenceGenerator::kind, PreferenceGenerator::next, PreferenceGenerator::peer, peer, and pref_gen_head.

Referenced by enforce_start_preference(), and enforce_stop_preference().

Here is the caller graph for this function:

◆ GNUNET_ATS_solver_generate_preferences_stop()

void GNUNET_ATS_solver_generate_preferences_stop ( struct PreferenceGenerator pg)

Definition at line 1070 of file gnunet-ats-solver-eval.c.

1071 {
1073 
1074  if (NULL != pg->feedback_task)
1075  {
1077  pg->feedback_task = NULL;
1078  }
1079 
1080  if (NULL != pg->set_task)
1081  {
1083  pg->set_task = NULL;
1084  }
1086  "Removing old up preference generator peer [%u] `%s'\n",
1088 
1089  GNUNET_free (pg);
1090 }
static struct PreferenceGenerator * pref_gen_tail

References PreferenceGenerator::feedback_task, GNUNET_ATS_print_preference_type(), GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_SCHEDULER_cancel(), PreferenceGenerator::kind, PreferenceGenerator::peer, pref_gen_head, pref_gen_tail, and PreferenceGenerator::set_task.

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

Here is the call graph for this function:
Here is the caller graph for this function:

◆ find_active_address()

static struct TestAddress* find_active_address ( struct TestPeer p)
static

Definition at line 1094 of file gnunet-ats-solver-eval.c.

1095 {
1096  struct TestAddress *cur;
1097 
1098  for (cur = p->addr_head; NULL != cur; cur = cur->next)
1099  if (GNUNET_YES == cur->ats_addr->active)
1100  return cur;
1101  return NULL;
1102 }

References ATS_Address::active, TestAddress::ats_addr, GNUNET_YES, TestAddress::next, and p.

Referenced by GNUNET_ATS_solver_generate_preferences_start().

Here is the caller graph for this function:

◆ GNUNET_ATS_solver_generate_preferences_start()

struct PreferenceGenerator* GNUNET_ATS_solver_generate_preferences_start ( unsigned int  peer,
unsigned int  address_id,
unsigned int  client_id,
enum GeneratorType  type,
long int  base_value,
long int  value_rate,
struct GNUNET_TIME_Relative  period,
struct GNUNET_TIME_Relative  frequency,
enum GNUNET_ATS_PreferenceKind  kind,
struct GNUNET_TIME_Relative  feedback_frequency 
)

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

Parameters
peersource
address_idpartner
client_idthe client
typetype of generator
base_valuebase value
value_ratemaximum value
periodduration of a period of generation (~ 1/frequency)
frequencyhow long to generate property
kindATS preference to generate
feedback_frequencyhow often to give feedback
Returns
the preference generator

Definition at line 1122 of file gnunet-ats-solver-eval.c.

1136 {
1137  struct PreferenceGenerator *pg;
1138  struct TestPeer *p;
1139 
1140  if (NULL == (p = find_peer_by_id (peer)))
1141  {
1142  GNUNET_break (0);
1144  "Starting preference for unknown peer %u\n", peer);
1145  return NULL;
1146  }
1147 
1148  pg = GNUNET_new (struct PreferenceGenerator);
1150  pg->type = type;
1151  pg->peer = peer;
1152  pg->client_id = client_id;
1153  pg->kind = kind;
1154  pg->base_value = base_value;
1155  pg->max_value = value_rate;
1156  pg->duration_period = period;
1157  pg->frequency = frequency;
1159  pg->feedback_frequency = feedback_frequency;
1160 
1161  switch (type)
1162  {
1165  "Setting up %s preference generator peer [%u] `%s' max %u Bips\n",
1168  base_value);
1169  break;
1170 
1173  "Setting up %s preference generator peer [%u] `%s' min %u Bips max %u Bips\n",
1176  base_value, value_rate);
1177  break;
1178 
1181  "Setting up %s preference generator peer [%u] `%s' baserate %u Bips, amplitude %u Bps\n",
1184  base_value, value_rate);
1185  break;
1186 
1189  "Setting up %s preference generator peer [%u] `%s' min %u Bips max %u Bps\n",
1192  base_value, value_rate);
1193  break;
1194 
1195  default:
1196  break;
1197  }
1198 
1200  if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us !=
1201  feedback_frequency.rel_value_us)
1202  {
1203  struct TestAddress *addr = find_active_address (p);
1204 
1205  pg->last_assigned_bw_in = p->assigned_bw_in;
1206  pg->last_assigned_bw_out = p->assigned_bw_out;
1207  pg->feedback_bw_in_acc = 0;
1208  pg->feedback_bw_out_acc = 0;
1209  pg->last_delay_value = addr->prop_norm[GNUNET_ATS_QUALITY_NET_DELAY];
1210  pg->feedback_delay_acc = 0;
1211 
1215  pg->feedback_task = GNUNET_SCHEDULER_add_delayed (feedback_frequency,
1216  &set_feedback_task, pg);
1217  }
1218 
1219  return pg;
1220 }
static struct TestAddress * find_active_address(struct TestPeer *p)
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".

References PreferenceGenerator::base_value, PreferenceGenerator::client_id, PreferenceGenerator::duration_period, PreferenceGenerator::feedback_bw_in_acc, PreferenceGenerator::feedback_bw_out_acc, PreferenceGenerator::feedback_delay_acc, PreferenceGenerator::feedback_frequency, PreferenceGenerator::feedback_last, PreferenceGenerator::feedback_last_bw_update, PreferenceGenerator::feedback_last_delay_update, PreferenceGenerator::feedback_task, find_active_address(), find_peer_by_id(), PreferenceGenerator::frequency, GNUNET_ATS_print_preference_type(), 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_ERROR, GNUNET_log, GNUNET_new, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_TIME_absolute_get(), GNUNET_TIME_UNIT_FOREVER_REL, PreferenceGenerator::kind, PreferenceGenerator::last_assigned_bw_in, PreferenceGenerator::last_assigned_bw_out, PreferenceGenerator::last_delay_value, PreferenceGenerator::max_value, p, PreferenceGenerator::peer, peer, pref_gen_head, pref_gen_tail, print_generator_type(), TestAddress::prop_norm, GNUNET_TIME_Relative::rel_value_us, set_feedback_task(), set_pref_task(), PreferenceGenerator::set_task, PreferenceGenerator::time_start, PreferenceGenerator::type, and type.

Referenced by enforce_start_preference().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_ATS_solver_generate_preferences_stop_all()

void GNUNET_ATS_solver_generate_preferences_stop_all ( )

Stop all preferences generators.

Definition at line 1227 of file gnunet-ats-solver-eval.c.

1228 {
1229  struct PreferenceGenerator *cur;
1230  struct PreferenceGenerator *next;
1231 
1232  next = pref_gen_head;
1233  for (cur = next; NULL != cur; cur = next)
1234  {
1235  next = cur->next;
1237  }
1238 }
void GNUNET_ATS_solver_generate_preferences_stop(struct PreferenceGenerator *pg)

References GNUNET_ATS_solver_generate_preferences_stop(), PreferenceGenerator::next, and pref_gen_head.

Referenced by done().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ print_op()

static const char* print_op ( enum OperationType  op)
static

Experiments.

Definition at line 1245 of file gnunet-ats-solver-eval.c.

1246 {
1247  switch (op)
1248  {
1249  case SOLVER_OP_ADD_ADDRESS:
1250  return "ADD_ADDRESS";
1251 
1252  case SOLVER_OP_DEL_ADDRESS:
1253  return "DEL_ADDRESS";
1254 
1256  return "START_SET_PREFERENCE";
1257 
1259  return "STOP_STOP_PREFERENCE";
1260 
1262  return "START_SET_PROPERTY";
1263 
1265  return "STOP_SET_PROPERTY";
1266 
1268  return "START_REQUEST";
1269 
1271  return "STOP_REQUEST";
1272 
1273  default:
1274  break;
1275  }
1276  return "";
1277 }
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
@ SOLVER_OP_STOP_SET_PREFERENCE
@ SOLVER_OP_DEL_ADDRESS
@ SOLVER_OP_START_REQUEST
@ SOLVER_OP_STOP_SET_PROPERTY
@ SOLVER_OP_START_SET_PREFERENCE
@ SOLVER_OP_STOP_REQUEST
@ SOLVER_OP_ADD_ADDRESS
@ SOLVER_OP_START_SET_PROPERTY

References op, SOLVER_OP_ADD_ADDRESS, SOLVER_OP_DEL_ADDRESS, SOLVER_OP_START_REQUEST, SOLVER_OP_START_SET_PREFERENCE, SOLVER_OP_START_SET_PROPERTY, SOLVER_OP_STOP_REQUEST, SOLVER_OP_STOP_SET_PREFERENCE, and SOLVER_OP_STOP_SET_PROPERTY.

Referenced by enforce_episode().

Here is the caller graph for this function:

◆ create_experiment()

static struct Experiment* create_experiment ( )
static

Definition at line 1281 of file gnunet-ats-solver-eval.c.

1282 {
1283  struct Experiment *e;
1284 
1285  e = GNUNET_new (struct Experiment);
1286  e->name = NULL;
1287  e->start = NULL;
1289  return e;
1290 }
struct Episode * start
struct GNUNET_TIME_Relative total_duration

References e, GNUNET_new, GNUNET_TIME_UNIT_ZERO, Experiment::name, Experiment::start, and Experiment::total_duration.

Referenced by GNUNET_ATS_solvers_experimentation_load().

Here is the caller graph for this function:

◆ free_experiment()

static void free_experiment ( struct Experiment e)
static

Definition at line 1294 of file gnunet-ats-solver-eval.c.

1295 {
1296  struct Episode *cur;
1297  struct Episode *next;
1298  struct GNUNET_ATS_TEST_Operation *cur_o;
1299  struct GNUNET_ATS_TEST_Operation *next_o;
1300 
1301  next = e->start;
1302  for (cur = next; NULL != cur; cur = next)
1303  {
1304  next = cur->next;
1305 
1306  next_o = cur->head;
1307  for (cur_o = next_o; NULL != cur_o; cur_o = next_o)
1308  {
1309  next_o = cur_o->next;
1310  GNUNET_free (cur_o->address);
1311  GNUNET_free (cur_o->plugin);
1312  GNUNET_free (cur_o);
1313  }
1314  GNUNET_free (cur);
1315  }
1316 
1317  GNUNET_free (e->name);
1320  GNUNET_free (e->cfg_file);
1321  GNUNET_free (e);
1322 }
struct Episode * next
struct GNUNET_ATS_TEST_Operation * head
An operation in an experiment.
struct GNUNET_ATS_TEST_Operation * next

References GNUNET_ATS_TEST_Operation::address, Experiment::cfg_file, e, GNUNET_free, Episode::head, Experiment::log_output_dir, Experiment::log_prefix, Experiment::name, GNUNET_ATS_TEST_Operation::next, Episode::next, GNUNET_ATS_TEST_Operation::plugin, and Experiment::start.

Referenced by GNUNET_ATS_solvers_experimentation_load(), and GNUNET_ATS_solvers_experimentation_stop().

Here is the caller graph for this function:

◆ load_op_add_address()

static int load_op_add_address ( struct GNUNET_ATS_TEST_Operation o,
struct Episode e,
int  op_counter,
char *  sec_name,
const struct GNUNET_CONFIGURATION_Handle cfg 
)
static

Definition at line 1326 of file gnunet-ats-solver-eval.c.

1331 {
1332  char *op_name;
1333  char *op_network;
1334 
1335  /* peer pid */
1336  GNUNET_asprintf (&op_name, "op-%u-peer-id", op_counter);
1338  sec_name, op_name,
1339  &o->peer_id))
1340  {
1341  fprintf (stderr, "Missing peer-id in operation %u `%s' in episode `%s'\n",
1342  op_counter, "ADD_ADDRESS", op_name);
1343  GNUNET_free (op_name);
1344  return GNUNET_SYSERR;
1345  }
1346  GNUNET_free (op_name);
1347 
1348  /* address pid */
1349  GNUNET_asprintf (&op_name, "op-%u-address-id", op_counter);
1351  sec_name, op_name,
1352  &o->address_id))
1353  {
1354  fprintf (stderr,
1355  "Missing address-id in operation %u `%s' in episode `%s'\n",
1356  op_counter, "ADD_ADDRESS", op_name);
1357  GNUNET_free (op_name);
1358  return GNUNET_SYSERR;
1359  }
1360  GNUNET_free (op_name);
1361 
1362  /* plugin */
1363  GNUNET_asprintf (&op_name, "op-%u-plugin", op_counter);
1365  sec_name, op_name,
1366  &o->plugin))
1367  {
1368  fprintf (stderr, "Missing plugin in operation %u `%s' in episode `%s'\n",
1369  op_counter, "ADD_ADDRESS", op_name);
1370  GNUNET_free (op_name);
1371  return GNUNET_SYSERR;
1372  }
1373  GNUNET_free (op_name);
1374 
1375  /* address */
1376  GNUNET_asprintf (&op_name, "op-%u-address", op_counter);
1378  sec_name, op_name,
1379  &o->address))
1380  {
1381  fprintf (stderr, "Missing address in operation %u `%s' in episode `%s'\n",
1382  op_counter, "ADD_ADDRESS", op_name);
1383  GNUNET_free (op_name);
1384  return GNUNET_SYSERR;
1385  }
1386  GNUNET_free (op_name);
1387 
1388  /* session */
1389  GNUNET_asprintf (&op_name, "op-%u-address-session", op_counter);
1391  sec_name, op_name,
1392  &o->
1393  address_session))
1394  {
1395  fprintf (stderr,
1396  "Missing address-session in operation %u `%s' in episode `%s'\n",
1397  op_counter, "ADD_ADDRESS", op_name);
1398  GNUNET_free (op_name);
1399  return GNUNET_SYSERR;
1400  }
1401  GNUNET_free (op_name);
1402 
1403  /* network */
1404  GNUNET_asprintf (&op_name, "op-%u-address-network", op_counter);
1406  sec_name, op_name,
1407  &op_network))
1408  {
1409  fprintf (stderr,
1410  "Missing address-network in operation %u `%s' in episode `%s'\n",
1411  op_counter, "ADD_ADDRESS", op_name);
1412  GNUNET_free (op_name);
1413  return GNUNET_SYSERR;
1414  }
1415  else
1416  {
1417  GNUNET_STRINGS_utf8_toupper (op_network, op_network);
1418  if (0 == strcmp (op_network, "UNSPECIFIED"))
1419  {
1421  }
1422  else if (0 == strcmp (op_network, "LOOPBACK"))
1423  {
1425  }
1426  else if (0 == strcmp (op_network, "LAN"))
1427  {
1429  }
1430  else if (0 == strcmp (op_network, "WAN"))
1431  {
1433  }
1434  else if (0 == strcmp (op_network, "WLAN"))
1435  {
1437  }
1438  else if (0 == strcmp (op_network, "BT"))
1439  {
1441  }
1442  else
1443  {
1444  fprintf (stderr,
1445  "Invalid address-network in operation %u `%s' in episode `%s': `%s'\n",
1446  op_counter, "ADD_ADDRESS", op_name, op_network);
1447  GNUNET_free (op_network);
1448  GNUNET_free (op_name);
1449  return GNUNET_SYSERR;
1450  }
1451  }
1452  GNUNET_free (op_network);
1453  GNUNET_free (op_name);
1454 
1456  "Found operation %s: [%llu:%llu] address `%s' plugin `%s' \n",
1457  "ADD_ADDRESS", o->peer_id, o->address_id, o->address, o->plugin);
1458 
1459  return GNUNET_OK;
1460 }
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
@ GNUNET_SYSERR
Definition: gnunet_common.h:93
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_number(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *number)
Get a configuration value that should be a number.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
@ GNUNET_NT_WLAN
Wireless LAN (i.e.
Definition: gnunet_nt_lib.h:60
@ GNUNET_NT_WAN
Wide area network (i.e.
Definition: gnunet_nt_lib.h:55
@ GNUNET_NT_UNSPECIFIED
Category of last resort.
Definition: gnunet_nt_lib.h:40
@ GNUNET_NT_LAN
Local area network.
Definition: gnunet_nt_lib.h:50
@ GNUNET_NT_LOOPBACK
Loopback (same host).
Definition: gnunet_nt_lib.h:45
@ GNUNET_NT_BT
Bluetooth LAN.
Definition: gnunet_nt_lib.h:65
void GNUNET_STRINGS_utf8_toupper(const char *input, char *output)
Convert the utf-8 input string to upper case.
Definition: strings.c:463
long long unsigned int peer_id
long long unsigned int address_id

References GNUNET_ATS_TEST_Operation::address, GNUNET_ATS_TEST_Operation::address_id, GNUNET_ATS_TEST_Operation::address_network, GNUNET_ATS_TEST_Operation::address_session, cfg, GNUNET_asprintf(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_NT_BT, GNUNET_NT_LAN, GNUNET_NT_LOOPBACK, GNUNET_NT_UNSPECIFIED, GNUNET_NT_WAN, GNUNET_NT_WLAN, GNUNET_OK, GNUNET_STRINGS_utf8_toupper(), GNUNET_SYSERR, GNUNET_ATS_TEST_Operation::peer_id, and GNUNET_ATS_TEST_Operation::plugin.

Referenced by load_episode().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ load_op_del_address()

static int load_op_del_address ( struct GNUNET_ATS_TEST_Operation o,
struct Episode e,
int  op_counter,
char *  sec_name,
const struct GNUNET_CONFIGURATION_Handle cfg 
)
static

Definition at line 1464 of file gnunet-ats-solver-eval.c.

1469 {
1470  char *op_name;
1471 
1472  // char *op_network;
1473 
1474  /* peer pid */
1475  GNUNET_asprintf (&op_name, "op-%u-peer-id", op_counter);
1477  sec_name, op_name,
1478  &o->peer_id))
1479  {
1480  fprintf (stderr, "Missing peer-id in operation %u `%s' in episode `%s'\n",
1481  op_counter, "DEL_ADDRESS", op_name);
1482  GNUNET_free (op_name);
1483  return GNUNET_SYSERR;
1484  }
1485  GNUNET_free (op_name);
1486 
1487  /* address pid */
1488  GNUNET_asprintf (&op_name, "op-%u-address-id", op_counter);
1490  sec_name, op_name,
1491  &o->address_id))
1492  {
1493  fprintf (stderr,
1494  "Missing address-id in operation %u `%s' in episode `%s'\n",
1495  op_counter, "DEL_ADDRESS", op_name);
1496  GNUNET_free (op_name);
1497  return GNUNET_SYSERR;
1498  }
1499  GNUNET_free (op_name);
1500 
1501 #if 0
1502  /* plugin */
1503  GNUNET_asprintf (&op_name, "op-%u-plugin", op_counter);
1505  sec_name, op_name,
1506  &o->plugin))
1507  {
1508  fprintf (stderr, "Missing plugin in operation %u `%s' in episode `%s'\n",
1509  op_counter, "DEL_ADDRESS", op_name);
1510  GNUNET_free (op_name);
1511  return GNUNET_SYSERR;
1512  }
1513  GNUNET_free (op_name);
1514 
1515  /* address */
1516  GNUNET_asprintf (&op_name, "op-%u-address", op_counter);
1518  sec_name, op_name,
1519  &o->address))
1520  {
1521  fprintf (stderr, "Missing address in operation %u `%s' in episode `%s'\n",
1522  op_counter, "DEL_ADDRESS", op_name);
1523  GNUNET_free (op_name);
1524  return GNUNET_SYSERR;
1525  }
1526  GNUNET_free (op_name);
1527 
1528  /* session */
1529  GNUNET_asprintf (&op_name, "op-%u-address-session", op_counter);
1531  sec_name, op_name,
1532  &o->
1533  address_session))
1534  {
1535  fprintf (stderr,
1536  "Missing address-session in operation %u `%s' in episode `%s'\n",
1537  op_counter, "DEL_ADDRESS", op_name);
1538  GNUNET_free (op_name);
1539  return GNUNET_SYSERR;
1540  }
1541  GNUNET_free (op_name);
1542 #endif
1543 
1545  "Found operation %s: [%llu:%llu] address `%s' plugin `%s' \n",
1546  "DEL_ADDRESS", o->peer_id, o->address_id, o->address, o->plugin);
1547 
1548  return GNUNET_OK;
1549 }

References GNUNET_ATS_TEST_Operation::address, GNUNET_ATS_TEST_Operation::address_id, GNUNET_ATS_TEST_Operation::address_session, cfg, GNUNET_asprintf(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_OK, GNUNET_SYSERR, GNUNET_ATS_TEST_Operation::peer_id, and GNUNET_ATS_TEST_Operation::plugin.

Referenced by load_episode().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ parse_preference_string()

static enum GNUNET_ATS_Property parse_preference_string ( const char *  str)
static

Definition at line 1464 of file gnunet-ats-solver-eval.c.

1554 {
1555  int c = 0;
1556  char *props[GNUNET_ATS_PreferenceCount] = GNUNET_ATS_PreferenceTypeString;
1557 
1558  for (c = 0; c < GNUNET_ATS_PreferenceCount; c++)
1559  if (0 == strcmp (str, props[c]))
1560  return c;
1561  return 0;
1562 }
#define GNUNET_ATS_PreferenceTypeString
ATS preference types as string array initializer.
struct LinkProperty * props
list of link properties

Referenced by load_op_start_set_preference(), and load_op_stop_set_preference().

Here is the caller graph for this function:

◆ load_op_start_set_preference()

static int load_op_start_set_preference ( struct GNUNET_ATS_TEST_Operation o,
struct Episode e,
int  op_counter,
char *  sec_name,
const struct GNUNET_CONFIGURATION_Handle cfg 
)
static

Definition at line 1566 of file gnunet-ats-solver-eval.c.

1571 {
1572  char *op_name;
1573  char *type;
1574  char *pref;
1575 
1576  /* peer pid */
1577  GNUNET_asprintf (&op_name, "op-%u-peer-id", op_counter);
1579  sec_name, op_name,
1580  &o->peer_id))
1581  {
1582  fprintf (stderr, "Missing peer-id in operation %u `%s' in episode `%s'\n",
1583  op_counter, "START_SET_PREFERENCE", op_name);
1584  GNUNET_free (op_name);
1585  return GNUNET_SYSERR;
1586  }
1587  GNUNET_free (op_name);
1588 
1589  /* address pid */
1590  GNUNET_asprintf (&op_name, "op-%u-client-id", op_counter);
1592  sec_name, op_name,
1593  &o->client_id))
1594  {
1595  fprintf (stderr, "Missing client-id in operation %u `%s' in episode `%s'\n",
1596  op_counter, "START_SET_PREFERENCE", op_name);
1597  GNUNET_free (op_name);
1598  return GNUNET_SYSERR;
1599  }
1600  GNUNET_free (op_name);
1601 
1602  /* generator */
1603  GNUNET_asprintf (&op_name, "op-%u-gen-type", op_counter);
1605  sec_name,
1606  op_name, &type)))
1607  {
1608  fprintf (stderr, "Missing type in operation %u `%s' in episode `%s'\n",
1609  op_counter, "START_SET_PREFERENCE", op_name);
1610  GNUNET_free (op_name);
1611  return GNUNET_SYSERR;
1612  }
1613 
1614  /* Load arguments for set_rate, start_send, set_preference */
1615  if (0 == strcmp (type, "constant"))
1616  {
1618  }
1619  else if (0 == strcmp (type, "linear"))
1620  {
1622  }
1623  else if (0 == strcmp (type, "sinus"))
1624  {
1626  }
1627  else if (0 == strcmp (type, "random"))
1628  {
1630  }
1631  else
1632  {
1633  fprintf (stderr, "Invalid generator type %u `%s' in episode %u\n",
1634  op_counter, op_name, e->id);
1635  GNUNET_free (type);
1636  GNUNET_free (op_name);
1637  return GNUNET_SYSERR;
1638  }
1639  GNUNET_free (type);
1640  GNUNET_free (op_name);
1641 
1642 
1643  /* Get base rate */
1644  GNUNET_asprintf (&op_name, "op-%u-base-rate", op_counter);
1646  sec_name, op_name,
1647  &o->base_rate))
1648  {
1649  fprintf (stderr, "Missing base rate in operation %u `%s' in episode %u\n",
1650  op_counter, op_name, e->id);
1651  GNUNET_free (op_name);
1652  return GNUNET_SYSERR;
1653  }
1654  GNUNET_free (op_name);
1655 
1656 
1657  /* Get max rate */
1658  GNUNET_asprintf (&op_name, "op-%u-max-rate", op_counter);
1660  sec_name, op_name,
1661  &o->max_rate))
1662  {
1663  if ((GNUNET_ATS_TEST_TG_LINEAR == o->gen_type) ||
1666  {
1667  fprintf (stderr, "Missing max rate in operation %u `%s' in episode %u\n",
1668  op_counter, op_name, e->id);
1669  GNUNET_free (op_name);
1670  return GNUNET_SYSERR;
1671  }
1672  }
1673  GNUNET_free (op_name);
1674 
1675  /* Get period */
1676  GNUNET_asprintf (&op_name, "op-%u-period", op_counter);
1678  sec_name, op_name,
1679  &o->period))
1680  {
1681  o->period = e->duration;
1682  }
1683  GNUNET_free (op_name);
1684 
1685  /* Get frequency */
1686  GNUNET_asprintf (&op_name, "op-%u-frequency", op_counter);
1688  sec_name, op_name,
1689  &o->frequency))
1690  {
1691  fprintf (stderr, "Missing frequency in operation %u `%s' in episode %u\n",
1692  op_counter, op_name, e->id);
1693  GNUNET_free (op_name);
1694  return GNUNET_SYSERR;
1695  }
1696  GNUNET_free (op_name);
1697 
1698  /* Get preference */
1699  GNUNET_asprintf (&op_name, "op-%u-pref", op_counter);
1701  sec_name, op_name,
1702  &pref))
1703  {
1704  fprintf (stderr, "Missing preference in operation %u `%s' in episode %u\n",
1705  op_counter, op_name, e->id);
1706  GNUNET_free (op_name);
1707  return GNUNET_SYSERR;
1708  }
1709 
1710  if (0 == (o->pref_type = parse_preference_string (pref)))
1711  {
1712  fprintf (stderr, "Invalid preference in operation %u `%s' in episode %u\n",
1713  op_counter, op_name, e->id);
1714  GNUNET_free (op_name);
1715  GNUNET_free (pref);
1716  return GNUNET_SYSERR;
1717  }
1718  GNUNET_free (pref);
1719  GNUNET_free (op_name);
1720 
1721  /* Get feedback delay */
1722  GNUNET_asprintf (&op_name, "op-%u-feedback_delay", op_counter);
1724  sec_name, op_name,
1725  &o->feedback_delay))
1726  {
1727  fprintf (stderr,
1728  "Using feedback delay %llu in operation %u `%s' in episode %u\n",
1729  (long long unsigned int) o->feedback_delay.rel_value_us,
1730  op_counter, op_name, e->id);
1731  }
1732  else
1734  GNUNET_free (op_name);
1735 
1737  "Found operation %s: [%llu:%llu]: %s = %llu\n",
1738  "START_SET_PREFERENCE", o->peer_id, o->address_id,
1740 
1741  return GNUNET_OK;
1742 }
static enum GNUNET_ATS_Property parse_preference_string(const char *str)
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_time(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, struct GNUNET_TIME_Relative *time)
Get a configuration value that should be a relative time.
struct GNUNET_TIME_Relative period
struct GNUNET_TIME_Relative feedback_delay
long long unsigned int client_id
long long unsigned int max_rate
enum GNUNET_ATS_PreferenceKind pref_type
long long unsigned int base_rate
struct GNUNET_TIME_Relative frequency

References GNUNET_ATS_TEST_Operation::address_id, GNUNET_ATS_TEST_Operation::base_rate, cfg, GNUNET_ATS_TEST_Operation::client_id, e, GNUNET_ATS_TEST_Operation::feedback_delay, GNUNET_ATS_TEST_Operation::frequency, GNUNET_ATS_TEST_Operation::gen_type, GNUNET_asprintf(), GNUNET_ATS_print_preference_type(), GNUNET_ATS_TEST_TG_CONSTANT, GNUNET_ATS_TEST_TG_LINEAR, GNUNET_ATS_TEST_TG_RANDOM, GNUNET_ATS_TEST_TG_SINUS, GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_get_value_time(), GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_OK, GNUNET_SYSERR, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_ATS_TEST_Operation::max_rate, parse_preference_string(), GNUNET_ATS_TEST_Operation::peer_id, GNUNET_ATS_TEST_Operation::period, GNUNET_ATS_TEST_Operation::pref_type, GNUNET_TIME_Relative::rel_value_us, and type.

Referenced by load_episode().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ load_op_stop_set_preference()

static int load_op_stop_set_preference ( struct GNUNET_ATS_TEST_Operation o,
struct Episode e,
int  op_counter,
char *  sec_name,
const struct GNUNET_CONFIGURATION_Handle cfg 
)
static

Definition at line 1746 of file gnunet-ats-solver-eval.c.

1751 {
1752  char *op_name;
1753  char *pref;
1754 
1755  /* peer pid */
1756  GNUNET_asprintf (&op_name, "op-%u-peer-id", op_counter);
1758  sec_name, op_name,
1759  &o->peer_id))
1760  {
1761  fprintf (stderr, "Missing peer-id in operation %u `%s' in episode `%s'\n",
1762  op_counter, "STOP_SET_PREFERENCE", op_name);
1763  GNUNET_free (op_name);
1764  return GNUNET_SYSERR;
1765  }
1766  GNUNET_free (op_name);
1767 
1768  /* address pid */
1769  GNUNET_asprintf (&op_name, "op-%u-address-id", op_counter);
1771  sec_name, op_name,
1772  &o->address_id))
1773  {
1774  fprintf (stderr,
1775  "Missing address-id in operation %u `%s' in episode `%s'\n",
1776  op_counter, "STOP_SET_PREFERENCE", op_name);
1777  GNUNET_free (op_name);
1778  return GNUNET_SYSERR;
1779  }
1780  GNUNET_free (op_name);
1781 
1782  /* Get preference */
1783  GNUNET_asprintf (&op_name, "op-%u-pref", op_counter);
1785  sec_name, op_name,
1786  &pref))
1787  {
1788  fprintf (stderr,
1789  "Missing preference in operation %u `%s' in episode `%s'\n",
1790  op_counter, "STOP_SET_PREFERENCE", op_name);
1791  GNUNET_free (op_name);
1792  return GNUNET_SYSERR;
1793  }
1794 
1795  if (0 == (o->pref_type = parse_preference_string (pref)))
1796  {
1797  fprintf (stderr, "Invalid preference in operation %u `%s' in episode %u\n",
1798  op_counter, op_name, e->id);
1799  GNUNET_free (op_name);
1800  GNUNET_free (pref);
1801  return GNUNET_SYSERR;
1802  }
1803  GNUNET_free (pref);
1804  GNUNET_free (op_name);
1805 
1807  "Found operation %s: [%llu:%llu]: %s\n",
1808  "STOP_SET_PREFERENCE", o->peer_id, o->address_id,
1810  return GNUNET_OK;
1811 }

References GNUNET_ATS_TEST_Operation::address_id, cfg, e, GNUNET_asprintf(), GNUNET_ATS_print_preference_type(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_OK, GNUNET_SYSERR, parse_preference_string(), GNUNET_ATS_TEST_Operation::peer_id, and GNUNET_ATS_TEST_Operation::pref_type.

Referenced by load_episode().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ parse_property_string()

static enum GNUNET_ATS_Property parse_property_string ( const char *  str)
static

Definition at line 1746 of file gnunet-ats-solver-eval.c.

1816 {
1817  enum GNUNET_ATS_Property c;
1818 
1819  for (c = 0; c < GNUNET_ATS_PropertyCount; c++)
1820  if (0 == strcmp (str,
1821  GNUNET_ATS_print_property_type (c)))
1822  return c;
1823  return 0;
1824 }

Referenced by load_op_start_set_property(), and load_op_stop_set_property().

Here is the caller graph for this function:

◆ load_op_start_set_property()

static int load_op_start_set_property ( struct GNUNET_ATS_TEST_Operation o,
struct Episode e,
int  op_counter,
char *  sec_name,
const struct GNUNET_CONFIGURATION_Handle cfg 
)
static

Definition at line 1828 of file gnunet-ats-solver-eval.c.

1833 {
1834  char *op_name;
1835  char *type;
1836  char *prop;
1837 
1838  /* peer pid */
1839  GNUNET_asprintf (&op_name, "op-%u-peer-id", op_counter);
1841  sec_name, op_name,
1842  &o->peer_id))
1843  {
1844  fprintf (stderr, "Missing peer-id in operation %u `%s' in episode `%s'\n",
1845  op_counter, "START_SET_PROPERTY", op_name);
1846  GNUNET_free (op_name);
1847  return GNUNET_SYSERR;
1848  }
1849  GNUNET_free (op_name);
1850 
1851  /* address pid */
1852  GNUNET_asprintf (&op_name, "op-%u-address-id", op_counter);
1854  sec_name, op_name,
1855  &o->address_id))
1856  {
1857  fprintf (stderr,
1858  "Missing address-id in operation %u `%s' in episode `%s'\n",
1859  op_counter, "START_SET_PROPERTY", op_name);
1860  GNUNET_free (op_name);
1861  return GNUNET_SYSERR;
1862  }
1863  GNUNET_free (op_name);
1864 
1865  /* generator */
1866  GNUNET_asprintf (&op_name, "op-%u-gen-type", op_counter);
1868  sec_name,
1869  op_name, &type)))
1870  {
1871  fprintf (stderr, "Missing type in operation %u `%s' in episode `%s'\n",
1872  op_counter, "START_SET_PROPERTY", op_name);
1873  GNUNET_free (op_name);
1874  return GNUNET_SYSERR;
1875  }
1876 
1877  /* Load arguments for set_rate, start_send, set_preference */
1878  if (0 == strcmp (type, "constant"))
1879  {
1881  }
1882  else if (0 == strcmp (type, "linear"))
1883  {
1885  }
1886  else if (0 == strcmp (type, "sinus"))
1887  {
1889  }
1890  else if (0 == strcmp (type, "random"))
1891  {
1893  }
1894  else
1895  {
1896  fprintf (stderr, "Invalid generator type %u `%s' in episode %u\n",
1897  op_counter, op_name, e->id);
1898  GNUNET_free (type);
1899  GNUNET_free (op_name);
1900  return GNUNET_SYSERR;
1901  }
1902  GNUNET_free (type);
1903  GNUNET_free (op_name);
1904 
1905 
1906  /* Get base rate */
1907  GNUNET_asprintf (&op_name, "op-%u-base-rate", op_counter);
1909  sec_name, op_name,
1910  &o->base_rate))
1911  {
1912  fprintf (stderr, "Missing base rate in operation %u `%s' in episode %u\n",
1913  op_counter, op_name, e->id);
1914  GNUNET_free (op_name);
1915  return GNUNET_SYSERR;
1916  }
1917  GNUNET_free (op_name);
1918 
1919 
1920  /* Get max rate */
1921  GNUNET_asprintf (&op_name, "op-%u-max-rate", op_counter);
1923  sec_name, op_name,
1924  &o->max_rate))
1925  {
1926  if ((GNUNET_ATS_TEST_TG_LINEAR == o->gen_type) ||
1929  {
1930  fprintf (stderr, "Missing max rate in operation %u `%s' in episode %u\n",
1931  op_counter, op_name, e->id);
1932  GNUNET_free (op_name);
1933  return GNUNET_SYSERR;
1934  }
1935  }
1936  GNUNET_free (op_name);
1937 
1938  /* Get period */
1939  GNUNET_asprintf (&op_name, "op-%u-period", op_counter);
1941  sec_name, op_name,
1942  &o->period))
1943  {
1944  o->period = e->duration;
1945  }
1946  GNUNET_free (op_name);
1947 
1948  /* Get frequency */
1949  GNUNET_asprintf (&op_name, "op-%u-frequency", op_counter);
1951  sec_name, op_name,
1952  &o->frequency))
1953  {
1954  fprintf (stderr, "Missing frequency in operation %u `%s' in episode %u\n",
1955  op_counter, op_name, e->id);
1956  GNUNET_free (op_name);
1957  return GNUNET_SYSERR;
1958  }
1959  GNUNET_free (op_name);
1960 
1961  /* Get preference */
1962  GNUNET_asprintf (&op_name, "op-%u-property", op_counter);
1964  sec_name, op_name,
1965  &prop))
1966  {
1967  fprintf (stderr, "Missing property in operation %u `%s' in episode %u\n",
1968  op_counter, op_name, e->id);
1969  GNUNET_free (op_name);
1970  GNUNET_free (prop);
1971  return GNUNET_SYSERR;
1972  }
1973 
1974  if (0 == (o->prop_type = parse_property_string (prop)))
1975  {
1976  fprintf (stderr, "Invalid property in operation %u `%s' in episode %u\n",
1977  op_counter, op_name, e->id);
1978  GNUNET_free (op_name);
1979  GNUNET_free (prop);
1980  return GNUNET_SYSERR;
1981  }
1982 
1983  GNUNET_free (prop);
1984  GNUNET_free (op_name);
1985 
1987  "Found operation %s: [%llu:%llu] %s = %llu\n",
1988  "START_SET_PROPERTY", o->peer_id, o->address_id,
1989  GNUNET_ATS_print_property_type (o->prop_type), o->base_rate);
1990 
1991  return GNUNET_OK;
1992 }
static enum GNUNET_ATS_Property parse_property_string(const char *str)

References GNUNET_ATS_TEST_Operation::address_id, GNUNET_ATS_TEST_Operation::base_rate, cfg, e, GNUNET_ATS_TEST_Operation::frequency, GNUNET_ATS_TEST_Operation::gen_type, GNUNET_asprintf(), GNUNET_ATS_TEST_TG_CONSTANT, GNUNET_ATS_TEST_TG_LINEAR, GNUNET_ATS_TEST_TG_RANDOM, GNUNET_ATS_TEST_TG_SINUS, GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_get_value_time(), GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_OK, GNUNET_SYSERR, GNUNET_ATS_TEST_Operation::max_rate, parse_property_string(), GNUNET_ATS_TEST_Operation::peer_id, GNUNET_ATS_TEST_Operation::period, and type.

Referenced by load_episode().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ load_op_stop_set_property()

static int load_op_stop_set_property ( struct GNUNET_ATS_TEST_Operation o,
struct Episode e,
int  op_counter,
char *  sec_name,
const struct GNUNET_CONFIGURATION_Handle cfg 
)
static

Definition at line 1996 of file gnunet-ats-solver-eval.c.

2001 {
2002  char *op_name;
2003  char *pref;
2004 
2005  /* peer pid */
2006  GNUNET_asprintf (&op_name, "op-%u-peer-id", op_counter);
2008  sec_name, op_name,
2009  &o->peer_id))
2010  {
2011  fprintf (stderr, "Missing peer-id in operation %u `%s' in episode `%s'\n",
2012  op_counter, "STOP_SET_PROPERTY", op_name);
2013  GNUNET_free (op_name);
2014  return GNUNET_SYSERR;
2015  }
2016  GNUNET_free (op_name);
2017 
2018  /* address pid */
2019  GNUNET_asprintf (&op_name, "op-%u-address-id", op_counter);
2021  sec_name, op_name,
2022  &o->address_id))
2023  {
2024  fprintf (stderr,
2025  "Missing address-id in operation %u `%s' in episode `%s'\n",
2026  op_counter, "STOP_SET_PROPERTY", op_name);
2027  GNUNET_free (op_name);
2028  return GNUNET_SYSERR;
2029  }
2030  GNUNET_free (op_name);
2031 
2032  /* Get property */
2033  GNUNET_asprintf (&op_name, "op-%u-property", op_counter);
2035  sec_name, op_name,
2036  &pref))
2037  {
2038  fprintf (stderr, "Missing property in operation %u `%s' in episode `%s'\n",
2039  op_counter, "STOP_SET_PROPERTY", op_name);
2040  GNUNET_free (op_name);
2041  GNUNET_free (pref);
2042  return GNUNET_SYSERR;
2043  }
2044 
2045  if (0 == (o->prop_type = parse_property_string (pref)))
2046  {
2047  fprintf (stderr, "Invalid property in operation %u `%s' in episode %u\n",
2048  op_counter, op_name, e->id);
2049  GNUNET_free (op_name);
2050  GNUNET_free (pref);
2051  return GNUNET_SYSERR;
2052  }
2053 
2054  GNUNET_free (pref);
2055  GNUNET_free (op_name);
2056 
2058  "Found operation %s: [%llu:%llu] %s\n",
2059  "STOP_SET_PROPERTY", o->peer_id, o->address_id,
2060  GNUNET_ATS_print_property_type (o->prop_type));
2061 
2062  return GNUNET_OK;
2063 }

References GNUNET_ATS_TEST_Operation::address_id, cfg, e, GNUNET_asprintf(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_OK, GNUNET_SYSERR, parse_property_string(), and GNUNET_ATS_TEST_Operation::peer_id.

Referenced by load_episode().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ load_op_start_request()

static int load_op_start_request ( struct GNUNET_ATS_TEST_Operation o,
struct Episode e,
int  op_counter,
char *  sec_name,
const struct GNUNET_CONFIGURATION_Handle cfg 
)
static

Definition at line 2067 of file gnunet-ats-solver-eval.c.

2072 {
2073  char *op_name;
2074 
2075  /* peer pid */
2076  GNUNET_asprintf (&op_name, "op-%u-peer-id", op_counter);
2078  sec_name, op_name,
2079  &o->peer_id))
2080  {
2081  fprintf (stderr, "Missing peer-id in operation %u `%s' in episode `%s'\n",
2082  op_counter, "START_REQUEST", op_name);
2083  GNUNET_free (op_name);
2084  return GNUNET_SYSERR;
2085  }
2086  GNUNET_free (op_name);
2087  return GNUNET_OK;
2088 }

References cfg, GNUNET_asprintf(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_free, GNUNET_OK, GNUNET_SYSERR, and GNUNET_ATS_TEST_Operation::peer_id.

Referenced by load_episode().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ load_op_stop_request()

static int load_op_stop_request ( struct GNUNET_ATS_TEST_Operation o,
struct Episode e,
int  op_counter,
char *  sec_name,
const struct GNUNET_CONFIGURATION_Handle cfg 
)
static

Definition at line 2092 of file gnunet-ats-solver-eval.c.

2097 {
2098  char *op_name;
2099 
2100  /* peer pid */
2101  GNUNET_asprintf (&op_name, "op-%u-peer-id", op_counter);
2103  sec_name, op_name,
2104  &o->peer_id))
2105  {
2106  fprintf (stderr, "Missing peer-id in operation %u `%s' in episode `%s'\n",
2107  op_counter, "STOP_REQUEST", op_name);
2108  GNUNET_free (op_name);
2109  return GNUNET_SYSERR;
2110  }
2111  GNUNET_free (op_name);
2112  return GNUNET_OK;
2113 }

References cfg, GNUNET_asprintf(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_free, GNUNET_OK, GNUNET_SYSERR, and GNUNET_ATS_TEST_Operation::peer_id.

Referenced by load_episode().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ load_episode()

static int load_episode ( struct Experiment e,
struct Episode cur,
struct GNUNET_CONFIGURATION_Handle cfg 
)
static

Definition at line 2117 of file gnunet-ats-solver-eval.c.

2119 {
2120  struct GNUNET_ATS_TEST_Operation *o;
2121  char *sec_name;
2122  char *op_name;
2123  char *op;
2124  int op_counter = 0;
2125  int res;
2126 
2127  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "=== Parsing episode %u\n", cur->id);
2128  GNUNET_asprintf (&sec_name, "episode-%u", cur->id);
2129 
2130  while (1)
2131  {
2132  /* Load operation */
2133  GNUNET_asprintf (&op_name, "op-%u-operation", op_counter);
2135  sec_name,
2136  op_name, &op))
2137  {
2138  GNUNET_free (op_name);
2139  break;
2140  }
2142  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "==== Parsing operation %u: `%s'\n",
2143  cur->id, op_name);
2144 
2145  /* operations = set_rate, start_send, stop_send, set_preference */
2146  if (0 == strcmp (op, "address_add"))
2147  {
2149  res = load_op_add_address (o, cur,
2150  op_counter, sec_name, cfg);
2151  }
2152  else if (0 == strcmp (op, "address_del"))
2153  {
2155  res = load_op_del_address (o, cur,
2156  op_counter, sec_name, cfg);
2157  }
2158  else if (0 == strcmp (op, "start_set_property"))
2159  {
2161  res = load_op_start_set_property (o, cur,
2162  op_counter, sec_name, cfg);
2163  }
2164  else if (0 == strcmp (op, "stop_set_property"))
2165  {
2167  res = load_op_stop_set_property (o, cur,
2168  op_counter, sec_name, cfg);
2169  }
2170  else if (0 == strcmp (op, "start_set_preference"))
2171  {
2174  op_counter, sec_name, cfg);
2175  }
2176  else if (0 == strcmp (op, "stop_set_preference"))
2177  {
2179  res = load_op_stop_set_preference (o, cur,
2180  op_counter, sec_name, cfg);
2181  }
2182  else if (0 == strcmp (op, "start_request"))
2183  {
2185  res = load_op_start_request (o, cur,
2186  op_counter, sec_name, cfg);
2187  }
2188  else if (0 == strcmp (op, "stop_request"))
2189  {
2191  res = load_op_stop_request (o, cur,
2192  op_counter, sec_name, cfg);
2193  }
2194  else
2195  {
2196  fprintf (stderr, "Invalid operation %u `%s' in episode %u\n",
2197  op_counter, op, cur->id);
2198  res = GNUNET_SYSERR;
2199  }
2200 
2201  GNUNET_free (op);
2202  GNUNET_free (op_name);
2203 
2204  if (GNUNET_SYSERR == res)
2205  {
2206  GNUNET_free (o);
2207  GNUNET_free (sec_name);
2208  return GNUNET_SYSERR;
2209  }
2210 
2211  GNUNET_CONTAINER_DLL_insert_tail (cur->head, cur->tail, o);
2212  op_counter++;
2213  }
2214  GNUNET_free (sec_name);
2215  return GNUNET_OK;
2216 }
static int load_op_stop_request(struct GNUNET_ATS_TEST_Operation *o, struct Episode *e, int op_counter, char *sec_name, const struct GNUNET_CONFIGURATION_Handle *cfg)
static int load_op_start_set_property(struct GNUNET_ATS_TEST_Operation *o, struct Episode *e, int op_counter, char *sec_name, const struct GNUNET_CONFIGURATION_Handle *cfg)
static int load_op_stop_set_property(struct GNUNET_ATS_TEST_Operation *o, struct Episode *e, int op_counter, char *sec_name, const struct GNUNET_CONFIGURATION_Handle *cfg)
static int load_op_stop_set_preference(struct GNUNET_ATS_TEST_Operation *o, struct Episode *e, int op_counter, char *sec_name, const struct GNUNET_CONFIGURATION_Handle *cfg)
static int load_op_del_address(struct GNUNET_ATS_TEST_Operation *o, struct Episode *e, int op_counter, char *sec_name, const struct GNUNET_CONFIGURATION_Handle *cfg)
static int load_op_start_request(struct GNUNET_ATS_TEST_Operation *o, struct Episode *e, int op_counter, char *sec_name, const struct GNUNET_CONFIGURATION_Handle *cfg)
static int load_op_start_set_preference(struct GNUNET_ATS_TEST_Operation *o, struct Episode *e, int op_counter, char *sec_name, const struct GNUNET_CONFIGURATION_Handle *cfg)
static int load_op_add_address(struct GNUNET_ATS_TEST_Operation *o, struct Episode *e, int op_counter, char *sec_name, const struct GNUNET_CONFIGURATION_Handle *cfg)
struct GNUNET_ATS_TEST_Operation * tail

References cfg, GNUNET_asprintf(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_new, GNUNET_OK, GNUNET_SYSERR, Episode::head, Episode::id, load_op_add_address(), load_op_del_address(), load_op_start_request(), load_op_start_set_preference(), load_op_start_set_property(), load_op_stop_request(), load_op_stop_set_preference(), load_op_stop_set_property(), op, res, SOLVER_OP_ADD_ADDRESS, SOLVER_OP_DEL_ADDRESS, SOLVER_OP_START_REQUEST, SOLVER_OP_START_SET_PREFERENCE, SOLVER_OP_START_SET_PROPERTY, SOLVER_OP_STOP_REQUEST, SOLVER_OP_STOP_SET_PREFERENCE, SOLVER_OP_STOP_SET_PROPERTY, Episode::tail, and GNUNET_ATS_TEST_Operation::type.

Referenced by load_episodes().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ load_episodes()

static int load_episodes ( struct Experiment e,
struct GNUNET_CONFIGURATION_Handle cfg 
)
static

Definition at line 2220 of file gnunet-ats-solver-eval.c.

2221 {
2222  int e_counter = 0;
2223  char *sec_name;
2224  struct GNUNET_TIME_Relative e_duration;
2225  struct Episode *cur;
2226  struct Episode *last;
2227 
2228  e_counter = 0;
2229  last = NULL;
2230  while (1)
2231  {
2232  GNUNET_asprintf (&sec_name, "episode-%u", e_counter);
2234  sec_name,
2235  "duration",
2236  &e_duration))
2237  {
2238  GNUNET_free (sec_name);
2239  break;
2240  }
2241 
2242  cur = GNUNET_new (struct Episode);
2243  cur->duration = e_duration;
2244  cur->id = e_counter;
2245 
2246  if (GNUNET_OK != load_episode (e, cur, cfg))
2247  {
2248  GNUNET_free (sec_name);
2249  GNUNET_free (cur);
2250  return GNUNET_SYSERR;
2251  }
2252 
2253  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Found episode %u with duration %s \n",
2254  e_counter,
2256  GNUNET_YES));
2257 
2258  /* Update experiment */
2259  e->num_episodes++;
2261  cur->duration);
2262  /* Put in linked list */
2263  if (NULL == last)
2264  e->start = cur;
2265  else
2266  last->next = cur;
2267 
2268  GNUNET_free (sec_name);
2269  e_counter++;
2270  last = cur;
2271  }
2272  return e_counter;
2273 }
static int load_episode(struct Experiment *e, struct Episode *cur, struct GNUNET_CONFIGURATION_Handle *cfg)
struct GNUNET_TIME_Relative GNUNET_TIME_relative_add(struct GNUNET_TIME_Relative a1, struct GNUNET_TIME_Relative a2)
Add relative times together.
Definition: time.c:411
struct GNUNET_TIME_Relative duration
unsigned int num_episodes

References cfg, Episode::duration, e, GNUNET_asprintf(), GNUNET_CONFIGURATION_get_value_time(), GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_new, GNUNET_OK, GNUNET_STRINGS_relative_time_to_string(), GNUNET_SYSERR, GNUNET_TIME_relative_add(), GNUNET_YES, Episode::id, load_episode(), Episode::next, Experiment::num_episodes, Experiment::start, and Experiment::total_duration.

Referenced by GNUNET_ATS_solvers_experimentation_load().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ timeout_experiment()

static void timeout_experiment ( void *  cls)
static

Definition at line 2277 of file gnunet-ats-solver-eval.c.

2278 {
2279  struct Experiment *e = cls;
2280 
2281  e->experiment_timeout_task = NULL;
2282  fprintf (stderr, "Experiment timeout!\n");
2283 
2284  if (NULL != e->episode_timeout_task)
2285  {
2287  e->episode_timeout_task = NULL;
2288  }
2289 
2291  GNUNET_SYSERR);
2292 }
struct GNUNET_SCHEDULER_Task * episode_timeout_task
GNUNET_ATS_TESTING_ExperimentDoneCallback e_done_cb
struct GNUNET_TIME_Absolute start_time
struct GNUNET_SCHEDULER_Task * experiment_timeout_task

References e, Experiment::e_done_cb, Experiment::episode_timeout_task, Experiment::experiment_timeout_task, GNUNET_SCHEDULER_cancel(), GNUNET_SYSERR, GNUNET_TIME_absolute_get_duration(), and Experiment::start_time.

Referenced by GNUNET_ATS_solvers_experimentation_run().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ create_ats_address()

struct ATS_Address* create_ats_address ( const struct GNUNET_PeerIdentity peer,
const char *  plugin_name,
const void *  plugin_addr,
size_t  plugin_addr_len,
uint32_t  session_id,
uint32_t  network 
)

Definition at line 2296 of file gnunet-ats-solver-eval.c.

2302 {
2303  struct ATS_Address *aa = NULL;
2304 
2305  aa = GNUNET_malloc (sizeof(struct ATS_Address) + plugin_addr_len + strlen (
2306  plugin_name) + 1);
2307  aa->atsi = GNUNET_new (struct GNUNET_ATS_Information);
2308  aa->atsi[0].type = htonl (GNUNET_ATS_NETWORK_TYPE);
2309  aa->atsi[0].value = htonl (network);
2310  aa->atsi_count = 1;
2311 
2312  aa->peer = *peer;
2313  aa->addr_len = plugin_addr_len;
2314  aa->addr = &aa[1];
2315  aa->plugin = (char *) &aa[1] + plugin_addr_len;
2316  GNUNET_memcpy (&aa[1], plugin_addr, plugin_addr_len);
2317  GNUNET_memcpy (aa->plugin, plugin_name, strlen (plugin_name) + 1);
2318  aa->session_id = session_id;
2319 
2320  return aa;
2321 }
static struct GNUNET_HashCode session_id
static char * plugin_name
Name of our plugin.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_malloc(size)
Wrapper around malloc.
Address with additional information.
char * plugin
Plugin name.
struct GNUNET_PeerIdentity peer
Peer ID this address is for.
uint32_t session_id
Session ID, can never be 0.
size_t addr_len
Address length, number of bytes in addr.
uint32_t atsi_count
ATS performance information for this address, size of the atsi array.
const void * addr
Address (in plugin-specific binary format).

References ATS_Address::addr, ATS_Address::addr_len, ATS_Address::atsi_count, GNUNET_malloc, GNUNET_memcpy, GNUNET_new, ATS_Address::peer, peer, ATS_Address::plugin, plugin_name, ATS_Address::session_id, and session_id.

Referenced by enforce_add_address().

Here is the caller graph for this function:

◆ enforce_add_address()

static void enforce_add_address ( struct GNUNET_ATS_TEST_Operation op)
static

Definition at line 2325 of file gnunet-ats-solver-eval.c.

2326 {
2327  struct TestPeer *p;
2328  struct TestAddress *a;
2329  int c;
2330 
2331  if (NULL == (p = find_peer_by_id (op->peer_id)))
2332  {
2333  p = GNUNET_new (struct TestPeer);
2334  p->id = op->peer_id;
2335  p->assigned_bw_in = 0;
2336  p->assigned_bw_out = 0;
2337  memset (&p->peer_id, op->peer_id, sizeof(p->peer_id));
2338  for (c = 0; c < GNUNET_ATS_PreferenceCount; c++)
2339  {
2340  p->pref_abs[c] = DEFAULT_ABS_PREFERENCE;
2341  p->pref_norm[c] = DEFAULT_REL_PREFERENCE;
2342  }
2343 
2345  }
2346 
2347  if (NULL != (find_address_by_id (p, op->address_id)))
2348  {
2349  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Duplicate address %u for peer %u\n",
2350  op->address_id, op->peer_id);
2351  return;
2352  }
2353 
2354  a = GNUNET_new (struct TestAddress);
2355  a->aid = op->address_id;
2356  a->network = op->address_network;
2357  a->ats_addr = create_ats_address (&p->peer_id, op->plugin, op->address,
2358  strlen (op->address) + 1,
2359  op->address_session, op->address_network);
2360  memset (&p->peer_id, op->peer_id, sizeof(p->peer_id));
2361  GNUNET_CONTAINER_DLL_insert_tail (p->addr_head, p->addr_tail, a);
2362 
2363  for (c = 0; c < GNUNET_ATS_PropertyCount; c++)
2365 
2368 
2370  "Adding address %u for peer %u in network `%s'\n",
2371  op->address_id, op->peer_id, GNUNET_NT_to_string (a->network));
2372 
2373  sh->sf->s_add (sh->sf->cls, a->ats_addr, op->address_network);
2374 }
static struct TestPeer * peer_tail
struct ATS_Address * create_ats_address(const struct GNUNET_PeerIdentity *peer, const char *plugin_name, const void *plugin_addr, size_t plugin_addr_len, uint32_t session_id, uint32_t network)
#define DEFAULT_REL_QUALITY
Value we return for a normalized quality score if we have no data.
#define DEFAULT_ABS_PREFERENCE
Default preference value we assume if we know nothing.
#define DEFAULT_REL_PREFERENCE
Default relative preference value we assume if we know nothing.
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
Allow multiple values with the same key.
const char * GNUNET_NT_to_string(enum GNUNET_NetworkType net)
Convert a enum GNUNET_NetworkType to a string.
Definition: nt.c:44
GAS_solver_address_add s_add
Add a new address for a peer to the solver.

References SolverHandle::addresses, TestAddress::aid, TestAddress::ats_addr, GNUNET_ATS_SolverFunctions::cls, create_ats_address(), DEFAULT_ABS_PREFERENCE, DEFAULT_REL_PREFERENCE, DEFAULT_REL_QUALITY, find_address_by_id(), find_peer_by_id(), GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multipeermap_put(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_new, GNUNET_NT_to_string(), TestAddress::network, op, p, peer_head, peer_tail, TestAddress::prop_norm, GNUNET_ATS_SolverFunctions::s_add, SolverHandle::sf, and sh.

Referenced by enforce_episode().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ enforce_del_address()

static void enforce_del_address ( struct GNUNET_ATS_TEST_Operation op)
static

Definition at line 2378 of file gnunet-ats-solver-eval.c.

2379 {
2380  struct TestPeer *p;
2381  struct TestAddress *a;
2382  struct PropertyGenerator *pg;
2383 
2384  if (NULL == (p = find_peer_by_id (op->peer_id)))
2385  {
2386  GNUNET_break (0);
2388  "Deleting address for unknown peer %u\n", op->peer_id);
2389  return;
2390  }
2391 
2392  if (NULL == (a = find_address_by_id (p, op->address_id)))
2393  {
2394  GNUNET_break (0);
2396  "Deleting address for unknown peer %u\n", op->peer_id);
2397  return;
2398  }
2399 
2400  while (NULL != (pg = find_prop_gen (p->id, a->aid, 0)))
2401  {
2403  }
2404 
2407  &p->peer_id,
2408  a->ats_addr));
2410  "Removing address %u for peer %u\n",
2411  op->address_id,
2412  op->peer_id);
2413 
2414  sh->sf->s_del (sh->sf->cls, a->ats_addr);
2415 
2416  if (NULL != l)
2417  {
2419  }
2420  GNUNET_CONTAINER_DLL_remove (p->addr_head, p->addr_tail, a);
2421 
2422  GNUNET_free (a->ats_addr->atsi);
2423  GNUNET_free (a->ats_addr);
2424  GNUNET_free (a);
2425 }
static struct PropertyGenerator * find_prop_gen(unsigned int peer, unsigned int address, uint32_t ats_property)
Set ats_property to 0 to find all pgs.
int GNUNET_CONTAINER_multipeermap_remove(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Remove the given key-value pair from the map.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
GAS_solver_address_delete s_del
Delete an address in the solver.

References SolverHandle::addresses, TestAddress::aid, TestAddress::ats_addr, GNUNET_ATS_SolverFunctions::cls, find_address_by_id(), find_peer_by_id(), find_prop_gen(), GNUNET_assert, GNUNET_ATS_solver_generate_property_stop(), GNUNET_ATS_solver_logging_now(), GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_YES, l, op, p, GNUNET_ATS_SolverFunctions::s_del, SolverHandle::sf, and sh.

Referenced by enforce_episode().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ enforce_start_property()

static void enforce_start_property ( struct GNUNET_ATS_TEST_Operation op)
static

Definition at line 2429 of file gnunet-ats-solver-eval.c.

2430 {
2431  struct PropertyGenerator *pg;
2432  struct TestPeer *p;
2433  struct TestAddress *a;
2434 
2435  if (NULL != (pg = find_prop_gen (op->peer_id, op->address_id, op->prop_type)))
2436  {
2438  GNUNET_free (pg);
2439  }
2440 
2441  if (NULL == (p = find_peer_by_id (op->peer_id)))
2442  {
2443  GNUNET_break (0);
2445  "Starting property generation for unknown peer %u\n",
2446  op->peer_id);
2447  return;
2448  }
2449 
2450  if (NULL == (a = find_address_by_id (p, op->address_id)))
2451  {
2452  GNUNET_break (0);
2454  "Setting property for unknown address %u\n", op->peer_id);
2455  return;
2456  }
2457 
2459  op->address_id,
2460  p, a,
2461  op->gen_type,
2462  op->base_rate,
2463  op->max_rate,
2464  op->period,
2465  op->frequency,
2466  op->prop_type);
2467 }
struct PropertyGenerator * GNUNET_ATS_solver_generate_property_start(unsigned int peer, unsigned int address_id, struct TestPeer *test_peer, struct TestAddress *test_address, enum GeneratorType type, long int base_value, long int value_rate, struct GNUNET_TIME_Relative period, struct GNUNET_TIME_Relative frequency, uint32_t ats_property)
Generate between the source master and the partner and set property with a value depending on the gen...

References find_address_by_id(), find_peer_by_id(), find_prop_gen(), GNUNET_ATS_solver_generate_property_start(), GNUNET_ATS_solver_generate_property_stop(), GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, op, and p.

Referenced by enforce_episode().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ enforce_stop_property()

static void enforce_stop_property ( struct GNUNET_ATS_TEST_Operation op)
static

Definition at line 2471 of file gnunet-ats-solver-eval.c.

2472 {
2473  struct PropertyGenerator *pg = find_prop_gen (op->peer_id, op->address_id,
2474  op->prop_type);
2475 
2476  if (NULL != pg)
2477  {
2479  "Stopping preference generation for peer %u address %u\n",
2480  op->peer_id,
2481  op->address_id);
2483  }
2484  else
2485  {
2487  "Cannot find preference generator for peer %u address %u\n",
2488  op->peer_id, op->address_id);
2489  GNUNET_break (0);
2490  }
2491 }

References find_prop_gen(), GNUNET_ATS_solver_generate_property_stop(), GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, and op.

Referenced by enforce_episode().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ enforce_start_preference()

static void enforce_start_preference ( struct GNUNET_ATS_TEST_Operation op)
static

Definition at line 2495 of file gnunet-ats-solver-eval.c.

2496 {
2497  struct PreferenceGenerator *pg;
2498 
2499  if (NULL != (pg = find_pref_gen (op->peer_id, op->pref_type)))
2500  {
2502  GNUNET_free (pg);
2503  }
2504 
2505  if (NULL == (find_peer_by_id (op->peer_id)))
2506  {
2507  GNUNET_break (0);
2509  "Starting preference generation for unknown peer %u\n",
2510  op->peer_id);
2511  return;
2512  }
2513 
2515  op->address_id,
2516  op->client_id,
2517  op->gen_type,
2518  op->base_rate,
2519  op->max_rate,
2520  op->period,
2521  op->frequency,
2522  op->pref_type,
2523  op->frequency);
2524 }
struct PreferenceGenerator * GNUNET_ATS_solver_generate_preferences_start(unsigned int peer, unsigned int address_id, unsigned int client_id, enum GeneratorType type, long int base_value, long int value_rate, struct GNUNET_TIME_Relative period, struct GNUNET_TIME_Relative frequency, enum GNUNET_ATS_PreferenceKind kind, struct GNUNET_TIME_Relative feedback_frequency)
Generate between the source master and the partner and set property with a value depending on the gen...
static struct PreferenceGenerator * find_pref_gen(unsigned int peer, enum GNUNET_ATS_PreferenceKind kind)

References find_peer_by_id(), find_pref_gen(), GNUNET_ATS_solver_generate_preferences_start(), GNUNET_ATS_solver_generate_preferences_stop(), GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, and op.

Referenced by enforce_episode().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ enforce_stop_preference()

static void enforce_stop_preference ( struct GNUNET_ATS_TEST_Operation op)
static

Definition at line 2528 of file gnunet-ats-solver-eval.c.

2529 {
2530  struct PreferenceGenerator *pg = find_pref_gen (op->peer_id,
2531  op->pref_type);
2532 
2533  if (NULL != pg)
2534  {
2536  "Stopping property generation for peer %u address %u\n",
2537  op->peer_id,
2538  op->address_id);
2540  }
2541  else
2542  {
2544  "Cannot find preference generator for peer %u address %u\n",
2545  op->peer_id, op->address_id);
2546  GNUNET_break (0);
2547  }
2548 }

References find_pref_gen(), GNUNET_ATS_solver_generate_preferences_stop(), GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, and op.

Referenced by enforce_episode().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ enforce_start_request()

static void enforce_start_request ( struct GNUNET_ATS_TEST_Operation op)
static

Definition at line 2552 of file gnunet-ats-solver-eval.c.

2553 {
2554  struct TestPeer *p;
2555 
2556  if (NULL == (p = find_peer_by_id (op->peer_id)))
2557  {
2558  GNUNET_break (0);
2560  "Requesting address for unknown peer %u\n", op->peer_id);
2561  return;
2562  }
2563 
2564  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Requesting address for peer %u\n",
2565  op->peer_id);
2566  p->is_requested = GNUNET_YES;
2567 
2568  sh->sf->s_get (sh->sf->cls, &p->peer_id);
2569 }
GAS_solver_get_preferred_address s_get
Tell solver to notify ATS if the address to use changes for a specific peer using the bandwidth chang...

References GNUNET_ATS_SolverFunctions::cls, find_peer_by_id(), GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_YES, op, p, GNUNET_ATS_SolverFunctions::s_get, SolverHandle::sf, and sh.

Referenced by enforce_episode().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ enforce_stop_request()

static void enforce_stop_request ( struct GNUNET_ATS_TEST_Operation op)
static

Definition at line 2573 of file gnunet-ats-solver-eval.c.

2574 {
2575  struct TestPeer *p;
2576 
2577  if (NULL == (p = find_peer_by_id (op->peer_id)))
2578  {
2579  GNUNET_break (0);
2581  "Requesting address for unknown peer %u\n", op->peer_id);
2582  return;
2583  }
2584 
2586  "Stop requesting address for peer %u\n",
2587  op->peer_id);
2588  p->is_requested = GNUNET_NO;
2589  p->assigned_bw_in = 0;
2590  p->assigned_bw_out = 0;
2591  sh->sf->s_get_stop (sh->sf->cls, &p->peer_id);
2592 
2593  if (NULL != l)
2594  {
2596  }
2597 }
GAS_solver_stop_get_preferred_address s_get_stop
Tell solver stop notifying ATS about changes for this peers.

References GNUNET_ATS_SolverFunctions::cls, find_peer_by_id(), GNUNET_ATS_solver_logging_now(), GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NO, l, op, p, GNUNET_ATS_SolverFunctions::s_get_stop, SolverHandle::sf, and sh.

Referenced by enforce_episode().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ enforce_episode()

static void enforce_episode ( struct Episode ep)
static

Definition at line 2601 of file gnunet-ats-solver-eval.c.

2602 {
2603  struct GNUNET_ATS_TEST_Operation *cur;
2604 
2605  for (cur = ep->head; NULL != cur; cur = cur->next)
2606  {
2607  switch (cur->type)
2608  {
2609  case SOLVER_OP_ADD_ADDRESS:
2610  fprintf (stderr, "Enforcing operation: %s [%llu:%llu]\n",
2611  print_op (cur->type), cur->peer_id, cur->address_id);
2612  enforce_add_address (cur);
2613  break;
2614 
2615  case SOLVER_OP_DEL_ADDRESS:
2616  fprintf (stderr, "Enforcing operation: %s [%llu:%llu]\n",
2617  print_op (cur->type), cur->peer_id, cur->address_id);
2618  enforce_del_address (cur);
2619  break;
2620 
2622  fprintf (stderr, "Enforcing operation: %s [%llu:%llu] == %llu\n",
2623  print_op (cur->type), cur->peer_id, cur->address_id,
2624  cur->base_rate);
2625  enforce_start_property (cur);
2626  break;
2627 
2629  fprintf (stderr, "Enforcing operation: %s [%llu:%llu] == %llu\n",
2630  print_op (cur->type), cur->peer_id, cur->address_id,
2631  cur->base_rate);
2632  enforce_stop_property (cur);
2633  break;
2634 
2636  fprintf (stderr, "Enforcing operation: %s [%llu:%llu] == %llu\n",
2637  print_op (cur->type), cur->peer_id, cur->address_id,
2638  cur->base_rate);
2640  break;
2641 
2643  fprintf (stderr, "Enforcing operation: %s [%llu:%llu] == %llu\n",
2644  print_op (cur->type), cur->peer_id, cur->address_id,
2645  cur->base_rate);
2647  break;
2648 
2650  fprintf (stderr, "Enforcing operation: %s [%llu]\n",
2651  print_op (cur->type), cur->peer_id);
2652  enforce_start_request (cur);
2653  break;
2654 
2656  fprintf (stderr, "Enforcing operation: %s [%llu]\n",
2657  print_op (cur->type), cur->peer_id);
2658  enforce_stop_request (cur);
2659  break;
2660 
2661  default:
2662  break;
2663  }
2664  }
2665 }
static void enforce_start_request(struct GNUNET_ATS_TEST_Operation *op)
static const char * print_op(enum OperationType op)
Experiments.
static void enforce_start_property(struct GNUNET_ATS_TEST_Operation *op)
static void enforce_stop_preference(struct GNUNET_ATS_TEST_Operation *op)
static void enforce_stop_property(struct GNUNET_ATS_TEST_Operation *op)
static void enforce_add_address(struct GNUNET_ATS_TEST_Operation *op)
static void enforce_start_preference(struct GNUNET_ATS_TEST_Operation *op)
static void enforce_del_address(struct GNUNET_ATS_TEST_Operation *op)
static void enforce_stop_request(struct GNUNET_ATS_TEST_Operation *op)

References GNUNET_ATS_TEST_Operation::address_id, GNUNET_ATS_TEST_Operation::base_rate, enforce_add_address(), enforce_del_address(), enforce_start_preference(), enforce_start_property(), enforce_start_request(), enforce_stop_preference(), enforce_stop_property(), enforce_stop_request(), Episode::head, GNUNET_ATS_TEST_Operation::next, GNUNET_ATS_TEST_Operation::peer_id, print_op(), SOLVER_OP_ADD_ADDRESS, SOLVER_OP_DEL_ADDRESS, SOLVER_OP_START_REQUEST, SOLVER_OP_START_SET_PREFERENCE, SOLVER_OP_START_SET_PROPERTY, SOLVER_OP_STOP_REQUEST, SOLVER_OP_STOP_SET_PREFERENCE, SOLVER_OP_STOP_SET_PROPERTY, and GNUNET_ATS_TEST_Operation::type.

Referenced by GNUNET_ATS_solvers_experimentation_run(), and timeout_episode().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ timeout_episode()

static void timeout_episode ( void *  cls)
static

Definition at line 2669 of file gnunet-ats-solver-eval.c.

2670 {
2671  struct Experiment *e = cls;
2672 
2673  e->episode_timeout_task = NULL;
2674  if (NULL != e->ep_done_cb)
2675  e->ep_done_cb (e->cur);
2676 
2677  /* Scheduling next */
2678  e->cur = e->cur->next;
2679  if (NULL == e->cur)
2680  {
2681  /* done */
2682  fprintf (stderr, "Last episode done!\n");
2683  if (NULL != e->experiment_timeout_task)
2684  {
2686  e->experiment_timeout_task = NULL;
2687  }
2689  GNUNET_OK);
2690  return;
2691  }
2692 
2693  fprintf (stderr, "Running episode %u with timeout %s\n",
2694  e->cur->id,
2696  GNUNET_YES));
2698  &timeout_episode, e);
2699  enforce_episode (e->cur);
2700 }
static void timeout_episode(void *cls)
static void enforce_episode(struct Episode *ep)
GNUNET_ATS_TESTING_EpisodeDoneCallback ep_done_cb
struct Episode * cur

References Experiment::cur, Episode::duration, e, Experiment::e_done_cb, enforce_episode(), Experiment::ep_done_cb, Experiment::episode_timeout_task, Experiment::experiment_timeout_task, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_duration(), GNUNET_YES, Episode::id, Episode::next, and Experiment::start_time.

Referenced by GNUNET_ATS_solvers_experimentation_run().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_ATS_solvers_experimentation_run()

void GNUNET_ATS_solvers_experimentation_run ( struct Experiment e,
GNUNET_ATS_TESTING_EpisodeDoneCallback  ep_done_cb,
GNUNET_ATS_TESTING_ExperimentDoneCallback  e_done_cb 
)

Definition at line 2704 of file gnunet-ats-solver-eval.c.

2709 {
2710  fprintf (stderr, "Running experiment `%s' with timeout %s\n", e->name,
2712  GNUNET_YES));
2713  e->e_done_cb = e_done_cb;
2714  e->ep_done_cb = ep_done_cb;
2716 
2717  /* Start total time out */
2720  e);
2721 
2722  /* Start */
2723  if (NULL == e->start)
2724  {
2725  GNUNET_break (0);
2726  return;
2727  }
2728 
2729  e->cur = e->start;
2730  fprintf (stderr, "Running episode %u with timeout %s\n",
2731  e->cur->id,
2733  GNUNET_YES));
2735  &timeout_episode, e);
2736  enforce_episode (e->cur);
2737 }
static void timeout_experiment(void *cls)
struct GNUNET_TIME_Relative max_duration

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

Referenced by run().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_ATS_solvers_experimentation_stop()

void GNUNET_ATS_solvers_experimentation_stop ( struct Experiment e)

Definition at line 2741 of file gnunet-ats-solver-eval.c.

2742 {
2743  if (NULL != e->experiment_timeout_task)
2744  {
2746  e->experiment_timeout_task = NULL;
2747  }
2748  if (NULL != e->episode_timeout_task)
2749  {
2751  e->episode_timeout_task = NULL;
2752  }
2753  if (NULL != e->cfg)
2754  {
2756  e->cfg = NULL;
2757  }
2758  free_experiment (e);
2759 }
static void free_experiment(struct Experiment *e)
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
struct GNUNET_CONFIGURATION_Handle * cfg

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

Referenced by done(), end_now(), and GNUNET_ATS_solvers_experimentation_load().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_ATS_solvers_experimentation_load()

struct Experiment* GNUNET_ATS_solvers_experimentation_load ( char *  filename)

Definition at line 2763 of file gnunet-ats-solver-eval.c.

2764 {
2765  struct Experiment *e;
2767 
2768  e = NULL;
2769 
2772  {
2773  fprintf (stderr, "Failed to load `%s'\n", filename);
2775  return NULL;
2776  }
2777 
2778  e = create_experiment ();
2779 
2781  "name", &e->name))
2782  {
2783  fprintf (stderr, "Invalid %s \n", "name");
2784  free_experiment (e);
2785  return NULL;
2786  }
2787  else
2788  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Experiment name: `%s'\n", e->name);
2789 
2791  "log_prefix",
2792  &e->log_prefix))
2793  {
2794  fprintf (stderr, "Invalid %s \n", "log_prefix");
2795  free_experiment (e);
2796  return NULL;
2797  }
2798  else
2799  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Experiment logging prefix: `%s'\n",
2800  e->log_prefix);
2801 
2803  "experiment",
2804  "log_output_dir",
2805  &e->
2806  log_output_dir))
2807  {
2808  e->log_output_dir = NULL;
2809  }
2810  else
2812  "Experiment logging output directory: `%s'\n",
2813  e->log_output_dir);
2814 
2815 
2818  "experiment",
2819  "log_append_time_stamp")))
2822  "Experiment logging append timestamp: `%s'\n",
2823  (GNUNET_YES == e->log_append_time_stamp) ? "yes" : "no");
2824 
2825 
2827  "experiment",
2828  "cfg_file",
2829  &e->cfg_file))
2830  {
2831  fprintf (stderr, "Invalid %s \n", "cfg_file");
2832  free_experiment (e);
2833  return NULL;
2834  }
2835  else
2836  {
2837  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Experiment configuration: `%s'\n",
2838  e->cfg_file);
2841  {
2842  fprintf (stderr, "Invalid configuration %s \n", "cfg_file");
2843  free_experiment (e);
2844  return NULL;
2845  }
2846  }
2847 
2849  "log_freq",
2850  &e->log_freq))
2851  {
2852  fprintf (stderr, "Invalid %s \n", "log_freq");
2853  free_experiment (e);
2854  return NULL;
2855  }
2856  else
2857  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Experiment logging frequency: `%s'\n",
2859  GNUNET_YES));
2860 
2862  "max_duration",
2863  &e->max_duration))
2864  {
2865  fprintf (stderr, "Invalid %s", "max_duration");
2866  free_experiment (e);
2867  return NULL;
2868  }
2869  else
2870  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Experiment duration: `%s'\n",
2872  GNUNET_YES));
2873 
2874  if (GNUNET_SYSERR == load_episodes (e, cfg))
2875  {
2878  e = NULL;
2879  fprintf (stderr, "Failed to load experiment\n");
2880  return NULL;
2881  }
2883  "Loaded %u episodes with total duration %s\n",
2884  e->num_episodes,
2886  GNUNET_YES));
2887 
2889  return e;
2890 }
static int load_episodes(struct Experiment *e, struct GNUNET_CONFIGURATION_Handle *cfg)
static struct Experiment * create_experiment()
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_filename(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be the name of a file or directory.
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_create(void)
Create a new configuration object.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_yesno(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option)
Get a configuration value that should be in a set of "YES" or "NO".
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_load(struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
Load configuration.
struct GNUNET_TIME_Relative log_freq

References cfg, Experiment::cfg, Experiment::cfg_file, create_experiment(), e, filename, free_experiment(), GNUNET_ATS_solvers_experimentation_stop(), GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_destroy(), GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_get_value_time(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CONFIGURATION_load(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_STRINGS_relative_time_to_string(), GNUNET_SYSERR, GNUNET_YES, load_episodes(), Experiment::log_append_time_stamp, Experiment::log_freq, Experiment::log_output_dir, Experiment::log_prefix, Experiment::max_duration, Experiment::name, Experiment::num_episodes, and Experiment::total_duration.

Referenced by run().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ free_all_it()

static int free_all_it ( void *  cls,
const struct GNUNET_PeerIdentity key,
void *  value 
)
static

Solver.

Definition at line 2898 of file gnunet-ats-solver-eval.c.

2901 {
2902  struct ATS_Address *address = value;
2903 
2905  sh->env.addresses,
2906  key, value));
2907  GNUNET_free (address);
2908 
2909  return GNUNET_OK;
2910 }
struct GNUNET_HashCode key
The key used in the DHT.
static char * value
Value of the record to add/remove.
struct GNUNET_CONTAINER_MultiPeerMap * addresses
Hashmap containing all addresses available.
struct GNUNET_ATS_PluginEnvironment env
Solver environment.

References address, GNUNET_ATS_PluginEnvironment::addresses, SolverHandle::env, GNUNET_break, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_free, GNUNET_OK, key, sh, and value.

Referenced by GNUNET_ATS_solvers_solver_stop().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_ATS_solvers_solver_stop()

void GNUNET_ATS_solvers_solver_stop ( struct SolverHandle sh)

Definition at line 2914 of file gnunet-ats-solver-eval.c.

2915 {
2917  GNUNET_NO);
2919  sh->sf = NULL;
2921 
2923  &free_all_it,
2924  NULL);
2926  GNUNET_free (sh->plugin);
2927  GNUNET_free (sh);
2928 }
static int free_all_it(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Solver.
void GAS_normalization_stop()
Stop the normalization component and free all items.
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
void * GNUNET_PLUGIN_unload(const char *library_name, void *arg)
Unload plugin (runs the "done" callback and returns whatever "done" returned).
Definition: plugin.c:269
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).
struct GNUNET_STATISTICS_Handle * stats
Statistics handle to be used by the solver.
Handle for the service.
char * plugin
Solver plugin name.

References SolverHandle::addresses, SolverHandle::env, free_all_it(), GAS_normalization_stop(), GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_free, GNUNET_NO, GNUNET_PLUGIN_unload(), GNUNET_STATISTICS_destroy(), SolverHandle::plugin, SolverHandle::sf, sh, and GNUNET_ATS_PluginEnvironment::stats.

Referenced by done(), and end_now().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_ATS_solvers_load_quotas()

unsigned int GNUNET_ATS_solvers_load_quotas ( const struct GNUNET_CONFIGURATION_Handle cfg,
unsigned long long *  out_dest,
unsigned long long *  in_dest,
int  dest_length 
)

Load quotas for networks from configuration.

Parameters
cfgconfiguration handle
out_destwhere to write outbound quotas
in_destwhere to write inbound quotas
dest_lengthlength of inbound and outbound arrays
Returns
number of networks loaded

Definition at line 2941 of file gnunet-ats-solver-eval.c.

2945 {
2946  char *entry_in = NULL;
2947  char *entry_out = NULL;
2948  char *quota_out_str;
2949  char *quota_in_str;
2950  int c;
2951  int res;
2952 
2953  for (c = 0; (c < GNUNET_NT_COUNT) && (c < dest_length); c++)
2954  {
2955  in_dest[c] = 0;
2956  out_dest[c] = 0;
2957  GNUNET_asprintf (&entry_out,
2958  "%s_QUOTA_OUT",
2959  GNUNET_NT_to_string (c));
2960  GNUNET_asprintf (&entry_in,
2961  "%s_QUOTA_IN",
2962  GNUNET_NT_to_string (c));
2963 
2964  /* quota out */
2966  entry_out,
2967  &quota_out_str))
2968  {
2969  res = GNUNET_NO;
2970  if (0 == strcmp (quota_out_str, BIG_M_STRING))
2971  {
2972  out_dest[c] = GNUNET_ATS_MaxBandwidth;
2973  res = GNUNET_YES;
2974  }
2975  if ((GNUNET_NO == res) && (GNUNET_OK ==
2977  quota_out_str, &out_dest[c])))
2978  res = GNUNET_YES;
2979  if ((GNUNET_NO == res) && (GNUNET_OK ==
2981  "ats",
2982  entry_out,
2983  &
2984  out_dest
2985  [c])))
2986  res = GNUNET_YES;
2987 
2988  if (GNUNET_NO == res)
2989  {
2991  _ (
2992  "Could not load quota for network `%s': `%s', assigning default bandwidth %llu\n"),
2993  GNUNET_NT_to_string (c),
2994  quota_out_str,
2996  out_dest[c] = GNUNET_ATS_DefaultBandwidth;
2997  }
2998  else
2999  {
3001  "Outbound quota configure for network `%s' is %llu\n",
3002  GNUNET_NT_to_string (c),
3003  out_dest[c]);
3004  }
3005  GNUNET_free (quota_out_str);
3006  }
3007  else
3008  {
3010  _ (
3011  "No outbound quota configured for network `%s', assigning default bandwidth %llu\n"),
3012  GNUNET_NT_to_string (c),
3014  out_dest[c] = GNUNET_ATS_DefaultBandwidth;
3015  }
3016 
3017  /* quota in */
3019  entry_in,
3020  &quota_in_str))
3021  {
3022  res = GNUNET_NO;
3023  if (0 == strcmp (quota_in_str, BIG_M_STRING))
3024  {
3025  in_dest[c] = GNUNET_ATS_MaxBandwidth;
3026  res = GNUNET_YES;
3027  }
3028  if ((GNUNET_NO == res) && (GNUNET_OK ==
3030  quota_in_str, &in_dest[c])))
3031  res = GNUNET_YES;
3032  if ((GNUNET_NO == res) && (GNUNET_OK ==
3034  "ats",
3035  entry_in,
3036  &in_dest
3037  [c])))
3038  res = GNUNET_YES;
3039 
3040  if (GNUNET_NO == res)
3041  {
3043  _ (
3044  "Could not load quota for network `%s': `%s', assigning default bandwidth %llu\n"),
3045  GNUNET_NT_to_string (c),
3046  quota_in_str,
3048  in_dest[c] = GNUNET_ATS_DefaultBandwidth;
3049  }
3050  else
3051  {
3053  "Inbound quota configured for network `%s' is %llu\n",
3054  GNUNET_NT_to_string (c),
3055  in_dest[c]);
3056  }
3057  GNUNET_free (quota_in_str);
3058  }
3059  else
3060  {
3062  _ (
3063  "No outbound quota configure for network `%s', assigning default bandwidth %llu\n"),
3064  GNUNET_NT_to_string (c),
3066  out_dest[c] = GNUNET_ATS_DefaultBandwidth;
3067  }
3069  "Loaded quota for network `%s' (in/out): %llu %llu\n",
3070  GNUNET_NT_to_string (c),
3071  in_dest[c],
3072  out_dest[c]);
3073  GNUNET_free (entry_out);
3074  GNUNET_free (entry_in);
3075  }
3076  return GNUNET_NT_COUNT;
3077 }
#define BIG_M_STRING
#define GNUNET_NT_COUNT
#define GNUNET_ATS_DefaultBandwidth
Default bandwidth assigned to a network : 64 KB/s.
#define GNUNET_ATS_MaxBandwidth
Maximum bandwidth assigned to a network : 4095 MB/s.
@ GNUNET_ERROR_TYPE_WARNING
int GNUNET_STRINGS_fancy_size_to_bytes(const char *fancy_size, unsigned long long *size)
Convert a given fancy human-readable size to bytes.
Definition: strings.c:260
#define _(String)
GNU gettext support macro.
Definition: platform.h:177

References _, BIG_M_STRING, cfg, GNUNET_asprintf(), GNUNET_ATS_DefaultBandwidth, GNUNET_ATS_MaxBandwidth, GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_NT_COUNT, GNUNET_NT_to_string(), GNUNET_OK, GNUNET_STRINGS_fancy_size_to_bytes(), GNUNET_YES, and res.

Referenced by GNUNET_ATS_solvers_solver_start().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ solver_info_cb()

static void solver_info_cb ( void *  cls,
enum GAS_Solver_Operation  op,
enum GAS_Solver_Status  stat,
enum GAS_Solver_Additional_Information  add 
)
static

Information callback for the solver.

Parameters
clsthe closure
opthe solver operation
statstatus of the solver operation
addadditional solver information

Definition at line 3089 of file gnunet-ats-solver-eval.c.

3093 {
3094  char *add_info;
3095 
3096  switch (add)
3097  {
3098  case GAS_INFO_NONE:
3099  add_info = "GAS_INFO_NONE";
3100  break;
3101 
3102  case GAS_INFO_FULL:
3103  add_info = "GAS_INFO_MLP_FULL";
3104  break;
3105 
3106  case GAS_INFO_UPDATED:
3107  add_info = "GAS_INFO_MLP_UPDATED";
3108  break;
3109 
3110  case GAS_INFO_PROP_ALL:
3111  add_info = "GAS_INFO_PROP_ALL";
3112  break;
3113 
3114  case GAS_INFO_PROP_SINGLE:
3115  add_info = "GAS_INFO_PROP_SINGLE";
3116  break;
3117 
3118  default:
3119  add_info = "INVALID";
3120  break;
3121  }
3122 
3123  switch (op)
3124  {
3125  case GAS_OP_SOLVE_START:
3127  "Solver notifies `%s' with result `%s' `%s'\n",
3128  "GAS_OP_SOLVE_START",
3129  (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL", add_info);
3130  return;
3131 
3132  case GAS_OP_SOLVE_STOP:
3134  "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_STOP",
3135  (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL", add_info);
3136  return;
3137 
3140  "Solver notifies `%s' with result `%s'\n",
3141  "GAS_OP_SOLVE_SETUP_START",
3142  (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
3143  return;
3144 
3147  "Solver notifies `%s' with result `%s'\n",
3148  "GAS_OP_SOLVE_SETUP_STOP",
3149  (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
3150  return;
3151 
3154  "Solver notifies `%s' with result `%s'\n",
3155  "GAS_OP_SOLVE_LP_START",
3156  (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
3157  return;
3158 
3161  "Solver notifies `%s' with result `%s'\n",
3162  "GAS_OP_SOLVE_LP_STOP",
3163  (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
3164  return;
3165 
3168  "Solver notifies `%s' with result `%s'\n",
3169  "GAS_OP_SOLVE_MLP_START",
3170  (GAS_STAT_SUCCESS == stat) ? "SUCCESS" : "FAIL");
3171