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.

Referenced by GNUNET_ATS_solvers_load_quotas().

Function Documentation

◆ end_now()

static void end_now ( )
static

Do shutdown.

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

References GNUNET_ATS_solvers_experimentation_stop(), and GNUNET_ATS_solvers_solver_stop().

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

3435 {
3436  if (NULL != e)
3437  {
3439  e = NULL;
3440  }
3441  if (NULL != sh)
3442  {
3444  sh = NULL;
3445  }
3446 }
void GNUNET_ATS_solvers_solver_stop(struct SolverHandle *sh)
static struct Experiment * e
static struct SolverHandle * sh
void GNUNET_ATS_solvers_experimentation_stop(struct Experiment *e)
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.

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().

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 }
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.

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

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().

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 }
long long unsigned int id
static struct TestPeer * peer_head
struct TestPeer * next
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.

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

Referenced by get_preferences_cb(), and solver_bandwidth_changed_cb().

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 }
struct GNUNET_PeerIdentity peer_id
static struct TestPeer * peer_head
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
struct TestPeer * next
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.

References TestPeer::addr_head, TestAddress::aid, and TestAddress::next.

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

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 }
long long unsigned int aid
struct TestAddress * next
struct TestAddress * addr_head
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.

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, LoggingAddress::network, TestAddress::network, TestPeer::next, TestAddress::next, 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().

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 }
struct LoggingPeer * head
double prop_abs[GNUNET_ATS_PropertyCount]
struct LoggingTimeStep * tail
uint64_t rel_value_us
The actual value.
double pref_abs[GNUNET_ATS_PreferenceCount]
struct LoggingTimeStep * prev
int active
Is this the active address for this peer?
struct LoggingAddress * addr_tail
long long unsigned int aid
long long unsigned int id
struct GNUNET_PeerIdentity peer_id
struct LoggingTimeStep * head
#define GNUNET_new(type)
Allocate a struct or union of the given type.
uint64_t abs_value_us
The actual value.
struct ATS_Address * ats_addr
uint32_t assigned_bw_in
Inbound bandwidth assigned by solver.
struct LoggingPeer * tail
double pref_abs[GNUNET_ATS_PREFERENCE_END]
struct LoggingAddress * addr_head
double prop_norm[GNUNET_ATS_PropertyCount]
long long unsigned int aid
const char * GNUNET_ATS_print_preference_type(enum GNUNET_ATS_PreferenceKind type)
Convert a enum GNUNET_ATS_PreferenceType to a string.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
Entry for a benchmark peer.
static struct TestPeer * peer_head
struct GNUNET_TIME_Relative delta
struct GNUNET_TIME_Absolute timestamp
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
struct TestAddress * next
double prop_abs[GNUNET_ATS_PropertyCount]
uint32_t assigned_bw_out
Outbound bandwidth assigned by solver.
struct TestAddress * addr_head
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:375
#define GNUNET_log(kind,...)
struct TestPeer * next
double pref_norm[GNUNET_ATS_PREFERENCE_END]
double prop_norm[GNUNET_ATS_PropertyCount]
double pref_norm[GNUNET_ATS_PreferenceCount]
long long unsigned int id
struct GNUNET_PeerIdentity peer_id
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.

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

Referenced by GNUNET_ATS_solver_logging_start().

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

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().

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 }
static void logging_task(void *cls)
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static struct LoggingHandle * l
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1280
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:687
#define GNUNET_log(kind,...)
struct GNUNET_TIME_Relative log_freq
struct GNUNET_SCHEDULER_Task * logging_task
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.

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

Referenced by done().

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 }
#define GNUNET_log(kind,...)
struct GNUNET_SCHEDULER_Task * logging_task
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
Here is the call graph for this function:
Here is the caller graph for this function:

◆ find_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.

References LoggingFileHandle::aid, LoggingFileHandle::next, LoggingFileHandle::pid, and res.

