summaryrefslogtreecommitdiff
path: root/src/transport/gnunet-service-transport_ats.c
diff options
context:
space:
mode:
authorChristian Grothoff <christian@grothoff.org>2011-08-15 21:46:35 +0000
committerChristian Grothoff <christian@grothoff.org>2011-08-15 21:46:35 +0000
commit502af2167f7c218366666ca4944bd7cc54b5b19a (patch)
treea91fec5cc9769d260640bd91c6633cb9cf395524 /src/transport/gnunet-service-transport_ats.c
parent03af5a603b7cc53432249d5854cd412aa90dde0d (diff)
indentation
Diffstat (limited to 'src/transport/gnunet-service-transport_ats.c')
-rw-r--r--src/transport/gnunet-service-transport_ats.c1826
1 files changed, 911 insertions, 915 deletions
diff --git a/src/transport/gnunet-service-transport_ats.c b/src/transport/gnunet-service-transport_ats.c
index df425bfb0..34d1791b9 100644
--- a/src/transport/gnunet-service-transport_ats.c
+++ b/src/transport/gnunet-service-transport_ats.c
@@ -41,133 +41,136 @@
#ifndef GLP_PROB_DEFINED
#define GLP_PROB_DEFINED
- typedef struct { double _opaque_prob[100]; } glp_prob;
+typedef struct
+{
+ double _opaque_prob[100];
+} glp_prob;
#endif
typedef struct
-{ /* integer optimizer control parameters */
- int msg_lev; /* message level (see glp_smcp) */
- int br_tech; /* branching technique: */
-#define GLP_BR_FFV 1 /* first fractional variable */
-#define GLP_BR_LFV 2 /* last fractional variable */
-#define GLP_BR_MFV 3 /* most fractional variable */
-#define GLP_BR_DTH 4 /* heuristic by Driebeck and Tomlin */
-#define GLP_BR_PCH 5 /* hybrid pseudocost heuristic */
- int bt_tech; /* backtracking technique: */
-#define GLP_BT_DFS 1 /* depth first search */
-#define GLP_BT_BFS 2 /* breadth first search */
-#define GLP_BT_BLB 3 /* best local bound */
-#define GLP_BT_BPH 4 /* best projection heuristic */
- double tol_int; /* mip.tol_int */
- double tol_obj; /* mip.tol_obj */
- int tm_lim; /* mip.tm_lim (milliseconds) */
- int out_frq; /* mip.out_frq (milliseconds) */
- int out_dly; /* mip.out_dly (milliseconds) */
- /* mip.cb_func */
- void *cb_info; /* mip.cb_info */
- int cb_size; /* mip.cb_size */
- int pp_tech; /* preprocessing technique: */
-#define GLP_PP_NONE 0 /* disable preprocessing */
-#define GLP_PP_ROOT 1 /* preprocessing only on root level */
-#define GLP_PP_ALL 2 /* preprocessing on all levels */
- double mip_gap; /* relative MIP gap tolerance */
- int mir_cuts; /* MIR cuts (GLP_ON/GLP_OFF) */
- int gmi_cuts; /* Gomory's cuts (GLP_ON/GLP_OFF) */
- int cov_cuts; /* cover cuts (GLP_ON/GLP_OFF) */
- int clq_cuts; /* clique cuts (GLP_ON/GLP_OFF) */
- int presolve; /* enable/disable using MIP presolver */
- int binarize; /* try to binarize integer variables */
- int fp_heur; /* feasibility pump heuristic */
-#if 1 /* 28/V-2010 */
- int alien; /* use alien solver */
-#endif
- double foo_bar[29]; /* (reserved) */
+{ /* integer optimizer control parameters */
+ int msg_lev; /* message level (see glp_smcp) */
+ int br_tech; /* branching technique: */
+#define GLP_BR_FFV 1 /* first fractional variable */
+#define GLP_BR_LFV 2 /* last fractional variable */
+#define GLP_BR_MFV 3 /* most fractional variable */
+#define GLP_BR_DTH 4 /* heuristic by Driebeck and Tomlin */
+#define GLP_BR_PCH 5 /* hybrid pseudocost heuristic */
+ int bt_tech; /* backtracking technique: */
+#define GLP_BT_DFS 1 /* depth first search */
+#define GLP_BT_BFS 2 /* breadth first search */
+#define GLP_BT_BLB 3 /* best local bound */
+#define GLP_BT_BPH 4 /* best projection heuristic */
+ double tol_int; /* mip.tol_int */
+ double tol_obj; /* mip.tol_obj */
+ int tm_lim; /* mip.tm_lim (milliseconds) */
+ int out_frq; /* mip.out_frq (milliseconds) */
+ int out_dly; /* mip.out_dly (milliseconds) */
+ /* mip.cb_func */
+ void *cb_info; /* mip.cb_info */
+ int cb_size; /* mip.cb_size */
+ int pp_tech; /* preprocessing technique: */
+#define GLP_PP_NONE 0 /* disable preprocessing */
+#define GLP_PP_ROOT 1 /* preprocessing only on root level */
+#define GLP_PP_ALL 2 /* preprocessing on all levels */
+ double mip_gap; /* relative MIP gap tolerance */
+ int mir_cuts; /* MIR cuts (GLP_ON/GLP_OFF) */
+ int gmi_cuts; /* Gomory's cuts (GLP_ON/GLP_OFF) */
+ int cov_cuts; /* cover cuts (GLP_ON/GLP_OFF) */
+ int clq_cuts; /* clique cuts (GLP_ON/GLP_OFF) */
+ int presolve; /* enable/disable using MIP presolver */
+ int binarize; /* try to binarize integer variables */
+ int fp_heur; /* feasibility pump heuristic */
+#if 1 /* 28/V-2010 */
+ int alien; /* use alien solver */
+#endif
+ double foo_bar[29]; /* (reserved) */
} glp_iocp;
typedef struct
-{ /* simplex method control parameters */
- int msg_lev; /* message level: */
-#define GLP_MSG_OFF 0 /* no output */
-#define GLP_MSG_ERR 1 /* warning and error messages only */
-#define GLP_MSG_ON 2 /* normal output */
-#define GLP_MSG_ALL 3 /* full output */
-#define GLP_MSG_DBG 4 /* debug output */
- int meth; /* simplex method option: */
-#define GLP_PRIMAL 1 /* use primal simplex */
-#define GLP_DUALP 2 /* use dual; if it fails, use primal */
-#define GLP_DUAL 3 /* use dual simplex */
- int pricing; /* pricing technique: */
-#define GLP_PT_STD 0x11 /* standard (Dantzig rule) */
-#define GLP_PT_PSE 0x22 /* projected steepest edge */
- int r_test; /* ratio test technique: */
-#define GLP_RT_STD 0x11 /* standard (textbook) */
-#define GLP_RT_HAR 0x22 /* two-pass Harris' ratio test */
- double tol_bnd; /* spx.tol_bnd */
- double tol_dj; /* spx.tol_dj */
- double tol_piv; /* spx.tol_piv */
- double obj_ll; /* spx.obj_ll */
- double obj_ul; /* spx.obj_ul */
- int it_lim; /* spx.it_lim */
- int tm_lim; /* spx.tm_lim (milliseconds) */
- int out_frq; /* spx.out_frq */
- int out_dly; /* spx.out_dly (milliseconds) */
- int presolve; /* enable/disable using LP presolver */
- double foo_bar[36]; /* (reserved) */
+{ /* simplex method control parameters */
+ int msg_lev; /* message level: */
+#define GLP_MSG_OFF 0 /* no output */
+#define GLP_MSG_ERR 1 /* warning and error messages only */
+#define GLP_MSG_ON 2 /* normal output */
+#define GLP_MSG_ALL 3 /* full output */
+#define GLP_MSG_DBG 4 /* debug output */
+ int meth; /* simplex method option: */
+#define GLP_PRIMAL 1 /* use primal simplex */
+#define GLP_DUALP 2 /* use dual; if it fails, use primal */
+#define GLP_DUAL 3 /* use dual simplex */
+ int pricing; /* pricing technique: */
+#define GLP_PT_STD 0x11 /* standard (Dantzig rule) */
+#define GLP_PT_PSE 0x22 /* projected steepest edge */
+ int r_test; /* ratio test technique: */
+#define GLP_RT_STD 0x11 /* standard (textbook) */
+#define GLP_RT_HAR 0x22 /* two-pass Harris' ratio test */
+ double tol_bnd; /* spx.tol_bnd */
+ double tol_dj; /* spx.tol_dj */
+ double tol_piv; /* spx.tol_piv */
+ double obj_ll; /* spx.obj_ll */
+ double obj_ul; /* spx.obj_ul */
+ int it_lim; /* spx.it_lim */
+ int tm_lim; /* spx.tm_lim (milliseconds) */
+ int out_frq; /* spx.out_frq */
+ int out_dly; /* spx.out_dly (milliseconds) */
+ int presolve; /* enable/disable using LP presolver */
+ double foo_bar[36]; /* (reserved) */
} glp_smcp;
/* optimization direction flag: */
-#define GLP_MIN 1 /* minimization */
-#define GLP_MAX 2 /* maximization */
+#define GLP_MIN 1 /* minimization */
+#define GLP_MAX 2 /* maximization */
/* kind of structural variable: */
-#define GLP_CV 1 /* continuous variable */
-#define GLP_IV 2 /* integer variable */
-#define GLP_BV 3 /* binary variable */
+#define GLP_CV 1 /* continuous variable */
+#define GLP_IV 2 /* integer variable */
+#define GLP_BV 3 /* binary variable */
/* type of auxiliary/structural variable: */
-#define GLP_FR 1 /* free variable */
-#define GLP_LO 2 /* variable with lower bound */
-#define GLP_UP 3 /* variable with upper bound */
-#define GLP_DB 4 /* double-bounded variable */
-#define GLP_FX 5 /* fixed variable */
+#define GLP_FR 1 /* free variable */
+#define GLP_LO 2 /* variable with lower bound */
+#define GLP_UP 3 /* variable with upper bound */
+#define GLP_DB 4 /* double-bounded variable */
+#define GLP_FX 5 /* fixed variable */
/* solution indicator: */
-#define GLP_SOL 1 /* basic solution */
-#define GLP_IPT 2 /* interior-point solution */
-#define GLP_MIP 3 /* mixed integer solution */
+#define GLP_SOL 1 /* basic solution */
+#define GLP_IPT 2 /* interior-point solution */
+#define GLP_MIP 3 /* mixed integer solution */
/* solution status: */
-#define GLP_UNDEF 1 /* solution is undefined */
-#define GLP_FEAS 2 /* solution is feasible */
-#define GLP_INFEAS 3 /* solution is infeasible */
-#define GLP_NOFEAS 4 /* no feasible solution exists */
-#define GLP_OPT 5 /* solution is optimal */
-#define GLP_UNBND 6 /* solution is unbounded */
+#define GLP_UNDEF 1 /* solution is undefined */
+#define GLP_FEAS 2 /* solution is feasible */
+#define GLP_INFEAS 3 /* solution is infeasible */
+#define GLP_NOFEAS 4 /* no feasible solution exists */
+#define GLP_OPT 5 /* solution is optimal */
+#define GLP_UNBND 6 /* solution is unbounded */
/* return codes: */
-#define GLP_EBADB 0x01 /* invalid basis */
-#define GLP_ESING 0x02 /* singular matrix */
-#define GLP_ECOND 0x03 /* ill-conditioned matrix */
-#define GLP_EBOUND 0x04 /* invalid bounds */
-#define GLP_EFAIL 0x05 /* solver failed */
-#define GLP_EOBJLL 0x06 /* objective lower limit reached */
-#define GLP_EOBJUL 0x07 /* objective upper limit reached */
-#define GLP_EITLIM 0x08 /* iteration limit exceeded */
-#define GLP_ETMLIM 0x09 /* time limit exceeded */
-#define GLP_ENOPFS 0x0A /* no primal feasible solution */
-#define GLP_ENODFS 0x0B /* no dual feasible solution */
-#define GLP_EROOT 0x0C /* root LP optimum not provided */
-#define GLP_ESTOP 0x0D /* search terminated by application */
-#define GLP_EMIPGAP 0x0E /* relative mip gap tolerance reached */
-#define GLP_ENOFEAS 0x0F /* no primal/dual feasible solution */
-#define GLP_ENOCVG 0x10 /* no convergence */
-#define GLP_EINSTAB 0x11 /* numerical instability */
-#define GLP_EDATA 0x12 /* invalid data */
-#define GLP_ERANGE 0x13 /* result out of range */
+#define GLP_EBADB 0x01 /* invalid basis */
+#define GLP_ESING 0x02 /* singular matrix */
+#define GLP_ECOND 0x03 /* ill-conditioned matrix */
+#define GLP_EBOUND 0x04 /* invalid bounds */
+#define GLP_EFAIL 0x05 /* solver failed */
+#define GLP_EOBJLL 0x06 /* objective lower limit reached */
+#define GLP_EOBJUL 0x07 /* objective upper limit reached */
+#define GLP_EITLIM 0x08 /* iteration limit exceeded */
+#define GLP_ETMLIM 0x09 /* time limit exceeded */
+#define GLP_ENOPFS 0x0A /* no primal feasible solution */
+#define GLP_ENODFS 0x0B /* no dual feasible solution */
+#define GLP_EROOT 0x0C /* root LP optimum not provided */
+#define GLP_ESTOP 0x0D /* search terminated by application */
+#define GLP_EMIPGAP 0x0E /* relative mip gap tolerance reached */
+#define GLP_ENOFEAS 0x0F /* no primal/dual feasible solution */
+#define GLP_ENOCVG 0x10 /* no convergence */
+#define GLP_EINSTAB 0x11 /* numerical instability */
+#define GLP_EDATA 0x12 /* invalid data */
+#define GLP_ERANGE 0x13 /* result out of range */
/* enable/disable flag: */
-#define GLP_ON 1 /* enable something */
-#define GLP_OFF 0 /* disable something */
+#define GLP_ON 1 /* enable something */
+#define GLP_OFF 0 /* disable something */
#endif
@@ -176,10 +179,11 @@ typedef struct
*/
-void * _lp_create_prob ( void )
+void *
+_lp_create_prob (void)
{
#if HAVE_LIBGLPK
- return glp_create_prob( );
+ return glp_create_prob ();
#else
// Function not implemented
GNUNET_break (0);
@@ -187,7 +191,8 @@ void * _lp_create_prob ( void )
return NULL;
}
-void _lp_set_obj_dir (glp_prob *P, int dir)
+void
+_lp_set_obj_dir (glp_prob *P, int dir)
{
#if HAVE_LIBGLPK
return glp_set_obj_dir (P, dir);
@@ -197,20 +202,22 @@ void _lp_set_obj_dir (glp_prob *P, int dir)
#endif
}
-void _lp_set_prob_name (glp_prob *P, const char *name)
+void
+_lp_set_prob_name (glp_prob *P, const char *name)
{
#if HAVE_LIBGLPK
- glp_set_prob_name(P, name);
+ glp_set_prob_name (P, name);
#else
// Function not implemented
GNUNET_break (0);
#endif
}
-int _lp_add_cols (glp_prob *P, int ncs)
+int
+_lp_add_cols (glp_prob *P, int ncs)
{
#if HAVE_LIBGLPK
- return glp_add_cols(P, ncs);
+ return glp_add_cols (P, ncs);
#else
// Function not implemented
GNUNET_break (0);
@@ -218,7 +225,8 @@ int _lp_add_cols (glp_prob *P, int ncs)
return 0;
}
-int _lp_add_rows (glp_prob *P, int nrs)
+int
+_lp_add_rows (glp_prob *P, int nrs)
{
#if HAVE_LIBGLPK
return glp_add_rows (P, nrs);
@@ -230,27 +238,30 @@ int _lp_add_rows (glp_prob *P, int nrs)
}
-void _lp_set_row_bnds (glp_prob *P, int i, int type, double lb, double ub)
+void
+_lp_set_row_bnds (glp_prob *P, int i, int type, double lb, double ub)
{
#if HAVE_LIBGLPK
- glp_set_row_bnds(P, i , type, lb, ub);
+ glp_set_row_bnds (P, i, type, lb, ub);
#else
// Function not implemented
GNUNET_break (0);
#endif
}
-void _lp_init_smcp (void * parm)
+void
+_lp_init_smcp (void *parm)
{
#if HAVE_LIBGLPK
- glp_init_smcp(parm);
+ glp_init_smcp (parm);
#else
// Function not implemented
GNUNET_break (0);
#endif
}
-void _lp_set_col_name (glp_prob *P, int j, const char *name)
+void
+_lp_set_col_name (glp_prob *P, int j, const char *name)
{
#if HAVE_LIBGLPK
glp_set_col_name (P, j, name);
@@ -260,28 +271,30 @@ void _lp_set_col_name (glp_prob *P, int j, const char *name)
#endif
}
-void _lp_set_col_bnds (glp_prob *P, int j, int type, double lb,
- double ub)
+void
+_lp_set_col_bnds (glp_prob *P, int j, int type, double lb, double ub)
{
#if HAVE_LIBGLPK
- glp_set_col_bnds(P, j, type, lb, ub);
+ glp_set_col_bnds (P, j, type, lb, ub);
#else
// Function not implemented
GNUNET_break (0);
#endif
}
-void _lp_set_obj_coef(glp_prob *P, int j, double coef)
+void
+_lp_set_obj_coef (glp_prob *P, int j, double coef)
{
#if HAVE_LIBGLPK
- glp_set_obj_coef(P, j, coef);
+ glp_set_obj_coef (P, j, coef);
#else
// Function not implemented
GNUNET_break (0);
#endif
}
-void _lp_delete_prob (void * P)
+void
+_lp_delete_prob (void *P)
{
#if HAVE_LIBGLPK
glp_delete_prob (P);
@@ -291,7 +304,8 @@ void _lp_delete_prob (void * P)
#endif
}
-static int _lp_simplex(glp_prob *P, void *parm)
+static int
+_lp_simplex (glp_prob *P, void *parm)
{
#if HAVE_LIBGLPK
return glp_simplex (P, parm);
@@ -302,19 +316,21 @@ static int _lp_simplex(glp_prob *P, void *parm)
return 0;
}
-static void _lp_load_matrix (glp_prob *P, int ne, const int ia[],
- const int ja[], const double ar[])
+static void
+_lp_load_matrix (glp_prob *P, int ne, const int ia[],
+ const int ja[], const double ar[])
{
#if HAVE_LIBGLPK
- glp_load_matrix(P, ne, ia, ja, ar);
+ glp_load_matrix (P, ne, ia, ja, ar);
#else
// Function not implemented
GNUNET_break (0);
#endif
}
-static void _lp_set_mat_row (glp_prob *P, int i, int len, const int ind[],
- const double val[])
+static void
+_lp_set_mat_row (glp_prob *P, int i, int len, const int ind[],
+ const double val[])
{
#if HAVE_LIBGLPK
glp_set_mat_row (P, i, len, ind, val);
@@ -324,10 +340,11 @@ static void _lp_set_mat_row (glp_prob *P, int i, int len, const int ind[],
#endif
}
-static int _lp_write_lp (glp_prob *P, const void *parm, const char *fname)
+static int
+_lp_write_lp (glp_prob *P, const void *parm, const char *fname)
{
#if HAVE_LIBGLPK
- return glp_write_lp ( P, parm, fname);
+ return glp_write_lp (P, parm, fname);
#else
// Function not implemented
GNUNET_break (0);
@@ -335,7 +352,8 @@ static int _lp_write_lp (glp_prob *P, const void *parm, const char *fname)
return 0;
}
-static void _lp_init_iocp (void *parm)
+static void
+_lp_init_iocp (void *parm)
{
#if HAVE_LIBGLPK
glp_init_iocp (parm);
@@ -345,7 +363,8 @@ static void _lp_init_iocp (void *parm)
#endif
}
-static int _lp_intopt (glp_prob *P, const void *parm)
+static int
+_lp_intopt (glp_prob *P, const void *parm)
{
#if HAVE_LIBGLPK
return glp_intopt (P, parm);
@@ -356,7 +375,8 @@ static int _lp_intopt (glp_prob *P, const void *parm)
return 0;
}
-static int _lp_get_status (glp_prob *P)
+static int
+_lp_get_status (glp_prob *P)
{
#if HAVE_LIBGLPK
return glp_get_status (P);
@@ -367,7 +387,8 @@ static int _lp_get_status (glp_prob *P)
return 0;
}
-static int _lp_mip_status (glp_prob *P)
+static int
+_lp_mip_status (glp_prob *P)
{
#if HAVE_LIBGLPK
return glp_mip_status (P);
@@ -378,7 +399,8 @@ static int _lp_mip_status (glp_prob *P)
return 0;
}
-static void _lp_set_col_kind (glp_prob *P, int j, int kind)
+static void
+_lp_set_col_kind (glp_prob *P, int j, int kind)
{
#if HAVE_LIBGLPK
glp_set_col_kind (P, j, kind);
@@ -388,7 +410,8 @@ static void _lp_set_col_kind (glp_prob *P, int j, int kind)
#endif
}
-static void _lp_free_env (void)
+static void
+_lp_free_env (void)
{
#if HAVE_LIBGLPK
glp_free_env ();
@@ -398,7 +421,8 @@ static void _lp_free_env (void)
#endif
}
-static const char * _lp_get_col_name ( glp_prob *P, int j)
+static const char *
+_lp_get_col_name (glp_prob *P, int j)
{
#if HAVE_LIBGLPK
return glp_get_col_name (P, j);
@@ -409,7 +433,8 @@ static const char * _lp_get_col_name ( glp_prob *P, int j)
return NULL;
}
-static double _lp_mip_obj_val (glp_prob *P)
+static double
+_lp_mip_obj_val (glp_prob *P)
{
#if HAVE_LIBGLPK
return glp_mip_obj_val (P);
@@ -421,10 +446,11 @@ static double _lp_mip_obj_val (glp_prob *P)
}
-static double _lp_get_col_prim (glp_prob *P, int j)
+static double
+_lp_get_col_prim (glp_prob *P, int j)
{
#if HAVE_LIBGLPK
- return glp_get_col_prim (P , j);
+ return glp_get_col_prim (P, j);
#else
// Function not implemented
GNUNET_break (0);
@@ -432,7 +458,8 @@ static double _lp_get_col_prim (glp_prob *P, int j)
return 0.0;
}
-static int _lp_print_sol(glp_prob *P, const char *fname)
+static int
+_lp_print_sol (glp_prob *P, const char *fname)
{
#if HAVE_LIBGLPK
#else
@@ -447,24 +474,27 @@ static int _lp_print_sol(glp_prob *P, const char *fname)
*/
static void _dummy2 ();
-static void _dummy ()
+static void
+_dummy ()
{
return;
_lp_get_col_name (NULL, 0);
_lp_mip_obj_val (NULL);
_lp_get_col_prim (NULL, 0);
- _lp_set_mat_row(NULL,0,0,NULL,NULL);
- _dummy2();
+ _lp_set_mat_row (NULL, 0, 0, NULL, NULL);
+ _dummy2 ();
}
-static void _dummy2 ()
+static void
+_dummy2 ()
{
ats_modify_problem_state (NULL, 0);
qm[1].atis_index = 0;
- _dummy();
+ _dummy ();
int t = ATS_COST_UPDATED + ATS_MODIFIED + ATS_NEW;
+
t++;
}
@@ -479,19 +509,20 @@ static void _dummy2 ()
* @return
*/
-struct ATS_Handle * ats_init (double D,
- double U,
- double R,
- int v_b_min,
- int v_n_min,
- int max_iterations,
- struct GNUNET_TIME_Relative max_duration,
- GNUNET_TRANSPORT_ATS_AddressNotification address_not,
- GNUNET_TRANSPORT_ATS_ResultCallback res_cb)
+struct ATS_Handle *
+ats_init (double D,
+ double U,
+ double R,
+ int v_b_min,
+ int v_n_min,
+ int max_iterations,
+ struct GNUNET_TIME_Relative max_duration,
+ GNUNET_TRANSPORT_ATS_AddressNotification address_not,
+ GNUNET_TRANSPORT_ATS_ResultCallback res_cb)
{
- struct ATS_Handle * ats = NULL;
+ struct ATS_Handle *ats = NULL;
- ats = GNUNET_malloc(sizeof (struct ATS_Handle));
+ ats = GNUNET_malloc (sizeof (struct ATS_Handle));
ats->prob = NULL;
@@ -507,7 +538,7 @@ struct ATS_Handle * ats_init (double D,
ats->v_b_min = v_b_min;
ats->v_n_min = v_n_min;
ats->dump_min_peers = 0;
- ats->dump_min_addr = 0;
+ ats->dump_min_addr = 0;
ats->dump_overwrite = GNUNET_NO;
ats->mechanisms = NULL;
ats->peers = NULL;
@@ -529,181 +560,165 @@ struct ATS_Handle * ats_init (double D,
* @param stat result struct
* @return GNUNET_SYSERR if glpk is not available, number of mechanisms used
*/
-int ats_create_problem (struct ATS_Handle *ats,
- struct ATS_internals *stat,
- struct ATS_peer *peers,
- int c_p,
- struct ATS_mechanism *mechanisms,
- int c_m)
+int
+ats_create_problem (struct ATS_Handle *ats,
+ struct ATS_internals *stat,
+ struct ATS_peer *peers,
+ int c_p, struct ATS_mechanism *mechanisms, int c_m)
{
if ((c_p == 0) || (c_m == 0))
return GNUNET_SYSERR;
- ats->prob = _lp_create_prob();
+ ats->prob = _lp_create_prob ();
int c;
int c_c_ressources = available_ressources;
int c_q_metrics = available_quality_metrics;
double M = VERY_BIG_DOUBLE_VALUE;
- double Q[c_q_metrics+1];
- for (c=1; c<=c_q_metrics; c++)
+ double Q[c_q_metrics + 1];
+
+ for (c = 1; c <= c_q_metrics; c++)
{
- Q[c] = 1;
+ Q[c] = 1;
}
if (ats->v_n_min > c_p)
- ats->v_n_min = c_p;
+ ats->v_n_min = c_p;
#if VERBOSE_ATS
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Creating problem with: %i peers, %i mechanisms, %i resource entries, %i quality metrics \n",
- c_p,
- c_m,
- c_c_ressources,
- c_q_metrics);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Creating problem with: %i peers, %i mechanisms, %i resource entries, %i quality metrics \n",
+ c_p, c_m, c_c_ressources, c_q_metrics);
#endif
- int size = 1 + 3 + 10 *c_m + c_p +
- (c_q_metrics*c_m)+ c_q_metrics + c_c_ressources * c_m ;
+ int size = 1 + 3 + 10 * c_m + c_p +
+ (c_q_metrics * c_m) + c_q_metrics + c_c_ressources * c_m;
int row_index;
- int array_index=1;
- int * ia = GNUNET_malloc (size * sizeof (int));
- int * ja = GNUNET_malloc (size * sizeof (int));
- double * ar = GNUNET_malloc(size* sizeof (double));
+ int array_index = 1;
+ int *ia = GNUNET_malloc (size * sizeof (int));
+ int *ja = GNUNET_malloc (size * sizeof (int));
+ double *ar = GNUNET_malloc (size * sizeof (double));
_lp_set_prob_name (ats->prob, "gnunet ats bandwidth distribution");
- _lp_set_obj_dir(ats->prob, GLP_MAX);
+ _lp_set_obj_dir (ats->prob, GLP_MAX);
/* adding columns */
- char * name;
- _lp_add_cols(ats->prob, 2 * c_m);
+ char *name;
+
+ _lp_add_cols (ats->prob, 2 * c_m);
/* adding b_t cols */
- for (c=1; c <= c_m; c++)
+ for (c = 1; c <= c_m; c++)
{
- GNUNET_asprintf(&name,
- "p_%s_b%i",GNUNET_i2s(&(mechanisms[c].peer->peer)), c);
- _lp_set_col_name(ats->prob, c, name);
+ GNUNET_asprintf (&name,
+ "p_%s_b%i", GNUNET_i2s (&(mechanisms[c].peer->peer)), c);
+ _lp_set_col_name (ats->prob, c, name);
GNUNET_free (name);
- _lp_set_col_bnds(ats->prob, c, GLP_LO, 0.0, 0.0);
- _lp_set_col_kind(ats->prob, c, GLP_CV);
- _lp_set_obj_coef(ats->prob, c, 0);
+ _lp_set_col_bnds (ats->prob, c, GLP_LO, 0.0, 0.0);
+ _lp_set_col_kind (ats->prob, c, GLP_CV);
+ _lp_set_obj_coef (ats->prob, c, 0);
}
/* adding n_t cols */
- for (c=c_m+1; c <= 2*c_m; c++)
+ for (c = c_m + 1; c <= 2 * c_m; c++)
{
- GNUNET_asprintf(&name,
- "p_%s_n%i",GNUNET_i2s(&(mechanisms[c-c_m].peer->peer)),(c-c_m));
- _lp_set_col_name(ats->prob, c, name);
+ GNUNET_asprintf (&name,
+ "p_%s_n%i", GNUNET_i2s (&(mechanisms[c - c_m].peer->peer)),
+ (c - c_m));
+ _lp_set_col_name (ats->prob, c, name);
GNUNET_free (name);
- _lp_set_col_bnds(ats->prob, c, GLP_DB, 0.0, 1.0);
- _lp_set_col_kind(ats->prob, c, GLP_IV);
- _lp_set_obj_coef(ats->prob, c, 0);
+ _lp_set_col_bnds (ats->prob, c, GLP_DB, 0.0, 1.0);
+ _lp_set_col_kind (ats->prob, c, GLP_IV);
+ _lp_set_obj_coef (ats->prob, c, 0);
}
/* feasibility constraints */
- /* Constraint 1: one address per peer*/
+ /* Constraint 1: one address per peer */
row_index = 1;
- _lp_add_rows(ats->prob, c_p);
+ _lp_add_rows (ats->prob, c_p);
- for (c=1; c<=c_p; c++)
+ for (c = 1; c <= c_p; c++)
{
#if VERBOSE_ATS
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",
- row_index);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n", row_index);
#endif
- _lp_set_row_bnds(ats->prob, row_index, GLP_FX, 1.0, 1.0);
- struct ATS_mechanism *m = peers[c].m_head;
- while (m!=NULL)
- {
- ia[array_index] = row_index;
- ja[array_index] = (c_m + m->col_index);
- ar[array_index] = 1;
+ _lp_set_row_bnds (ats->prob, row_index, GLP_FX, 1.0, 1.0);
+ struct ATS_mechanism *m = peers[c].m_head;
+
+ while (m != NULL)
+ {
+ ia[array_index] = row_index;
+ ja[array_index] = (c_m + m->col_index);
+ ar[array_index] = 1;
#if VERBOSE_ATS
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
- array_index,
- ia[array_index],
- ja[array_index],
- ar[array_index]);
-#endif
- array_index++;
- m = m->next;
- }
- row_index++;
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
+ array_index,
+ ia[array_index], ja[array_index], ar[array_index]);
+#endif
+ array_index++;
+ m = m->next;
+ }
+ row_index++;
}
/* Constraint 2: only active mechanism gets bandwidth assigned */
- _lp_add_rows(ats->prob, c_m);
- for (c=1; c<=c_m; c++)
+ _lp_add_rows (ats->prob, c_m);
+ for (c = 1; c <= c_m; c++)
{
- /* b_t - n_t * M <= 0 */
+ /* b_t - n_t * M <= 0 */
#if VERBOSE_ATS
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",
- row_index);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n", row_index);
#endif
- _lp_set_row_bnds(ats->prob, row_index, GLP_UP, 0.0, 0.0);
- ia[array_index] = row_index;
- ja[array_index] = mechanisms[c].col_index;
- ar[array_index] = 1;
+ _lp_set_row_bnds (ats->prob, row_index, GLP_UP, 0.0, 0.0);
+ ia[array_index] = row_index;
+ ja[array_index] = mechanisms[c].col_index;
+ ar[array_index] = 1;
#if VERBOSE_ATS
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
- array_index,
- ia[array_index],
- ja[array_index],
- ar[array_index]);
-#endif
- array_index++;
- ia[array_index] = row_index;
- ja[array_index] = c_m + mechanisms[c].col_index;
- ar[array_index] = -M;
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
+ array_index, ia[array_index], ja[array_index], ar[array_index]);
+#endif
+ array_index++;
+ ia[array_index] = row_index;
+ ja[array_index] = c_m + mechanisms[c].col_index;
+ ar[array_index] = -M;
#if VERBOSE_ATS
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
- array_index,
- ia[array_index],
- ja[array_index],
- ar[array_index]);
-#endif
- array_index++;
- row_index ++;
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
+ array_index, ia[array_index], ja[array_index], ar[array_index]);
+#endif
+ array_index++;
+ row_index++;
}
- /* Constraint 3: minimum bandwidth*/
- _lp_add_rows(ats->prob, c_m);
+ /* Constraint 3: minimum bandwidth */
+ _lp_add_rows (ats->prob, c_m);
- for (c=1; c<=c_m; c++)
+ for (c = 1; c <= c_m; c++)
{
- /* b_t - n_t * b_min <= 0 */
+ /* b_t - n_t * b_min <= 0 */
#if VERBOSE_ATS
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",
- row_index);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n", row_index);
#endif
#if HAVE_LIBGLPK
- _lp_set_row_bnds(ats->prob, row_index, GLP_LO, 0.0, 0.0);
+ _lp_set_row_bnds (ats->prob, row_index, GLP_LO, 0.0, 0.0);
#endif
- ia[array_index] = row_index;
- ja[array_index] = mechanisms[c].col_index;
- ar[array_index] = 1;
+ ia[array_index] = row_index;
+ ja[array_index] = mechanisms[c].col_index;
+ ar[array_index] = 1;
#if VERBOSE_ATS
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
- array_index,
- ia[array_index],
- ja[array_index],
- ar[array_index]);
-#endif
- array_index++;
- ia[array_index] = row_index;
- ja[array_index] = c_m + mechanisms[c].col_index;
- ar[array_index] = -ats->v_b_min;
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
+ array_index, ia[array_index], ja[array_index], ar[array_index]);
+#endif
+ array_index++;
+ ia[array_index] = row_index;
+ ja[array_index] = c_m + mechanisms[c].col_index;
+ ar[array_index] = -ats->v_b_min;
#if VERBOSE_ATS
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
- array_index,
- ia[array_index],
- ja[array_index],
- ar[array_index]);
-#endif
- array_index++;
- row_index ++;
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
+ array_index, ia[array_index], ja[array_index], ar[array_index]);
+#endif
+ array_index++;
+ row_index++;
}
int c2;
@@ -711,69 +726,63 @@ int ats_create_problem (struct ATS_Handle *ats,
/* V cr: bt * ct_r <= cr_max
* */
- _lp_add_rows(ats->prob, available_ressources);
+ _lp_add_rows (ats->prob, available_ressources);
double ct_max = VERY_BIG_DOUBLE_VALUE;
double ct_min = 0.0;
stat->begin_cr = array_index;
- for (c=0; c<available_ressources; c++)
+ for (c = 0; c < available_ressources; c++)
{
- ct_max = ressources[c].c_max;
- ct_min = ressources[c].c_min;
+ ct_max = ressources[c].c_max;
+ ct_min = ressources[c].c_min;
#if VERBOSE_ATS
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] %f..%f\n",
- row_index,
- ct_min,
- ct_max);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] %f..%f\n",
+ row_index, ct_min, ct_max);
#endif
#if HAVE_LIBGLPK
- _lp_set_row_bnds(ats->prob, row_index, GLP_DB, ct_min, ct_max);
+ _lp_set_row_bnds (ats->prob, row_index, GLP_DB, ct_min, ct_max);
#endif
- for (c2=1; c2<=c_m; c2++)
- {
- double value = 0;
- ia[array_index] = row_index;
- ja[array_index] = c2;
- value = mechanisms[c2].ressources[c].c;
- ar[array_index] = value;
+ for (c2 = 1; c2 <= c_m; c2++)
+ {
+ double value = 0;
+
+ ia[array_index] = row_index;
+ ja[array_index] = c2;
+ value = mechanisms[c2].ressources[c].c;
+ ar[array_index] = value;
#if VERBOSE_ATS
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
- array_index, ia[array_index],
- ja[array_index],
- ar[array_index]);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
+ array_index, ia[array_index],
+ ja[array_index], ar[array_index]);
#endif
- array_index++;
- }
- row_index ++;
+ array_index++;
+ }
+ row_index++;
}
stat->end_cr = array_index--;
- /* Constraint 5: min number of connections*/
- _lp_add_rows(ats->prob, 1);
+ /* Constraint 5: min number of connections */
+ _lp_add_rows (ats->prob, 1);
- for (c=1; c<=c_m; c++)
+ for (c = 1; c <= c_m; c++)
{
- // b_t - n_t * b_min >= 0
+ // b_t - n_t * b_min >= 0
#if VERBOSE_ATS
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",
- row_index);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n", row_index);
#endif
- _lp_set_row_bnds(ats->prob, row_index, GLP_LO, ats->v_n_min, 0.0);
- ia[array_index] = row_index;
- ja[array_index] = c_m + mechanisms[c].col_index;
- ar[array_index] = 1;
+ _lp_set_row_bnds (ats->prob, row_index, GLP_LO, ats->v_n_min, 0.0);
+ ia[array_index] = row_index;
+ ja[array_index] = c_m + mechanisms[c].col_index;
+ ar[array_index] = 1;
#if VERBOSE_ATS
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
- array_index,
- ia[array_index],
- ja[array_index],
- ar[array_index]);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
+ array_index, ia[array_index], ja[array_index], ar[array_index]);
#endif
- array_index++;
+ array_index++;
}
- row_index ++;
+ row_index++;
// optimisation constraints
@@ -781,29 +790,27 @@ int ats_create_problem (struct ATS_Handle *ats,
// Constraint 6: optimize for diversity
int col_d;
- col_d = _lp_add_cols(ats->prob, 1);
- _lp_set_col_name(ats->prob, col_d, "d");
- _lp_set_obj_coef(ats->prob, col_d, ats->D);
- _lp_set_col_bnds(ats->prob, col_d, GLP_LO, 0.0, 0.0);
- _lp_add_rows(ats->prob, 1);
- _lp_set_row_bnds(ats->prob, row_index, GLP_FX, 0.0, 0.0);
+ col_d = _lp_add_cols (ats->prob, 1);
+
+ _lp_set_col_name (ats->prob, col_d, "d");
+ _lp_set_obj_coef (ats->prob, col_d, ats->D);
+ _lp_set_col_bnds (ats->prob, col_d, GLP_LO, 0.0, 0.0);
+ _lp_add_rows (ats->prob, 1);
+ _lp_set_row_bnds (ats->prob, row_index, GLP_FX, 0.0, 0.0);
stat->col_d = col_d;
#if VERBOSE_ATS
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",row_index);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n", row_index);
#endif
- for (c=1; c<=c_m; c++)
+ for (c = 1; c <= c_m; c++)
{
ia[array_index] = row_index;
ja[array_index] = c_m + mechanisms[c].col_index;
ar[array_index] = 1;
#if VERBOSE_ATS
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
- array_index,
- ia[array_index],
- ja[array_index],
- ar[array_index]);
+ array_index, ia[array_index], ja[array_index], ar[array_index]);
#endif
array_index++;
}
@@ -812,122 +819,120 @@ int ats_create_problem (struct ATS_Handle *ats,
ar[array_index] = -1;
#if VERBOSE_ATS
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
- array_index,
- ia[array_index],
- ja[array_index],
- ar[array_index]);
+ array_index, ia[array_index], ja[array_index], ar[array_index]);
#endif
array_index++;
- row_index ++;
+ row_index++;
// Constraint 7: optimize for quality
int col_qm;
- col_qm = _lp_add_cols(ats->prob, c_q_metrics);
+
+ col_qm = _lp_add_cols (ats->prob, c_q_metrics);
stat->col_qm = col_qm;
//GNUNET_assert (col_qm == (2*c_mechs) + 3 + 1);
- for (c=0; c< c_q_metrics; c++)
+ for (c = 0; c < c_q_metrics; c++)
{
- GNUNET_asprintf(&name, "Q_%s",qm[c].name);
+ GNUNET_asprintf (&name, "Q_%s", qm[c].name);
_lp_set_col_name (ats->prob, col_qm + c, name);
_lp_set_col_bnds (ats->prob, col_qm + c, GLP_LO, 0.0, 0.0);
GNUNET_free (name);
_lp_set_obj_coef (ats->prob, col_qm + c, Q[c]);
}
- _lp_add_rows(ats->prob, available_quality_metrics);
+ _lp_add_rows (ats->prob, available_quality_metrics);
stat->begin_qm = row_index;
- for (c=1; c <= c_q_metrics; c++)
+ for (c = 1; c <= c_q_metrics; c++)
{
#if VERBOSE_ATS
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",
- row_index);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n", row_index);
#endif
- double value = 1;
- _lp_set_row_bnds(ats->prob, row_index, GLP_FX, 0.0, 0.0);
- for (c2=1; c2<=c_m; c2++)
+ double value = 1;
+
+ _lp_set_row_bnds (ats->prob, row_index, GLP_FX, 0.0, 0.0);
+ for (c2 = 1; c2 <= c_m; c2++)
+ {
+ ia[array_index] = row_index;
+ ja[array_index] = c2;
+ if (qm[c - 1].atis_index == GNUNET_TRANSPORT_ATS_QUALITY_NET_DELAY)
{
- ia[array_index] = row_index;
- ja[array_index] = c2;
- if (qm[c-1].atis_index == GNUNET_TRANSPORT_ATS_QUALITY_NET_DELAY)
- {
- double v0 = 0, v1 = 0, v2 = 0;
- v0 = mechanisms[c2].quality[c-1].values[0];
- if (v1 < 1) v0 = 0.1;
- v1 = mechanisms[c2].quality[c-1].values[1];
- if (v1 < 1) v0 = 0.1;
- v2 = mechanisms[c2].quality[c-1].values[2];
- if (v1 < 1) v0 = 0.1;
- value = 100.0 / ((v0 + 2 * v1 + 3 * v2) / 6.0);
- value = 1;
- }
- if (qm[c-1].atis_index == GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE)
- {
- double v0 = 0, v1 = 0, v2 = 0;
- v0 = mechanisms[c2].quality[c-1].values[0];
- if (v0 < 1) v0 = 1;
- v1 = mechanisms[c2].quality[c-1].values[1];
- if (v1 < 1) v1 = 1;
- v2 = mechanisms[c2].quality[c-1].values[2];
- if (v2 < 1) v2 = 1;
- value = (v0 + 2 * v1 + 3 * v2) / 6.0;
- if (value >= 1)
- value = (double) 10 / value;
- else
- value = 10;
- }
- ar[array_index] = (mechanisms[c2].peer->f) * value ;
-#if VERBOSE_ATS
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: %s [%i,%i]=%f \n",
- array_index,
- qm[c-1].name,
- ia[array_index],
- ja[array_index],
- ar[array_index]);
-#endif
- array_index++;
+ double v0 = 0, v1 = 0, v2 = 0;
+
+ v0 = mechanisms[c2].quality[c - 1].values[0];
+ if (v1 < 1)
+ v0 = 0.1;
+ v1 = mechanisms[c2].quality[c - 1].values[1];
+ if (v1 < 1)
+ v0 = 0.1;
+ v2 = mechanisms[c2].quality[c - 1].values[2];
+ if (v1 < 1)
+ v0 = 0.1;
+ value = 100.0 / ((v0 + 2 * v1 + 3 * v2) / 6.0);
+ value = 1;
}
- ia[array_index] = row_index;
- ja[array_index] = col_qm + c - 1;
- ar[array_index] = -1;
+ if (qm[c - 1].atis_index == GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE)
+ {
+ double v0 = 0, v1 = 0, v2 = 0;
+
+ v0 = mechanisms[c2].quality[c - 1].values[0];
+ if (v0 < 1)
+ v0 = 1;
+ v1 = mechanisms[c2].quality[c - 1].values[1];
+ if (v1 < 1)
+ v1 = 1;
+ v2 = mechanisms[c2].quality[c - 1].values[2];
+ if (v2 < 1)
+ v2 = 1;
+ value = (v0 + 2 * v1 + 3 * v2) / 6.0;
+ if (value >= 1)
+ value = (double) 10 / value;
+ else
+ value = 10;
+ }
+ ar[array_index] = (mechanisms[c2].peer->f) * value;
#if VERBOSE_ATS
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
- array_index,
- ia[array_index],
- ja[array_index],
- ar[array_index]);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: %s [%i,%i]=%f \n",
+ array_index,
+ qm[c - 1].name,
+ ia[array_index], ja[array_index], ar[array_index]);
#endif
array_index++;
- row_index++;
+ }
+ ia[array_index] = row_index;
+ ja[array_index] = col_qm + c - 1;
+ ar[array_index] = -1;
+#if VERBOSE_ATS
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
+ array_index, ia[array_index], ja[array_index], ar[array_index]);
+#endif
+ array_index++;
+ row_index++;
}
- stat->end_qm = row_index-1;
+ stat->end_qm = row_index - 1;
// Constraint 8: optimize bandwidth utility
int col_u;
- col_u = _lp_add_cols(ats->prob, 1);
+ col_u = _lp_add_cols (ats->prob, 1);
- _lp_set_col_name(ats->prob, col_u, "u");
- _lp_set_obj_coef(ats->prob, col_u, ats->U);
- _lp_set_col_bnds(ats->prob, col_u, GLP_LO, 0.0, 0.0);
- _lp_add_rows(ats->prob, 1);
+ _lp_set_col_name (ats->prob, col_u, "u");
+ _lp_set_obj_coef (ats->prob, col_u, ats->U);
+ _lp_set_col_bnds (ats->prob, col_u, GLP_LO, 0.0, 0.0);
+ _lp_add_rows (ats->prob, 1);
stat->col_u = col_u;
#if VERBOSE_ATS
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",row_index);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n", row_index);
#endif
- _lp_set_row_bnds(ats->prob, row_index, GLP_FX, 0.0, 0.0);
- for (c=1; c<=c_m; c++)
+ _lp_set_row_bnds (ats->prob, row_index, GLP_FX, 0.0, 0.0);
+ for (c = 1; c <= c_m; c++)
{
ia[array_index] = row_index;
ja[array_index] = c;
ar[array_index] = mechanisms[c].peer->f;
#if VERBOSE_ATS
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
- array_index,
- ia[array_index],
- ja[array_index],
- ar[array_index]);
+ array_index, ia[array_index], ja[array_index], ar[array_index]);
#endif
array_index++;
}
@@ -936,40 +941,37 @@ int ats_create_problem (struct ATS_Handle *ats,
ar[array_index] = -1;
#if VERBOSE_ATS
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
- array_index, ia[array_index],
- ja[array_index],
- ar[array_index]);
+ array_index, ia[array_index], ja[array_index], ar[array_index]);
#endif
array_index++;
- row_index ++;
+ row_index++;
// Constraint 9: optimize relativity
int col_r;
- col_r = _lp_add_cols(ats->prob, 1);
+ col_r = _lp_add_cols (ats->prob, 1);
- _lp_set_col_name(ats->prob, col_r, "r");
- _lp_set_obj_coef(ats->prob, col_r, ats->R);
- _lp_set_col_bnds(ats->prob, col_r, GLP_LO, 0.0, 0.0);
- _lp_add_rows(ats->prob, c_p);
+ _lp_set_col_name (ats->prob, col_r, "r");
+ _lp_set_obj_coef (ats->prob, col_r, ats->R);
+ _lp_set_col_bnds (ats->prob, col_r, GLP_LO, 0.0, 0.0);
+ _lp_add_rows (ats->prob, c_p);
stat->col_r = col_r;
- for (c=1; c<=c_p; c++)
+ for (c = 1; c <= c_p; c++)
{
- _lp_set_row_bnds(ats->prob, row_index, GLP_LO, 0.0, 0.0);
+ _lp_set_row_bnds (ats->prob, row_index, GLP_LO, 0.0, 0.0);
struct ATS_mechanism *m = peers[c].m_head;
- while (m!=NULL)
+
+ while (m != NULL)
{
ia[array_index] = row_index;
ja[array_index] = m->col_index;
ar[array_index] = 1 / mechanisms[c].peer->f;
#if VERBOSE_ATS
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
- array_index,
- ia[array_index],
- ja[array_index],
- ar[array_index]);
+ array_index,
+ ia[array_index], ja[array_index], ar[array_index]);
#endif
array_index++;
m = m->next;
@@ -979,17 +981,14 @@ int ats_create_problem (struct ATS_Handle *ats,
ar[array_index] = -1;
#if VERBOSE_ATS
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
- array_index,
- ia[array_index],
- ja[array_index],
- ar[array_index]);
+ array_index, ia[array_index], ja[array_index], ar[array_index]);
#endif
array_index++;
row_index++;
}
/* Loading the matrix */
- _lp_load_matrix(ats->prob, array_index-1, ia, ja, ar);
+ _lp_load_matrix (ats->prob, array_index - 1, ia, ja, ar);
stat->c_mechs = c_m;
stat->c_peers = c_p;
@@ -1005,30 +1004,31 @@ int ats_create_problem (struct ATS_Handle *ats,
}
-void ats_delete_problem (struct ATS_Handle * ats)
+void
+ats_delete_problem (struct ATS_Handle *ats)
{
#if DEBUG_ATS
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Deleting problem\n");
#endif
int c;
- for (c=0; c< (ats->internal).c_mechs; c++)
- GNUNET_free_non_null (ats->mechanisms[c].rc);
- if (ats->mechanisms!=NULL)
+ for (c = 0; c < (ats->internal).c_mechs; c++)
+ GNUNET_free_non_null (ats->mechanisms[c].rc);
+ if (ats->mechanisms != NULL)
{
- GNUNET_free(ats->mechanisms);
+ GNUNET_free (ats->mechanisms);
ats->mechanisms = NULL;
}
- if (ats->peers!=NULL)
+ if (ats->peers != NULL)
{
- GNUNET_free(ats->peers);
+ GNUNET_free (ats->peers);
ats->peers = NULL;
}
if (ats->prob != NULL)
{
- _lp_delete_prob(ats->prob);
+ _lp_delete_prob (ats->prob);
ats->prob = NULL;
}
@@ -1042,13 +1042,14 @@ void ats_delete_problem (struct ATS_Handle * ats)
ats->internal.valid = GNUNET_SYSERR;
}
-void ats_modify_problem_state (struct ATS_Handle * ats, enum ATS_problem_state s)
+void
+ats_modify_problem_state (struct ATS_Handle *ats, enum ATS_problem_state s)
{
if (ats == NULL)
return;
switch (s)
{
- case ATS_NEW :
+ case ATS_NEW:
ats->internal.recreate_problem = GNUNET_NO;
ats->internal.modified_quality = GNUNET_NO;
ats->internal.modified_resources = GNUNET_NO;
@@ -1056,10 +1057,10 @@ void ats_modify_problem_state (struct ATS_Handle * ats, enum ATS_problem_state s
case ATS_MODIFIED:
ats->internal.recreate_problem = GNUNET_YES;
break;
- case ATS_QUALITY_UPDATED :
+ case ATS_QUALITY_UPDATED:
ats->internal.modified_quality = GNUNET_YES;
break;
- case ATS_COST_UPDATED :
+ case ATS_COST_UPDATED:
ats->internal.modified_resources = GNUNET_YES;
break;
case ATS_QUALITY_COST_UPDATED:
@@ -1074,12 +1075,12 @@ void ats_modify_problem_state (struct ATS_Handle * ats, enum ATS_problem_state s
}
-void ats_solve_problem (struct ATS_Handle * ats,
- unsigned int max_it,
- unsigned int max_dur,
- unsigned int c_peers,
- unsigned int c_mechs,
- struct ATS_internals *stat)
+void
+ats_solve_problem (struct ATS_Handle *ats,
+ unsigned int max_it,
+ unsigned int max_dur,
+ unsigned int c_peers,
+ unsigned int c_mechs, struct ATS_internals *stat)
{
int result = GNUNET_SYSERR;
int lp_solution = GNUNET_SYSERR;
@@ -1088,7 +1089,8 @@ void ats_solve_problem (struct ATS_Handle * ats,
// Solving simplex
glp_smcp opt_lp;
- _lp_init_smcp(&opt_lp);
+
+ _lp_init_smcp (&opt_lp);
#if VERBOSE_ATS
opt_lp.msg_lev = GLP_MSG_ALL;
#else
@@ -1100,20 +1102,20 @@ void ats_solve_problem (struct ATS_Handle * ats,
opt_lp.tm_lim = max_dur;
if (ats->internal.recreate_problem == GNUNET_YES)
- opt_lp.presolve = GLP_ON;
+ opt_lp.presolve = GLP_ON;
- result = _lp_simplex(ats->prob, &opt_lp);
- lp_solution = _lp_get_status (ats->prob);
+ result = _lp_simplex (ats->prob, &opt_lp);
+ lp_solution = _lp_get_status (ats->prob);
if ((result == GLP_ETMLIM) || (result == GLP_EITLIM))
{
ats->internal.valid = GNUNET_NO;
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "ATS exceeded time or iteration limit!\n");
+ "ATS exceeded time or iteration limit!\n");
return;
}
- if (ats_evaluate_results(result, lp_solution, "LP") == GNUNET_YES)
+ if (ats_evaluate_results (result, lp_solution, "LP") == GNUNET_YES)
{
stat->valid = GNUNET_YES;
}
@@ -1121,36 +1123,37 @@ void ats_solve_problem (struct ATS_Handle * ats,
{
ats->internal.simplex_rerun_required = GNUNET_YES;
opt_lp.presolve = GLP_ON;
- result = _lp_simplex(ats->prob, &opt_lp);
- lp_solution = _lp_get_status (ats->prob);
+ result = _lp_simplex (ats->prob, &opt_lp);
+ lp_solution = _lp_get_status (ats->prob);
// TODO: Remove if this does not appear until release
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, ""
- "EXECUTED SIMPLEX WITH PRESOLVER! %i \n",
- lp_solution);
+ "EXECUTED SIMPLEX WITH PRESOLVER! %i \n", lp_solution);
- if (ats_evaluate_results(result, lp_solution, "LP") != GNUNET_YES)
+ if (ats_evaluate_results (result, lp_solution, "LP") != GNUNET_YES)
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "After execution simplex with presolver: STILL INVALID!\n");
- char * filename;
- GNUNET_asprintf (&filename,
- "ats_mlp_p%i_m%i_%llu.mlp",
- ats->internal.c_peers,
- ats->internal.c_mechs,
- GNUNET_TIME_absolute_get().abs_value);
- _lp_write_lp ((void *)ats->prob, NULL, filename);
- GNUNET_free (filename);
- stat->valid = GNUNET_NO;
- ats->internal.recreate_problem = GNUNET_YES;
- return;
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "After execution simplex with presolver: STILL INVALID!\n");
+ char *filename;
+
+ GNUNET_asprintf (&filename,
+ "ats_mlp_p%i_m%i_%llu.mlp",
+ ats->internal.c_peers,
+ ats->internal.c_mechs,
+ GNUNET_TIME_absolute_get ().abs_value);
+ _lp_write_lp ((void *) ats->prob, NULL, filename);
+ GNUNET_free (filename);
+ stat->valid = GNUNET_NO;
+ ats->internal.recreate_problem = GNUNET_YES;
+ return;
}
stat->valid = GNUNET_YES;
}
// Solving mlp
glp_iocp opt_mlp;
- _lp_init_iocp(&opt_mlp);
+
+ _lp_init_iocp (&opt_mlp);
// maximum duration
opt_mlp.tm_lim = max_dur;
// output level
@@ -1161,342 +1164,351 @@ void ats_solve_problem (struct ATS_Handle * ats,
#endif
result = _lp_intopt (ats->prob, &opt_mlp);
- mlp_solution = _lp_mip_status (ats->prob);
+ mlp_solution = _lp_mip_status (ats->prob);
stat->solution = mlp_solution;
- if (ats_evaluate_results(result, mlp_solution, "MLP") == GNUNET_YES)
+ if (ats_evaluate_results (result, mlp_solution, "MLP") == GNUNET_YES)
{
- stat->valid = GNUNET_YES;
+ stat->valid = GNUNET_YES;
}
else
{
- // TODO: Remove if this does not appear until release
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "MLP solution for %i peers, %i mechs is invalid: %i\n",
- ats->internal.c_peers,
- ats->internal.c_mechs,
- mlp_solution);
- stat->valid = GNUNET_NO;
+ // TODO: Remove if this does not appear until release
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "MLP solution for %i peers, %i mechs is invalid: %i\n",
+ ats->internal.c_peers, ats->internal.c_mechs, mlp_solution);
+ stat->valid = GNUNET_NO;
}
#if VERBOSE_ATS
- if (_lp_get_col_prim(ats->prob,2*c_mechs+1) != 1)
- {
- int c;
- for (c=1; c<= available_quality_metrics; c++ )
+ if (_lp_get_col_prim (ats->prob, 2 * c_mechs + 1) != 1)
{
+ int c;
+
+ for (c = 1; c <= available_quality_metrics; c++)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s %f\n",
+ _lp_get_col_name (ats->prob, 2 * c_mechs + 3 + c),
+ _lp_get_col_prim (ats->prob, 2 * c_mechs + 3 + c));
+ }
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s %f\n",
- _lp_get_col_name(ats->prob,2*c_mechs+3+c),
- _lp_get_col_prim(ats->prob,2*c_mechs+3+c));
- }
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s %f\n",
- _lp_get_col_name(ats->prob,2*c_mechs+1),
- _lp_get_col_prim(ats->prob,2*c_mechs+1));
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s %f\n",
- _lp_get_col_name(ats->prob,2*c_mechs+2),
- _lp_get_col_prim(ats->prob,2*c_mechs+2));
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s %f\n",
- _lp_get_col_name(ats->prob,2*c_mechs+3),
- _lp_get_col_prim(ats->prob,2*c_mechs+3));
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "objective value: %f\n",
- _lp_mip_obj_val(ats->prob));
+ _lp_get_col_name (ats->prob, 2 * c_mechs + 1),
+ _lp_get_col_prim (ats->prob, 2 * c_mechs + 1));
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s %f\n",
+ _lp_get_col_name (ats->prob, 2 * c_mechs + 2),
+ _lp_get_col_prim (ats->prob, 2 * c_mechs + 2));
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s %f\n",
+ _lp_get_col_name (ats->prob, 2 * c_mechs + 3),
+ _lp_get_col_prim (ats->prob, 2 * c_mechs + 3));
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "objective value: %f\n",
+ _lp_mip_obj_val (ats->prob));
}
#endif
}
-void ats_shutdown (struct ATS_Handle * ats)
+void
+ats_shutdown (struct ATS_Handle *ats)
{
#if DEBUG_ATS
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "ATS shutdown\n");
#endif
ats_delete_problem (ats);
- _lp_free_env();
+ _lp_free_env ();
GNUNET_free (ats);
}
-void ats_update_problem_qm (struct ATS_Handle * ats)
+void
+ats_update_problem_qm (struct ATS_Handle *ats)
{
- int array_index;
- int row_index;
- int c, c2;
- int c_q_metrics = available_quality_metrics;
-
- int *ja = GNUNET_malloc ((1 + ats->internal.c_mechs*2 + 3 +
- available_quality_metrics) * sizeof (int));
- double *ar = GNUNET_malloc ((1 + ats->internal.c_mechs*2 + 3 +
- available_quality_metrics) * sizeof (double));
+ int array_index;
+ int row_index;
+ int c, c2;
+ int c_q_metrics = available_quality_metrics;
+
+ int *ja = GNUNET_malloc ((1 + ats->internal.c_mechs * 2 + 3 +
+ available_quality_metrics) * sizeof (int));
+ double *ar = GNUNET_malloc ((1 + ats->internal.c_mechs * 2 + 3 +
+ available_quality_metrics) * sizeof (double));
#if DEBUG_ATS
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Updating problem quality metrics\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Updating problem quality metrics\n");
#endif
- row_index = ats->internal.begin_qm;
+ row_index = ats->internal.begin_qm;
+
+ for (c = 1; c <= c_q_metrics; c++)
+ {
+ array_index = 1;
+ double value = 1;
- for (c=1; c <= c_q_metrics; c++)
- {
- array_index = 1;
- double value = 1;
-#if VERBOSE_ATS
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",row_index);
-#endif
- _lp_set_row_bnds(ats->prob, row_index, GLP_FX, 0.0, 0.0);
- for (c2=1; c2<=ats->internal.c_mechs; c2++)
- {
- ja[array_index] = c2;
- GNUNET_assert (ats->mechanisms[c2].addr != NULL);
- GNUNET_assert (ats->mechanisms[c2].peer != NULL);
-
- if (qm[c-1].atis_index == GNUNET_TRANSPORT_ATS_QUALITY_NET_DELAY)
- {
- double v0 = 0, v1 = 0, v2 = 0;
-
- v0 = ats->mechanisms[c2].quality[c-1].values[0];
- if (v1 < 1) v0 = 0.1;
- v1 = ats->mechanisms[c2].quality[c-1].values[1];
- if (v1 < 1) v0 = 0.1;
- v2 = ats->mechanisms[c2].quality[c-1].values[2];
- if (v1 < 1) v0 = 0.1;
- value = 100.0 / ((v0 + 2 * v1 + 3 * v2) / 6.0);
- //value = 1;
- }
- if (qm[c-1].atis_index == GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE)
- {
- double v0 = 0, v1 = 0, v2 = 0;
- v0 = ats->mechanisms[c2].quality[c-1].values[0];
- if (v0 < 1) v0 = 1;
- v1 = ats->mechanisms[c2].quality[c-1].values[1];
- if (v1 < 1) v1 = 1;
- v2 = ats->mechanisms[c2].quality[c-1].values[2];
- if (v2 < 1) v2 = 1;
- value = (v0 + 2 * v1 + 3 * v2) / 6.0;
- if (value >= 1)
- value = (double) 10 / value;
- else
- value = 10;
- }
- ar[array_index] = (ats->mechanisms[c2].peer->f) * value;
#if VERBOSE_ATS
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: %s [%i,%i]=%f \n",
- array_index,
- qm[c-1].name,
- row_index,
- ja[array_index],
- ar[array_index]);
-#endif
- array_index++;
- }
- ja[array_index] = ats->internal.col_qm + c - 1;
- ar[array_index] = -1;
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n", row_index);
+#endif
+ _lp_set_row_bnds (ats->prob, row_index, GLP_FX, 0.0, 0.0);
+ for (c2 = 1; c2 <= ats->internal.c_mechs; c2++)
+ {
+ ja[array_index] = c2;
+ GNUNET_assert (ats->mechanisms[c2].addr != NULL);
+ GNUNET_assert (ats->mechanisms[c2].peer != NULL);
+ if (qm[c - 1].atis_index == GNUNET_TRANSPORT_ATS_QUALITY_NET_DELAY)
+ {
+ double v0 = 0, v1 = 0, v2 = 0;
+
+ v0 = ats->mechanisms[c2].quality[c - 1].values[0];
+ if (v1 < 1)
+ v0 = 0.1;
+ v1 = ats->mechanisms[c2].quality[c - 1].values[1];
+ if (v1 < 1)
+ v0 = 0.1;
+ v2 = ats->mechanisms[c2].quality[c - 1].values[2];
+ if (v1 < 1)
+ v0 = 0.1;
+ value = 100.0 / ((v0 + 2 * v1 + 3 * v2) / 6.0);
+ //value = 1;
+ }
+ if (qm[c - 1].atis_index == GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE)
+ {
+ double v0 = 0, v1 = 0, v2 = 0;
+
+ v0 = ats->mechanisms[c2].quality[c - 1].values[0];
+ if (v0 < 1)
+ v0 = 1;
+ v1 = ats->mechanisms[c2].quality[c - 1].values[1];
+ if (v1 < 1)
+ v1 = 1;
+ v2 = ats->mechanisms[c2].quality[c - 1].values[2];
+ if (v2 < 1)
+ v2 = 1;
+ value = (v0 + 2 * v1 + 3 * v2) / 6.0;
+ if (value >= 1)
+ value = (double) 10 / value;
+ else
+ value = 10;
+ }
+ ar[array_index] = (ats->mechanisms[c2].peer->f) * value;
#if VERBOSE_ATS
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
- array_index,
- row_index,
- ja[array_index],
- ar[array_index]);
-#endif
- _lp_set_mat_row (ats->prob, row_index, array_index, ja, ar);
- array_index = 1;
- row_index++;
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: %s [%i,%i]=%f \n",
+ array_index,
+ qm[c - 1].name, row_index, ja[array_index], ar[array_index]);
+#endif
+ array_index++;
}
- GNUNET_free_non_null (ja);
- GNUNET_free_non_null (ar);
+ ja[array_index] = ats->internal.col_qm + c - 1;
+ ar[array_index] = -1;
+
+#if VERBOSE_ATS
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
+ array_index, row_index, ja[array_index], ar[array_index]);
+#endif
+ _lp_set_mat_row (ats->prob, row_index, array_index, ja, ar);
+ array_index = 1;
+ row_index++;
+ }
+ GNUNET_free_non_null (ja);
+ GNUNET_free_non_null (ar);
}
void
-ats_calculate_bandwidth_distribution (struct ATS_Handle * ats)
+ats_calculate_bandwidth_distribution (struct ATS_Handle *ats)
{
- struct GNUNET_TIME_Absolute start;
- struct GNUNET_TIME_Relative creation;
- struct GNUNET_TIME_Relative solving;
- int c_m;
- int c_p;
- char *text = "unmodified";
+ struct GNUNET_TIME_Absolute start;
+ struct GNUNET_TIME_Relative creation;
+ struct GNUNET_TIME_Relative solving;
+ int c_m;
+ int c_p;
+ char *text = "unmodified";
#if FIXME_WACHS
- int dur;
- if (INT_MAX < ats->max_exec_duration.rel_value)
- dur = INT_MAX;
- else
- dur = (int) ats->max_exec_duration.rel_value;
+ int dur;
+
+ if (INT_MAX < ats->max_exec_duration.rel_value)
+ dur = INT_MAX;
+ else
+ dur = (int) ats->max_exec_duration.rel_value;
#endif
- ats->internal.simplex_rerun_required = GNUNET_NO;
- start = GNUNET_TIME_absolute_get();
- if ((ats->internal.recreate_problem == GNUNET_YES) ||
- (ats->prob==NULL) ||
- (ats->internal.valid == GNUNET_NO))
- {
- text = "new";
- ats->internal.recreate_problem = GNUNET_YES;
- ats_delete_problem (ats);
- ats->addr_notification(&ats->peers , &c_p, &ats->mechanisms, &c_m);
+ ats->internal.simplex_rerun_required = GNUNET_NO;
+ start = GNUNET_TIME_absolute_get ();
+ if ((ats->internal.recreate_problem == GNUNET_YES) ||
+ (ats->prob == NULL) || (ats->internal.valid == GNUNET_NO))
+ {
+ text = "new";
+ ats->internal.recreate_problem = GNUNET_YES;
+ ats_delete_problem (ats);
+ ats->addr_notification (&ats->peers, &c_p, &ats->mechanisms, &c_m);
#if DEBUG_ATS
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Service returned: %i peer, %i mechs\n",
- c_p,
- c_m);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Service returned: %i peer, %i mechs\n", c_p, c_m);
#endif
- ats_create_problem (ats, &ats->internal, ats->peers, c_p, ats->mechanisms, c_m);
+ ats_create_problem (ats, &ats->internal, ats->peers, c_p, ats->mechanisms,
+ c_m);
#if DEBUG_ATS
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Peers/Addresses were modified... new problem: %i peer, %i mechs\n",
- ats->internal.c_peers,
- ats->internal.c_mechs);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Peers/Addresses were modified... new problem: %i peer, %i mechs\n",
+ ats->internal.c_peers, ats->internal.c_mechs);
#endif
- }
+ }
- else if ((ats->internal.recreate_problem == GNUNET_NO) &&
- (ats->internal.modified_resources == GNUNET_YES) &&
- (ats->internal.valid == GNUNET_YES))
- {
- text = "modified resources";
- ats_update_problem_cr (ats);
- }
- else if ((ats->internal.recreate_problem == GNUNET_NO) &&
- (ats->internal.modified_quality == GNUNET_YES) &&
- (ats->internal.valid == GNUNET_YES))
- {
- text = "modified quality";
- ats_update_problem_qm (ats);
- //ats_update_problem_qm_TEST ();
- }
+ else if ((ats->internal.recreate_problem == GNUNET_NO) &&
+ (ats->internal.modified_resources == GNUNET_YES) &&
+ (ats->internal.valid == GNUNET_YES))
+ {
+ text = "modified resources";
+ ats_update_problem_cr (ats);
+ }
+ else if ((ats->internal.recreate_problem == GNUNET_NO) &&
+ (ats->internal.modified_quality == GNUNET_YES) &&
+ (ats->internal.valid == GNUNET_YES))
+ {
+ text = "modified quality";
+ ats_update_problem_qm (ats);
+ //ats_update_problem_qm_TEST ();
+ }
#if DEBUG_ATS
- else GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Problem is %s\n", text);
+ else
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Problem is %s\n", text);
#endif
- creation = GNUNET_TIME_absolute_get_difference(start,GNUNET_TIME_absolute_get());
- start = GNUNET_TIME_absolute_get();
+ creation =
+ GNUNET_TIME_absolute_get_difference (start, GNUNET_TIME_absolute_get ());
+ start = GNUNET_TIME_absolute_get ();
- ats->internal.solution = GLP_UNDEF;
- if (ats->internal.valid == GNUNET_YES)
- {
- ats_solve_problem(ats,
- ats->max_iterations,
- ats->max_exec_duration.rel_value,
- ats->internal.c_peers,
- ats->internal.c_mechs,
- &ats->internal);
- }
- solving = GNUNET_TIME_absolute_get_difference(start,GNUNET_TIME_absolute_get());
+ ats->internal.solution = GLP_UNDEF;
+ if (ats->internal.valid == GNUNET_YES)
+ {
+ ats_solve_problem (ats,
+ ats->max_iterations,
+ ats->max_exec_duration.rel_value,
+ ats->internal.c_peers,
+ ats->internal.c_mechs, &ats->internal);
+ }
+ solving =
+ GNUNET_TIME_absolute_get_difference (start, GNUNET_TIME_absolute_get ());
- if (ats->internal.valid == GNUNET_YES)
- {
- /* Telling about new distribution*/
- ats->result_cb ();
+ if (ats->internal.valid == GNUNET_YES)
+ {
+ /* Telling about new distribution */
+ ats->result_cb ();
+
+ int msg_type = GNUNET_ERROR_TYPE_DEBUG;
- int msg_type = GNUNET_ERROR_TYPE_DEBUG;
#if DEBUG_ATS
- msg_type = GNUNET_ERROR_TYPE_ERROR;
-#endif
- GNUNET_log (msg_type,
- "MLP %s: creation time: %llu, execution time: %llu, %i peers, %i mechanisms, simplex rerun: %s, solution %s\n",
- text,
- creation.rel_value,
- solving.rel_value,
- ats->internal.c_peers,
- ats->internal.c_mechs,
- (ats->internal.simplex_rerun_required == GNUNET_NO) ? "NO" : "YES",
- (ats->internal.solution == 5) ? "OPTIMAL" : "INVALID");
- ats->successful_executions ++;
+ msg_type = GNUNET_ERROR_TYPE_ERROR;
+#endif
+ GNUNET_log (msg_type,
+ "MLP %s: creation time: %llu, execution time: %llu, %i peers, %i mechanisms, simplex rerun: %s, solution %s\n",
+ text,
+ creation.rel_value,
+ solving.rel_value,
+ ats->internal.c_peers,
+ ats->internal.c_mechs,
+ (ats->internal.simplex_rerun_required ==
+ GNUNET_NO) ? "NO" : "YES",
+ (ats->internal.solution == 5) ? "OPTIMAL" : "INVALID");
+ ats->successful_executions++;
+ GNUNET_STATISTICS_set (ats->stats, "# ATS successful executions",
+ ats->successful_executions, GNUNET_NO);
+
+ if ((ats->internal.recreate_problem == GNUNET_YES) || (ats->prob == NULL))
+ GNUNET_STATISTICS_set (ats->stats, "ATS state", ATS_NEW, GNUNET_NO);
+ else if ((ats->internal.modified_resources == GNUNET_YES) &&
+ (ats->internal.modified_quality == GNUNET_NO))
+ GNUNET_STATISTICS_set (ats->stats, "ATS state", ATS_COST_UPDATED,
+ GNUNET_NO);
+ else if ((ats->internal.modified_resources == GNUNET_NO) &&
+ (ats->internal.modified_quality == GNUNET_YES) &&
+ (ats->internal.simplex_rerun_required == GNUNET_NO))
+ GNUNET_STATISTICS_set (ats->stats, "ATS state", ATS_QUALITY_UPDATED,
+ GNUNET_NO);
+ else if ((ats->internal.modified_resources == GNUNET_YES) &&
+ (ats->internal.modified_quality == GNUNET_YES) &&
+ (ats->internal.simplex_rerun_required == GNUNET_NO))
+ GNUNET_STATISTICS_set (ats->stats, "ATS state", ATS_QUALITY_COST_UPDATED,
+ GNUNET_NO);
+ else if (ats->internal.simplex_rerun_required == GNUNET_NO)
+ GNUNET_STATISTICS_set (ats->stats, "ATS state", ATS_UNMODIFIED,
+ GNUNET_NO);
+ }
+ else
+ {
+ if (ats->internal.c_peers != 0)
+ {
+ ats->invalid_executions++;
+ GNUNET_STATISTICS_set (ats->stats, "# ATS invalid executions",
+ ats->invalid_executions, GNUNET_NO);
+ }
+ else
+ {
GNUNET_STATISTICS_set (ats->stats, "# ATS successful executions",
- ats->successful_executions,
- GNUNET_NO);
-
- if ((ats->internal.recreate_problem == GNUNET_YES) || (ats->prob==NULL))
- GNUNET_STATISTICS_set (ats->stats, "ATS state",ATS_NEW, GNUNET_NO);
- else if ((ats->internal.modified_resources == GNUNET_YES) &&
- (ats->internal.modified_quality == GNUNET_NO))
- GNUNET_STATISTICS_set (ats->stats, "ATS state", ATS_COST_UPDATED, GNUNET_NO);
- else if ((ats->internal.modified_resources == GNUNET_NO) &&
- (ats->internal.modified_quality == GNUNET_YES) &&
- (ats->internal.simplex_rerun_required == GNUNET_NO))
- GNUNET_STATISTICS_set (ats->stats, "ATS state", ATS_QUALITY_UPDATED, GNUNET_NO);
- else if ((ats->internal.modified_resources == GNUNET_YES) &&
- (ats->internal.modified_quality == GNUNET_YES) &&
- (ats->internal.simplex_rerun_required == GNUNET_NO))
- GNUNET_STATISTICS_set (ats->stats, "ATS state", ATS_QUALITY_COST_UPDATED, GNUNET_NO);
- else if (ats->internal.simplex_rerun_required == GNUNET_NO)
- GNUNET_STATISTICS_set (ats->stats, "ATS state", ATS_UNMODIFIED, GNUNET_NO);
+ ats->successful_executions, GNUNET_NO);
+ }
+ }
+
+ GNUNET_STATISTICS_set (ats->stats,
+ "ATS duration", solving.rel_value + creation.rel_value,
+ GNUNET_NO);
+ GNUNET_STATISTICS_set (ats->stats, "ATS mechanisms", ats->internal.c_mechs,
+ GNUNET_NO);
+ GNUNET_STATISTICS_set (ats->stats, "ATS peers", ats->internal.c_peers,
+ GNUNET_NO);
+ GNUNET_STATISTICS_set (ats->stats, "ATS solution", ats->internal.solution,
+ GNUNET_NO);
+ GNUNET_STATISTICS_set (ats->stats, "ATS timestamp", start.abs_value,
+ GNUNET_NO);
+
+ if ((ats->save_mlp == GNUNET_YES) &&
+ (ats->internal.c_mechs >= ats->dump_min_peers) &&
+ (ats->internal.c_mechs >= ats->dump_min_addr))
+ {
+ char *filename;
+
+ if (ats->dump_overwrite == GNUNET_NO)
+ {
+ GNUNET_asprintf (&filename, "ats_mlp_p%i_m%i_%s_%llu.mlp",
+ ats->internal.c_peers,
+ ats->internal.c_mechs,
+ text, GNUNET_TIME_absolute_get ().abs_value);
+ _lp_write_lp ((void *) ats->prob, NULL, filename);
}
else
{
- if (ats->internal.c_peers != 0)
- {
- ats->invalid_executions ++;
- GNUNET_STATISTICS_set (ats->stats, "# ATS invalid executions",
- ats->invalid_executions, GNUNET_NO);
- }
- else
- {
- GNUNET_STATISTICS_set (ats->stats, "# ATS successful executions",
- ats->successful_executions, GNUNET_NO);
- }
+ GNUNET_asprintf (&filename, "ats_mlp_p%i_m%i.mlp",
+ ats->internal.c_peers, ats->internal.c_mechs);
+ _lp_write_lp ((void *) ats->prob, NULL, filename);
}
+ GNUNET_free (filename);
+ }
+ if ((ats->save_solution == GNUNET_YES) &&
+ (ats->internal.c_mechs >= ats->dump_min_peers) &&
+ (ats->internal.c_mechs >= ats->dump_min_addr))
+ {
+ char *filename;
- GNUNET_STATISTICS_set (ats->stats,
- "ATS duration", solving.rel_value + creation.rel_value, GNUNET_NO);
- GNUNET_STATISTICS_set (ats->stats,
- "ATS mechanisms", ats->internal.c_mechs, GNUNET_NO);
- GNUNET_STATISTICS_set (ats->stats,
- "ATS peers", ats->internal.c_peers, GNUNET_NO);
- GNUNET_STATISTICS_set (ats->stats,
- "ATS solution", ats->internal.solution, GNUNET_NO);
- GNUNET_STATISTICS_set (ats->stats,
- "ATS timestamp", start.abs_value, GNUNET_NO);
-
- if ((ats->save_mlp == GNUNET_YES) &&
- (ats->internal.c_mechs >= ats->dump_min_peers) &&
- (ats->internal.c_mechs >= ats->dump_min_addr))
+ if (ats->dump_overwrite == GNUNET_NO)
{
- char * filename;
- if (ats->dump_overwrite == GNUNET_NO)
- {
- GNUNET_asprintf (&filename, "ats_mlp_p%i_m%i_%s_%llu.mlp",
- ats->internal.c_peers,
- ats->internal.c_mechs,
- text,
- GNUNET_TIME_absolute_get().abs_value);
- _lp_write_lp ((void *) ats->prob, NULL, filename);
- }
- else
- {
- GNUNET_asprintf (&filename, "ats_mlp_p%i_m%i.mlp",
- ats->internal.c_peers, ats->internal.c_mechs );
- _lp_write_lp ((void *) ats->prob, NULL, filename);
- }
- GNUNET_free (filename);
+ GNUNET_asprintf (&filename, "ats_mlp_p%i_m%i_%s_%llu.sol",
+ ats->internal.c_peers,
+ ats->internal.c_mechs,
+ text, GNUNET_TIME_absolute_get ().abs_value);
+ _lp_print_sol (ats->prob, filename);
}
- if ((ats->save_solution == GNUNET_YES) &&
- (ats->internal.c_mechs >= ats->dump_min_peers) &&
- (ats->internal.c_mechs >= ats->dump_min_addr))
+ else
{
- char * filename;
- if (ats->dump_overwrite == GNUNET_NO)
- {
- GNUNET_asprintf (&filename, "ats_mlp_p%i_m%i_%s_%llu.sol",
- ats->internal.c_peers,
- ats->internal.c_mechs,
- text,
- GNUNET_TIME_absolute_get().abs_value);
- _lp_print_sol (ats->prob, filename);
- }
- else
- {
- GNUNET_asprintf (&filename, "ats_mlp_p%i_m%i.sol",
- ats->internal.c_peers, ats->internal.c_mechs);
- _lp_print_sol (ats->prob, filename);
- }
- GNUNET_free (filename);
+ GNUNET_asprintf (&filename, "ats_mlp_p%i_m%i.sol",
+ ats->internal.c_peers, ats->internal.c_mechs);
+ _lp_print_sol (ats->prob, filename);
}
+ GNUNET_free (filename);
+ }
- ats->internal.recreate_problem = GNUNET_NO;
- ats->internal.modified_resources = GNUNET_NO;
- ats->internal.modified_quality = GNUNET_NO;
+ ats->internal.recreate_problem = GNUNET_NO;
+ ats->internal.modified_resources = GNUNET_NO;
+ ats->internal.modified_quality = GNUNET_NO;
}
/**
@@ -1508,198 +1520,188 @@ ats_calculate_bandwidth_distribution (struct ATS_Handle * ats)
* valid
*/
-int ats_evaluate_results (int result, int solution, char * problem)
+int
+ats_evaluate_results (int result, int solution, char *problem)
{
- int cont = GNUNET_NO;
+ int cont = GNUNET_NO;
+
#if DEBUG_ATS || VERBOSE_ATS
- int error_kind = GNUNET_ERROR_TYPE_DEBUG;
+ int error_kind = GNUNET_ERROR_TYPE_DEBUG;
#endif
#if VERBOSE_ATS
- error_kind = GNUNET_ERROR_TYPE_ERROR;
+ error_kind = GNUNET_ERROR_TYPE_ERROR;
#endif
- switch (result) {
- case GNUNET_SYSERR : /* GNUNET problem, not GLPK related */
+ switch (result)
+ {
+ case GNUNET_SYSERR: /* GNUNET problem, not GLPK related */
#if DEBUG_ATS || VERBOSE_ATS
- GNUNET_log (error_kind,
- "%s, GLPK solving not executed\n", problem);
+ GNUNET_log (error_kind, "%s, GLPK solving not executed\n", problem);
#endif
- break;
- case GLP_ESTOP : /* search terminated by application */
+ break;
+ case GLP_ESTOP: /* search terminated by application */
#if DEBUG_ATS || VERBOSE_ATS
- GNUNET_log (error_kind,
- "%s , Search terminated by application\n", problem);
+ GNUNET_log (error_kind, "%s , Search terminated by application\n", problem);
#endif
- break;
- case GLP_EITLIM : /* iteration limit exceeded */
+ break;
+ case GLP_EITLIM: /* iteration limit exceeded */
#if DEBUG_ATS || VERBOSE_ATS
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "%s Iteration limit exceeded\n", problem);
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "%s Iteration limit exceeded\n", problem);
#endif
- break;
- case GLP_ETMLIM : /* time limit exceeded */
+ break;
+ case GLP_ETMLIM: /* time limit exceeded */
#if DEBUG_ATS || VERBOSE_ATS
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "%s Time limit exceeded\n", problem);
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "%s Time limit exceeded\n", problem);
#endif
- break;
- case GLP_ENOPFS : /* no primal feasible solution */
- case GLP_ENODFS : /* no dual feasible solution */
+ break;
+ case GLP_ENOPFS: /* no primal feasible solution */
+ case GLP_ENODFS: /* no dual feasible solution */
#if DEBUG_ATS || VERBOSE_ATS
- GNUNET_log (error_kind,
- "%s No feasible solution\n", problem);
-#endif
- break;
- case GLP_EBADB : /* invalid basis */
- case GLP_ESING : /* singular matrix */
- case GLP_ECOND : /* ill-conditioned matrix */
- case GLP_EBOUND : /* invalid bounds */
- case GLP_EFAIL : /* solver failed */
- case GLP_EOBJLL : /* objective lower limit reached */
- case GLP_EOBJUL : /* objective upper limit reached */
- case GLP_EROOT : /* root LP optimum not provided */
+ GNUNET_log (error_kind, "%s No feasible solution\n", problem);
+#endif
+ break;
+ case GLP_EBADB: /* invalid basis */
+ case GLP_ESING: /* singular matrix */
+ case GLP_ECOND: /* ill-conditioned matrix */
+ case GLP_EBOUND: /* invalid bounds */
+ case GLP_EFAIL: /* solver failed */
+ case GLP_EOBJLL: /* objective lower limit reached */
+ case GLP_EOBJUL: /* objective upper limit reached */
+ case GLP_EROOT: /* root LP optimum not provided */
#if DEBUG_ATS || VERBOSE_ATS
- GNUNET_log (error_kind,
- "%s Invalid Input data: %i\n",
- problem, result);
+ GNUNET_log (error_kind, "%s Invalid Input data: %i\n", problem, result);
#endif
- break;
- case 0:
+ break;
+ case 0:
#if DEBUG_ATS || VERBOSE_ATS
- GNUNET_log (error_kind,
- "%s Problem has been solved\n", problem);
+ GNUNET_log (error_kind, "%s Problem has been solved\n", problem);
#endif
break;
}
- switch (solution) {
- case GLP_UNDEF:
+ switch (solution)
+ {
+ case GLP_UNDEF:
#if DEBUG_ATS || VERBOSE_ATS
- GNUNET_log (error_kind,
- "%s solution is undefined\n", problem);
+ GNUNET_log (error_kind, "%s solution is undefined\n", problem);
#endif
- break;
- case GLP_OPT:
+ break;
+ case GLP_OPT:
#if DEBUG_ATS || VERBOSE_ATS
- GNUNET_log (error_kind,
- "%s solution is optimal\n", problem);
+ GNUNET_log (error_kind, "%s solution is optimal\n", problem);
#endif
- cont=GNUNET_YES;
- break;
- case GLP_FEAS:
+ cont = GNUNET_YES;
+ break;
+ case GLP_FEAS:
#if DEBUG_ATS || VERBOSE_ATS
- GNUNET_log (error_kind,
- "%s solution is %s feasible, however, its optimality (or non-optimality) has not been proven\n",
- problem, (0==strcmp(problem,"LP")?"":"integer"));
+ GNUNET_log (error_kind,
+ "%s solution is %s feasible, however, its optimality (or non-optimality) has not been proven\n",
+ problem, (0 == strcmp (problem, "LP") ? "" : "integer"));
#endif
- cont=GNUNET_YES;
- break;
- case GLP_NOFEAS:
+ cont = GNUNET_YES;
+ break;
+ case GLP_NOFEAS:
#if DEBUG_ATS || VERBOSE_ATS
- GNUNET_log (error_kind, "%s problem has no %sfeasible solution\n",
- problem, (0==strcmp(problem,"LP")?"":"integer "));
+ GNUNET_log (error_kind, "%s problem has no %sfeasible solution\n",
+ problem, (0 == strcmp (problem, "LP") ? "" : "integer "));
#endif
- break;
- case GLP_INFEAS:
+ break;
+ case GLP_INFEAS:
#if DEBUG_ATS || VERBOSE_ATS
- GNUNET_log (error_kind, "%s problem is infeasible \n", problem);
+ GNUNET_log (error_kind, "%s problem is infeasible \n", problem);
#endif
- break;
- case GLP_UNBND:
+ break;
+ case GLP_UNBND:
#if DEBUG_ATS || VERBOSE_ATS
- GNUNET_log (error_kind, "%s problem is unbounded \n", problem);
+ GNUNET_log (error_kind, "%s problem is unbounded \n", problem);
#endif
- default:
- break;
+ default:
+ break;
}
-return cont;
+ return cont;
}
-void ats_update_problem_cr (struct ATS_Handle * ats)
+void
+ats_update_problem_cr (struct ATS_Handle *ats)
{
- int array_index;
- int row_index;
- int c, c2;
- double ct_max, ct_min;
-
- int *ja = GNUNET_malloc ((1 + ats->internal.c_mechs*2 + 3 +
- available_quality_metrics) * sizeof (int));
- double *ar = GNUNET_malloc ((1 + ats->internal.c_mechs*2 + 3 +
- available_quality_metrics) * sizeof (double));
-
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Updating problem quality metrics\n");
- row_index = ats->internal.begin_cr;
- array_index = 1;
+ int array_index;
+ int row_index;
+ int c, c2;
+ double ct_max, ct_min;
- for (c=0; c<available_ressources; c++)
- {
- ct_max = ressources[c].c_max;
- ct_min = ressources[c].c_min;
+ int *ja = GNUNET_malloc ((1 + ats->internal.c_mechs * 2 + 3 +
+ available_quality_metrics) * sizeof (int));
+ double *ar = GNUNET_malloc ((1 + ats->internal.c_mechs * 2 + 3 +
+ available_quality_metrics) * sizeof (double));
+
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Updating problem quality metrics\n");
+ row_index = ats->internal.begin_cr;
+ array_index = 1;
+
+ for (c = 0; c < available_ressources; c++)
+ {
+ ct_max = ressources[c].c_max;
+ ct_min = ressources[c].c_min;
#if VERBOSE_ATS
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] %f..%f\n",
- row_index,
- ct_min,
- ct_max);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] %f..%f\n",
+ row_index, ct_min, ct_max);
#endif
- _lp_set_row_bnds(ats->prob, row_index, GLP_DB, ct_min, ct_max);
- for (c2=1; c2<=ats->internal.c_mechs; c2++)
- {
- double value = 0;
- GNUNET_assert (ats->mechanisms[c2].addr != NULL);
- GNUNET_assert (ats->mechanisms[c2].peer != NULL);
+ _lp_set_row_bnds (ats->prob, row_index, GLP_DB, ct_min, ct_max);
+ for (c2 = 1; c2 <= ats->internal.c_mechs; c2++)
+ {
+ double value = 0;
+
+ GNUNET_assert (ats->mechanisms[c2].addr != NULL);
+ GNUNET_assert (ats->mechanisms[c2].peer != NULL);
- ja[array_index] = c2;
- value = ats->mechanisms[c2].ressources[c].c;
- ar[array_index] = value;
+ ja[array_index] = c2;
+ value = ats->mechanisms[c2].ressources[c].c;
+ ar[array_index] = value;
#if VERBOSE_ATS
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
- array_index,
- row_index,
- ja[array_index],
- ar[array_index]);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",
+ array_index, row_index, ja[array_index], ar[array_index]);
#endif
- array_index++;
- }
- _lp_set_mat_row (ats->prob, row_index, array_index, ja, ar);
- row_index ++;
+ array_index++;
}
- GNUNET_free_non_null (ja);
- GNUNET_free_non_null (ar);
+ _lp_set_mat_row (ats->prob, row_index, array_index, ja, ar);
+ row_index++;
+ }
+ GNUNET_free_non_null (ja);
+ GNUNET_free_non_null (ar);
}
-void ats_set_logging_options (struct ATS_Handle * ats,
- struct GNUNET_STATISTICS_Handle * stats,
- const struct GNUNET_CONFIGURATION_Handle *cfg)
+void
+ats_set_logging_options (struct ATS_Handle *ats,
+ struct GNUNET_STATISTICS_Handle *stats,
+ const struct GNUNET_CONFIGURATION_Handle *cfg)
{
int minimum_addresses;
int minimum_peers;
int overwrite_dump;
int log_solution;
int log_problem;
- unsigned long long value;
+ unsigned long long value;
if (ats == NULL)
return;
log_problem = GNUNET_CONFIGURATION_get_value_yesno (cfg,
- "transport",
- "DUMP_MLP");
+ "transport", "DUMP_MLP");
log_solution = GNUNET_CONFIGURATION_get_value_yesno (cfg,
- "transport",
- "DUMP_SOLUTION");
+ "transport",
+ "DUMP_SOLUTION");
overwrite_dump = GNUNET_CONFIGURATION_get_value_yesno (cfg,
- "transport",
- "DUMP_OVERWRITE");
+ "transport",
+ "DUMP_OVERWRITE");
if (GNUNET_OK ==
- GNUNET_CONFIGURATION_get_value_number(cfg,
- "transport",
- "DUMP_MIN_PEERS",
- &value))
+ GNUNET_CONFIGURATION_get_value_number (cfg,
+ "transport",
+ "DUMP_MIN_PEERS", &value))
minimum_peers = (int) value;
if (GNUNET_OK ==
- GNUNET_CONFIGURATION_get_value_number(cfg,
- "transport",
- "DUMP_MIN_ADDRS",
- &value))
+ GNUNET_CONFIGURATION_get_value_number (cfg,
+ "transport",
+ "DUMP_MIN_ADDRS", &value))
minimum_addresses = (int) value;
@@ -1712,64 +1714,58 @@ void ats_set_logging_options (struct ATS_Handle * ats,
}
#if 0
-static void ats_update_problem_qm_TEST ()
+static void
+ats_update_problem_qm_TEST ()
{
- int row_index;
- int c
- int c2;
- int c_old;
- int changed = 0;
-
- int old_ja[ats->internal.c_mechs + 2];
- double old_ar[ats->internal.c_mechs + 2];
-
- int *ja = GNUNET_malloc ((1 + ats->internal.c_mechs*2 + 3 +
- available_quality_metrics) * sizeof (int));
- double *ar = GNUNET_malloc ((1 + ats->internal.c_mechs*2 + 3 +
- available_quality_metrics) * sizeof (double));
+ int row_index;
+ int c int c2;
+ int c_old;
+ int changed = 0;
+
+ int old_ja[ats->internal.c_mechs + 2];
+ double old_ar[ats->internal.c_mechs + 2];
+
+ int *ja = GNUNET_malloc ((1 + ats->internal.c_mechs * 2 + 3 +
+ available_quality_metrics) * sizeof (int));
+ double *ar = GNUNET_malloc ((1 + ats->internal.c_mechs * 2 + 3 +
+ available_quality_metrics) * sizeof (double));
#if DEBUG_ATS
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Updating problem quality metrics TEST\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Updating problem quality metrics TEST\n");
#endif
- if (ats->internal.begin_qm >0)
- row_index = ats->internal.begin_qm;
- else
- return;
- for (c=0; c<available_quality_metrics; c++)
+ if (ats->internal.begin_qm > 0)
+ row_index = ats->internal.begin_qm;
+ else
+ return;
+ for (c = 0; c < available_quality_metrics; c++)
+ {
+ c_old = _lp_get_mat_row (ats->prob, row_index, old_ja, old_ar);
+ _lp_set_row_bnds (ats->prob, row_index, GLP_FX, 0.0, 0.0);
+ for (c2 = 1; c2 <= c_old; c2++)
{
- c_old = _lp_get_mat_row (ats->prob, row_index, old_ja, old_ar);
- _lp_set_row_bnds(ats->prob, row_index, GLP_FX, 0.0, 0.0);
- for (c2=1; c2<=c_old; c2++)
+ ja[c2] = old_ja[c2];
+ if ((changed < 3) && (c2 > 2) && (old_ar[c2] != -1))
{
- ja[c2] = old_ja[c2];
- if ((changed < 3) && (c2>2) && (old_ar[c2] != -1))
- {
- ar[c2] = old_ar[c2] + 5 - changed;
- changed ++;
- }
- else
- ar[c2] = old_ar[c2];
+ ar[c2] = old_ar[c2] + 5 - changed;
+ changed++;
+ }
+ else
+ ar[c2] = old_ar[c2];
#if VERBOSE_ATS
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "[index]=[%i]: old [%i,%i]=%f new [%i,%i]=%f\n",
- c2,
- row_index,
- old_ja[c2],
- old_ar[c2],
- row_index,
- ja[c2],
- ar[c2]);
-#endif
- }
- _lp_set_mat_row (ats->prob, row_index, c_old, ja, ar);
- row_index ++;
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "[index]=[%i]: old [%i,%i]=%f new [%i,%i]=%f\n",
+ c2,
+ row_index, old_ja[c2], old_ar[c2], row_index, ja[c2], ar[c2]);
+#endif
}
- GNUNET_free_non_null (ja);
- GNUNET_free_non_null (ar);
+ _lp_set_mat_row (ats->prob, row_index, c_old, ja, ar);
+ row_index++;
+ }
+ GNUNET_free_non_null (ja);
+ GNUNET_free_non_null (ar);
}
#endif
/* end of transport_ats.c */
-