Referenced by GNUNET_ATS_solver_logging_write_to_disk().

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 char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
long long unsigned int pid
struct LoggingFileHandle * next
static int res
long long unsigned int aid
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.

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, 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, 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().

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 
364  cur->f_hd = GNUNET_DISK_file_open (filename,
372  if (NULL == cur->f_hd)
373  {
374  fprintf (stderr, "Cannot open `%s' to write log data!\n", filename);
375  GNUNET_free (filename);
376  GNUNET_free (cur);
377  goto cleanup;
378  }
379  GNUNET_free (filename);
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 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct LoggingPeer * head
Create file if it doesn&#39;t exist.
int GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1345
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
long long unsigned int aid
struct LoggingTimeStep * next
struct LoggingTimeStep * head
static struct Experiment * e
int GNUNET_DISK_directory_create_for_file(const char *filename)
Create the directory structure for storing a file.
Definition: disk.c:684
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_new(type)
Allocate a struct or union of the given type.
long long unsigned int pid
struct LoggingAddress * next
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
uint64_t abs_value_us
The actual value.
static char * opt_solver
struct LoggingPeer * next
double pref_abs[GNUNET_ATS_PREFERENCE_END]
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
struct LoggingAddress * addr_head
static struct LoggingFileHandle * find_logging_file_handle(struct LoggingFileHandle *lf_head, struct LoggingFileHandle *lf_tail, int peer_id, int address_id)
struct LoggingFileHandle * next
double prop_norm[GNUNET_ATS_PropertyCount]
Truncate file if it exists.
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:820
#define DIR_SEPARATOR_STR
Definition: platform.h:168
static char * filename
static void cleanup(void *cls)
Function scheduled as very last function, cleans up after us.
Entry for a benchmark peer.
struct GNUNET_TIME_Relative delta
struct GNUNET_TIME_Absolute timestamp
struct GNUNET_DISK_FileHandle * f_hd
Everybody can read.
double prop_abs[GNUNET_ATS_PropertyCount]
#define GNUNET_log(kind,...)
long long unsigned int aid
Open the file for both reading and writing.
#define GNUNET_YES
Definition: gnunet_common.h:77
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:354
double pref_norm[GNUNET_ATS_PREFERENCE_END]
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:1268
#define GNUNET_free(ptr)
Wrapper around free.
long long unsigned int id
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.

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, 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().

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 }
struct LoggingPeer * head
uint64_t rel_value_us
The actual value.
long long unsigned int aid
struct LoggingTimeStep * next
struct LoggingTimeStep * head
struct LoggingAddress * next
uint64_t abs_value_us
The actual value.
struct LoggingPeer * next
double pref_abs[GNUNET_ATS_PREFERENCE_END]
struct LoggingAddress * addr_head
double prop_norm[GNUNET_ATS_PropertyCount]
const char * GNUNET_ATS_print_preference_type(enum GNUNET_ATS_PreferenceKind type)
Convert a enum GNUNET_ATS_PreferenceType to a string.
Entry for a benchmark peer.
struct GNUNET_TIME_Relative delta
struct GNUNET_TIME_Absolute timestamp
double prop_abs[GNUNET_ATS_PropertyCount]
double pref_norm[GNUNET_ATS_PREFERENCE_END]
long long unsigned int id
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.

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

Referenced by done().

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 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct LoggingPeer * head
struct LoggingTimeStep * tail
struct LoggingAddress * addr_tail
struct LoggingTimeStep * next
struct LoggingTimeStep * head
struct LoggingAddress * next
struct LoggingPeer * tail
struct LoggingPeer * next
struct LoggingAddress * addr_head
Entry for a benchmark peer.
struct GNUNET_SCHEDULER_Task * logging_task
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
Here is the call graph for this function:
Here is the caller graph for this function:

◆ get_property()

static double get_property ( struct PropertyGenerator pg)
static

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

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().

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 }
uint64_t rel_value_us
The actual value.
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
enum GeneratorType type
struct GNUNET_TIME_Absolute time_start
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:375
#define GNUNET_log(kind,...)
struct GNUNET_TIME_Relative duration_period
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
Time for relative time used by GNUnet, in microseconds.
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.

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, PropertyGenerator::test_address, test_address(), and PropertyGenerator::test_peer.

Referenced by GNUNET_ATS_solver_generate_property_start().

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 }
double prop_abs[GNUNET_ATS_PropertyCount]
long long unsigned int address_id
struct GNUNET_PeerIdentity peer_id
GAS_solver_address_property_changed s_address_update_property
Update the properties of an address in the solver.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct ATS_Address * ats_addr
void GAS_normalization_update_property(struct ATS_Address *address)
Update and normalize atsi performance information.
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:1253
struct GNUNET_SCHEDULER_Task * set_task
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
static struct SolverHandle * sh
struct GNUNET_TIME_Relative frequency
void * cls
Closure to pass to all solver functions in this struct.
struct TestAddress * test_address
static double get_property(struct PropertyGenerator *pg)
static int opt_disable_normalization
cmd option -d: disable normalization
struct GNUNET_ATS_SolverFunctions * sf
Solver handle.
static void set_prop_task(void *cls)
GAS_solver_bulk_start s_bulk_start
Start a bulk operation.
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.
long long unsigned int peer
#define GNUNET_log(kind,...)
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.
static struct TestPeer * find_peer_by_id(int id)
struct TestPeer * test_peer
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_CONTAINER_MultiPeerMap * addresses
Address hashmap.
double prop_norm[GNUNET_ATS_PropertyCount]
GAS_solver_bulk_stop s_bulk_stop
Bulk operation done.
static struct TestAddress * find_address_by_id(struct TestPeer *peer, int aid)
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.

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

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

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 }
long long unsigned int address_id
struct PropertyGenerator * next
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
long long unsigned int peer
static char * address
GNS address for this phone.
static struct PropertyGenerator * prop_gen_head
Property Generators.
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.

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

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

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 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
long long unsigned int address_id
struct GNUNET_SCHEDULER_Task * set_task
static struct PropertyGenerator * prop_gen_tail
long long unsigned int peer
#define GNUNET_log(kind,...)
#define GNUNET_free(ptr)
Wrapper around free.
static struct PropertyGenerator * prop_gen_head
Property Generators.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
Here is the call graph for this function:
Here is the caller graph for this function:

◆ 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.

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, peer, PropertyGenerator::peer, print_generator_type(), set_prop_task(), PropertyGenerator::set_task, PropertyGenerator::test_address, test_address(), PropertyGenerator::test_peer, PropertyGenerator::time_start, type, and PropertyGenerator::type.

Referenced by enforce_start_property().

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 }
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
long long unsigned int address_id
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_SCHEDULER_Task * set_task
enum GeneratorType type
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1280
static char * print_generator_type(enum GeneratorType g)
static struct PropertyGenerator * prop_gen_tail
struct GNUNET_TIME_Relative frequency
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
struct TestAddress * test_address
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
struct GNUNET_TIME_Absolute time_start
static void set_prop_task(void *cls)
long long unsigned int peer
#define GNUNET_log(kind,...)
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.
struct TestPeer * test_peer
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
struct GNUNET_TIME_Relative duration_period
static struct PropertyGenerator * prop_gen_head
Property Generators.
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.

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

Referenced by done().

829 {
830  struct PropertyGenerator *cur;
831  struct PropertyGenerator *next;
832 
833  next = prop_gen_head;
834  for (cur = next; NULL != cur; cur = next)
835  {
836  next = cur->next;
838  }
839 }
struct PropertyGenerator * next
void GNUNET_ATS_solver_generate_property_stop(struct PropertyGenerator *pg)
static struct PropertyGenerator * prop_gen_head
Property Generators.
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.

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().

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_Absolute time_start
uint64_t rel_value_us
The actual value.
struct GNUNET_TIME_Relative duration_period
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
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:375
#define GNUNET_log(kind,...)
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
Time for relative time used by GNUnet, in microseconds.
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.

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, TestPeer::peer_id, PreferenceGenerator::pref_bw_old, PreferenceGenerator::pref_latency_old, GNUNET_TIME_Relative::rel_value_us, GNUNET_ATS_SolverFunctions::s_feedback, and SolverHandle::sf.

Referenced by GNUNET_ATS_solver_generate_preferences_start().

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 void set_feedback_task(void *cls)
uint64_t rel_value_us
The actual value.
long long unsigned int peer
struct GNUNET_PeerIdentity peer_id
GAS_solver_address_feedback_preference s_feedback
Give feedback about the current assignment.
struct GNUNET_TIME_Absolute feedback_last_delay_update
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
enum GNUNET_ATS_PreferenceKind kind
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:1253
struct GNUNET_TIME_Absolute feedback_last_bw_update
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
static struct SolverHandle * sh
const char * GNUNET_ATS_print_preference_type(enum GNUNET_ATS_PreferenceKind type)
Convert a enum GNUNET_ATS_PreferenceType to a string.
void * cls
Closure to pass to all solver functions in this struct.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
Change the peer&#39;s latency value to the given amount.
struct GNUNET_TIME_Absolute feedback_last
struct GNUNET_ATS_SolverFunctions * sf
Solver handle.
struct GNUNET_SCHEDULER_Task * feedback_task
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:375
static double get_preference(struct PreferenceGenerator *pg)
#define GNUNET_log(kind,...)
Change the peer&#39;s bandwidth value (value per byte of bandwidth in the goal function) to the given amo...
static struct TestPeer * find_peer_by_id(int id)
struct GNUNET_TIME_Relative feedback_frequency
Time for relative time used by GNUnet, in microseconds.
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.

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, TestPeer::peer_id, TestPeer::pref_abs, PreferenceGenerator::pref_bw_old, PreferenceGenerator::pref_latency_old, TestPeer::pref_norm, GNUNET_ATS_SolverFunctions::s_pref, PreferenceGenerator::set_task, SolverHandle::sf, and update_preference().

Referenced by GNUNET_ATS_solver_generate_preferences_start().

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 }
double pref_abs[GNUNET_ATS_PreferenceCount]
long long unsigned int peer
struct GNUNET_PeerIdentity peer_id
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.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
enum GNUNET_ATS_PreferenceKind kind
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:1253
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
static struct SolverHandle * sh
const char * GNUNET_ATS_print_preference_type(enum GNUNET_ATS_PreferenceKind type)
Convert a enum GNUNET_ATS_PreferenceType to a string.
void * cls
Closure to pass to all solver functions in this struct.
GAS_solver_address_change_preference s_pref
Change relative preference for quality in solver.
struct GNUNET_SCHEDULER_Task * set_task
static int opt_disable_normalization
cmd option -d: disable normalization
Change the peer&#39;s latency value to the given amount.
struct GNUNET_ATS_SolverFunctions * sf
Solver handle.
struct GNUNET_TIME_Relative frequency
static double get_preference(struct PreferenceGenerator *pg)
#define GNUNET_log(kind,...)
Change the peer&#39;s bandwidth value (value per byte of bandwidth in the goal function) to the given amo...
static struct TestPeer * find_peer_by_id(int id)
#define GNUNET_YES
Definition: gnunet_common.h:77
static void set_pref_task(void *cls)
double pref_norm[GNUNET_ATS_PreferenceCount]
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.

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

Referenced by enforce_start_preference(), and enforce_stop_preference().

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 }
struct PreferenceGenerator * next
long long unsigned int peer
End of preference list.
enum GNUNET_ATS_PreferenceKind kind
static struct PreferenceGenerator * pref_gen_head
Preference Generators.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
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.

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, and PreferenceGenerator::set_task.

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

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 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
long long unsigned int peer
enum GNUNET_ATS_PreferenceKind kind
const char * GNUNET_ATS_print_preference_type(enum GNUNET_ATS_PreferenceKind type)
Convert a enum GNUNET_ATS_PreferenceType to a string.
struct GNUNET_SCHEDULER_Task * set_task
static struct PreferenceGenerator * pref_gen_head
Preference Generators.
struct GNUNET_SCHEDULER_Task * feedback_task
#define GNUNET_log(kind,...)
static struct PreferenceGenerator * pref_gen_tail
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
Here is the call graph for this function:
Here is the caller graph for this function:

◆ find_active_address()

static struct TestAddress* find_active_address ( struct TestPeer p)
static

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

References ATS_Address::active, TestPeer::addr_head, TestAddress::ats_addr, GNUNET_YES, and TestAddress::next.

Referenced by GNUNET_ATS_solver_generate_preferences_start().

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 }
int active
Is this the active address for this peer?
struct ATS_Address * ats_addr
struct TestAddress * next
struct TestAddress * addr_head
#define GNUNET_YES
Definition: gnunet_common.h:77
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.

References TestPeer::assigned_bw_in, TestPeer::assigned_bw_out, 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, peer, PreferenceGenerator::peer, print_generator_type(), TestAddress::prop_norm, GNUNET_TIME_Relative::rel_value_us, set_feedback_task(), set_pref_task(), PreferenceGenerator::set_task, PreferenceGenerator::time_start, type, and PreferenceGenerator::type.

Referenced by enforce_start_preference().

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 
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 }
struct GNUNET_TIME_Absolute time_start
static void set_feedback_task(void *cls)
uint64_t rel_value_us
The actual value.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
long long unsigned int peer
struct GNUNET_TIME_Relative duration_period
struct GNUNET_TIME_Absolute feedback_last_delay_update
static struct TestAddress * find_active_address(struct TestPeer *p)
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
enum GNUNET_ATS_PreferenceKind kind
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:1253
struct GNUNET_TIME_Absolute feedback_last_bw_update
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1280
static char * print_generator_type(enum GeneratorType g)
uint32_t assigned_bw_in
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
const char * GNUNET_ATS_print_preference_type(enum GNUNET_ATS_PreferenceKind type)
Convert a enum GNUNET_ATS_PreferenceType to a string.
struct GNUNET_SCHEDULER_Task * set_task
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
static struct PreferenceGenerator * pref_gen_head
Preference Generators.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
struct GNUNET_TIME_Absolute feedback_last
struct GNUNET_SCHEDULER_Task * feedback_task
struct GNUNET_TIME_Relative frequency
#define GNUNET_log(kind,...)
uint32_t assigned_bw_out
static struct TestPeer * find_peer_by_id(int id)
static struct PreferenceGenerator * pref_gen_tail
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
static void set_pref_task(void *cls)
struct GNUNET_TIME_Relative feedback_frequency
double prop_norm[GNUNET_ATS_PropertyCount]
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.

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

Referenced by done().

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)
struct PreferenceGenerator * next
static struct PreferenceGenerator * pref_gen_head
Preference Generators.
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.

References 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().

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
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.

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

Referenced by GNUNET_ATS_solvers_experimentation_load().

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
static struct Experiment * e
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
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.

References GNUNET_ATS_TEST_Operation::address, Experiment::cfg_file, GNUNET_free, GNUNET_free_non_null, 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().

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_non_null (cur_o->address);
1311  GNUNET_free_non_null (cur_o->plugin);
1312  GNUNET_free (cur_o);
1313  }
1314  GNUNET_free (cur);
1315  }
1316 
1321  GNUNET_free (e);
1322 }
struct GNUNET_ATS_TEST_Operation * next
struct Episode * start
struct Episode * next
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
An operation in an experiment.
struct GNUNET_ATS_TEST_Operation * head
#define GNUNET_free(ptr)
Wrapper around free.
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.

References GNUNET_ATS_TEST_Operation::address, GNUNET_ATS_TEST_Operation::address_id, GNUNET_ATS_TEST_Operation::address_network, GNUNET_ATS_TEST_Operation::address_session, 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().

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 }
Local area network.
Definition: gnunet_nt_lib.h:50
long long unsigned int peer_id
int 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.
Wide area network (i.e.
Definition: gnunet_nt_lib.h:55
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
Wireless LAN (i.e.
Definition: gnunet_nt_lib.h:60
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
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:578
long long unsigned int address_id
int 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.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
Loopback (same host).
Definition: gnunet_nt_lib.h:45
#define GNUNET_log(kind,...)
long long unsigned int address_session
#define GNUNET_free(ptr)
Wrapper around free.
Category of last resort.
Definition: gnunet_nt_lib.h:40
Here is the call graph for this function:
Here is the caller graph for this function:

◆ 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.

References GNUNET_ATS_TEST_Operation::address, GNUNET_ATS_TEST_Operation::address_id, GNUNET_ATS_TEST_Operation::address_session, 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().

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 }
long long unsigned int peer_id
int 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.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
long long unsigned int address_id
int 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.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
#define GNUNET_log(kind,...)
long long unsigned int address_session
#define GNUNET_free(ptr)
Wrapper around free.
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 1553 of file gnunet-ats-solver-eval.c.

References GNUNET_ATS_PreferenceTypeString, and props.

Referenced by load_op_start_set_preference(), and load_op_stop_set_preference().

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 }
struct LinkProperty * props
list of link properties
#define GNUNET_ATS_PreferenceTypeString
ATS preference types as string array initializer.
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.

References GNUNET_ATS_TEST_Operation::address_id, GNUNET_ATS_TEST_Operation::base_rate, GNUNET_ATS_TEST_Operation::client_id, Episode::duration, 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, Episode::id, 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().

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 }
int 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.
long long unsigned int peer_id
int 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.
uint64_t rel_value_us
The actual value.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_TIME_Relative period
long long unsigned int client_id
static enum GNUNET_ATS_Property parse_preference_string(const char *str)
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
long long unsigned int base_rate
enum GNUNET_ATS_PreferenceKind pref_type
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
long long unsigned int address_id
const char * GNUNET_ATS_print_preference_type(enum GNUNET_ATS_PreferenceKind type)
Convert a enum GNUNET_ATS_PreferenceType to a string.
struct GNUNET_TIME_Relative duration
int 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.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
#define GNUNET_log(kind,...)
struct GNUNET_TIME_Relative feedback_delay
struct GNUNET_TIME_Relative frequency
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
long long unsigned int max_rate
#define GNUNET_free(ptr)
Wrapper around free.
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.

References GNUNET_ATS_TEST_Operation::address_id, 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, Episode::id, parse_preference_string(), GNUNET_ATS_TEST_Operation::peer_id, and GNUNET_ATS_TEST_Operation::pref_type.

Referenced by load_episode().

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 }
long long unsigned int peer_id
int 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.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static enum GNUNET_ATS_Property parse_preference_string(const char *str)
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
enum GNUNET_ATS_PreferenceKind pref_type
long long unsigned int address_id
const char * GNUNET_ATS_print_preference_type(enum GNUNET_ATS_PreferenceKind type)
Convert a enum GNUNET_ATS_PreferenceType to a string.
int 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.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
#define GNUNET_log(kind,...)
#define GNUNET_free(ptr)
Wrapper around free.
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 1815 of file gnunet-ats-solver-eval.c.

Referenced by load_op_start_set_property(), and load_op_stop_set_property().

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 }
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.

References GNUNET_ATS_TEST_Operation::address_id, GNUNET_ATS_TEST_Operation::base_rate, Episode::duration, 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_free_non_null, GNUNET_log, GNUNET_OK, GNUNET_SYSERR, Episode::id, 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().

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_non_null (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 }
int 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.
long long unsigned int peer_id
int 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.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
struct GNUNET_TIME_Relative period
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
long long unsigned int base_rate
long long unsigned int address_id
struct GNUNET_TIME_Relative duration
int 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.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static enum GNUNET_ATS_Property parse_property_string(const char *str)
#define GNUNET_log(kind,...)
struct GNUNET_TIME_Relative frequency
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
long long unsigned int max_rate
#define GNUNET_free(ptr)
Wrapper around free.
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.

References GNUNET_ATS_TEST_Operation::address_id, GNUNET_asprintf(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_free_non_null, GNUNET_log, GNUNET_OK, GNUNET_SYSERR, Episode::id, parse_property_string(), and GNUNET_ATS_TEST_Operation::peer_id.

Referenced by load_episode().

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_non_null (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_non_null (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 }
long long unsigned int peer_id
int 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.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
long long unsigned int address_id
int 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.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static enum GNUNET_ATS_Property parse_property_string(const char *str)
#define GNUNET_log(kind,...)
#define GNUNET_free(ptr)
Wrapper around free.
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.

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

Referenced by load_episode().

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 }
long long unsigned int peer_id
int 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.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
#define GNUNET_free(ptr)
Wrapper around free.
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.

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

Referenced by load_episode().

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 }
long long unsigned int peer_id
int 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.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
#define GNUNET_free(ptr)
Wrapper around free.
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.

References 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().

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  {
2173  res = load_op_start_set_preference (o, cur,
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_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)
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_new(type)
Allocate a struct or union of the given type.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
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_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_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 res
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)
int 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.
An operation in an experiment.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
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)
struct GNUNET_ATS_TEST_Operation * head
struct GNUNET_ATS_TEST_Operation * tail
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)
#define GNUNET_log(kind,...)
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
#define GNUNET_free(ptr)
Wrapper around free.
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.

References Episode::duration, 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().

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 }
struct Episode * start
int 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 Episode * next
struct GNUNET_TIME_Relative total_duration
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_new(type)
Allocate a struct or union of the given type.
unsigned int num_episodes
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
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:687
struct GNUNET_TIME_Relative duration
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
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:579
#define GNUNET_log(kind,...)
#define GNUNET_YES
Definition: gnunet_common.h:77
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.
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.

References 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().

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 }
GNUNET_ATS_TESTING_ExperimentDoneCallback e_done_cb
static struct Experiment * e
struct GNUNET_SCHEDULER_Task * experiment_timeout_task
struct GNUNET_SCHEDULER_Task * episode_timeout_task
struct GNUNET_TIME_Absolute start_time
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
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:375
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
Here is the call graph for this function:
Here is the caller graph for this function:

◆ 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.

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

Referenced by enforce_add_address().

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 }
uint32_t session_id
Session ID, can never be 0.
struct GNUNET_PeerIdentity peer
Peer ID this address is for.
const void * addr
Address (in plugin-specific binary format).
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
static struct GNUNET_HashCode session_id
char * plugin
Plugin name.
size_t addr_len
Address length, number of bytes in addr.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Address with additional information.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
uint32_t atsi_count
ATS performance information for this address, size of the atsi array.
static char * plugin_name
Name of our plugin.
#define GNUNET_malloc(size)
Wrapper around malloc.
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.

References TestPeer::addr_head, TestPeer::addr_tail, GNUNET_ATS_TEST_Operation::address, GNUNET_ATS_TEST_Operation::address_id, GNUNET_ATS_TEST_Operation::address_network, GNUNET_ATS_TEST_Operation::address_session, SolverHandle::addresses, TestAddress::aid, TestPeer::assigned_bw_in, TestPeer::assigned_bw_out, 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(), TestPeer::id, TestAddress::network, p, TestPeer::peer_id, GNUNET_ATS_TEST_Operation::peer_id, GNUNET_ATS_TEST_Operation::plugin, TestPeer::pref_abs, TestPeer::pref_norm, TestAddress::prop_norm, GNUNET_ATS_SolverFunctions::s_add, and SolverHandle::sf.

Referenced by enforce_episode().

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  {
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));
2362 
2363  for (c = 0; c < GNUNET_ATS_PropertyCount; c++)
2365 
2368 
2370  "Adding address %u for peer %u in network `%s'\n",
2372 
2373  sh->sf->s_add (sh->sf->cls, a->ats_addr, op->address_network);
2374 }
GAS_solver_address_add s_add
Add a new address for a peer to the solver.
long long unsigned int peer_id
const char * GNUNET_NT_to_string(enum GNUNET_NetworkType net)
Convert a enum GNUNET_NetworkType to a string.
Definition: nt.c:44
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
double pref_abs[GNUNET_ATS_PreferenceCount]
#define DEFAULT_REL_QUALITY
Value we return for a normalized quality score if we have no data.
long long unsigned int id
struct GNUNET_PeerIdentity peer_id
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static struct TestPeer * peer_tail
struct TestAddress * addr_tail
struct ATS_Address * ats_addr
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
static struct SolverHandle * sh
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)
long long unsigned int aid
uint32_t assigned_bw_in
long long unsigned int address_id
void * cls
Closure to pass to all solver functions in this struct.
static struct TestPeer * peer_head
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
#define DEFAULT_REL_PREFERENCE
Default relative preference value we assume if we know nothing.
struct GNUNET_ATS_SolverFunctions * sf
Solver handle.
Allow multiple values with the same key.
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.
struct TestAddress * addr_head
#define GNUNET_log(kind,...)
uint32_t assigned_bw_out
static struct TestPeer * find_peer_by_id(int id)
#define DEFAULT_ABS_PREFERENCE
Default preference value we assume if we know nothing.
struct GNUNET_CONTAINER_MultiPeerMap * addresses
Address hashmap.
double prop_norm[GNUNET_ATS_PropertyCount]
long long unsigned int address_session
static struct TestAddress * find_address_by_id(struct TestPeer *peer, int aid)
double pref_norm[GNUNET_ATS_PreferenceCount]
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.

References TestPeer::addr_head, TestPeer::addr_tail, GNUNET_ATS_TEST_Operation::address_id, 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_free_non_null, GNUNET_log, GNUNET_YES, TestPeer::id, p, TestPeer::peer_id, GNUNET_ATS_TEST_Operation::peer_id, GNUNET_ATS_SolverFunctions::s_del, and SolverHandle::sf.

Referenced by enforce_episode().

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  }
2421 
2422  GNUNET_free_non_null (a->ats_addr->atsi);
2423  GNUNET_free (a->ats_addr);
2424  GNUNET_free (a);
2425 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
long long unsigned int peer_id
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
long long unsigned int id
struct GNUNET_PeerIdentity peer_id
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_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
struct TestAddress * addr_tail
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct ATS_Address * ats_addr
static struct LoggingHandle * l
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.
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
void GNUNET_ATS_solver_logging_now(struct LoggingHandle *l)
Logging.
static struct SolverHandle * sh
GAS_solver_address_delete s_del
Delete an address in the solver.
long long unsigned int aid
void GNUNET_ATS_solver_generate_property_stop(struct PropertyGenerator *pg)
long long unsigned int address_id
void * cls
Closure to pass to all solver functions in this struct.
struct GNUNET_ATS_SolverFunctions * sf
Solver handle.
struct TestAddress * addr_head
#define GNUNET_log(kind,...)
static struct TestPeer * find_peer_by_id(int id)
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_CONTAINER_MultiPeerMap * addresses
Address hashmap.
static struct TestAddress * find_address_by_id(struct TestPeer *peer, int aid)
#define GNUNET_free(ptr)
Wrapper around free.
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.

References GNUNET_ATS_TEST_Operation::address_id, GNUNET_ATS_TEST_Operation::base_rate, find_address_by_id(), find_peer_by_id(), find_prop_gen(), GNUNET_ATS_TEST_Operation::frequency, GNUNET_ATS_TEST_Operation::gen_type, GNUNET_ATS_solver_generate_property_start(), GNUNET_ATS_solver_generate_property_stop(), GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_ATS_TEST_Operation::max_rate, p, GNUNET_ATS_TEST_Operation::peer_id, and GNUNET_ATS_TEST_Operation::period.

Referenced by enforce_episode().

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 }
long long unsigned int peer_id
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...
struct GNUNET_TIME_Relative period
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
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.
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
long long unsigned int base_rate
void GNUNET_ATS_solver_generate_property_stop(struct PropertyGenerator *pg)
long long unsigned int address_id
#define GNUNET_log(kind,...)
static struct TestPeer * find_peer_by_id(int id)
struct GNUNET_TIME_Relative frequency
long long unsigned int max_rate
static struct TestAddress * find_address_by_id(struct TestPeer *peer, int aid)
#define GNUNET_free(ptr)
Wrapper around free.
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.

References GNUNET_ATS_TEST_Operation::address_id, find_prop_gen(), GNUNET_ATS_solver_generate_property_stop(), GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, and GNUNET_ATS_TEST_Operation::peer_id.

Referenced by enforce_episode().

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 }
long long unsigned int peer_id
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
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.
void GNUNET_ATS_solver_generate_property_stop(struct PropertyGenerator *pg)
long long unsigned int address_id
#define GNUNET_log(kind,...)
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