/**
* Convert quota from text to numeric value.
*
* @param quota_str the value found in the configuration
* @param direction direction of the quota
* @param network network the quota applies to
* @return numeric quota value to use
*/
static unsigned long long
parse_quota (const char *quota_str,
const char *direction,
enum GNUNET_ATS_Network_Type network)
{
int res;
unsigned long long ret;
res = GNUNET_NO;
if (0 == strcmp (quota_str, GNUNET_ATS_MaxBandwidthString))
{
ret = GNUNET_ATS_MaxBandwidth;
res = GNUNET_YES;
}
if ((GNUNET_NO == res) &&
(GNUNET_OK ==
GNUNET_STRINGS_fancy_size_to_bytes (quota_str,
&ret)))
res = GNUNET_YES;
if ((GNUNET_NO == res) &&
(1 ==
sscanf (quota_str,
"%llu",
&ret)))
res = GNUNET_YES;
if (GNUNET_NO == res)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Could not load %s quota for network `%s': `%s', assigning default bandwidth %llu\n"),
direction,
GNUNET_ATS_print_network_type (network),
quota_str,
GNUNET_ATS_DefaultBandwidth);
ret = GNUNET_ATS_DefaultBandwidth;
}
else
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
_("%s quota configured for network `%s' is %llu\n"),
direction,
GNUNET_ATS_print_network_type (network),
ret);
}
return ret;
}
/**
* Init the MLP problem solving component
*
* @param cfg the GNUNET_CONFIGURATION_Handle handle
* @param stats the GNUNET_STATISTICS handle
* @param max_duration maximum numbers of iterations for the LP/MLP Solver
* @param max_iterations maximum time limit for the LP/MLP Solver
* @return struct GAS_MLP_Handle * on success, NULL on fail
*/
struct GAS_MLP_Handle *
GAS_mlp_init (const struct GNUNET_CONFIGURATION_Handle *cfg,
const struct GNUNET_STATISTICS_Handle *stats,
struct GNUNET_TIME_Relative max_duration,
unsigned int max_iterations)
{
struct GAS_MLP_Handle * mlp = GNUNET_malloc (sizeof (struct GAS_MLP_Handle));
double D;
double R;
double U;
unsigned long long tmp;
unsigned int b_min;
unsigned int n_min;
struct GNUNET_TIME_Relative i_exec;
int c;
char * quota_out_str;
char * quota_in_str;
/* Init GLPK environment */
int res = glp_init_env();
switch (res) {
case 0:
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "GLPK: `%s'\n",
"initialization successful");
break;
case 1:
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "GLPK: `%s'\n",
"environment is already initialized");
break;
case 2:
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not init GLPK: `%s'\n",
"initialization failed (insufficient memory)");
GNUNET_free(mlp);
return NULL;
break;
case 3:
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not init GLPK: `%s'\n",
"initialization failed (unsupported programming model)");
GNUNET_free(mlp);
return NULL;
break;
default:
break;
}
/* Create initial MLP problem */
mlp->prob = glp_create_prob();
GNUNET_assert (mlp->prob != NULL);
mlp->BIG_M = (double) BIG_M_VALUE;
/* Get diversity coefficient from configuration */
if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_size (cfg, "ats",
"COEFFICIENT_D",
&tmp))
D = (double) tmp / 100;
else
D = 1.0;
/* Get proportionality coefficient from configuration */
if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_size (cfg, "ats",
"COEFFICIENT_R",
&tmp))
R = (double) tmp / 100;
else
R = 1.0;
/* Get utilization coefficient from configuration */
if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_size (cfg, "ats",
"COEFFICIENT_U",
&tmp))
U = (double) tmp / 100;
else
U = 1.0;
/* Get quality metric coefficients from configuration */
int i_delay = -1;
int i_distance = -1;
int q[GNUNET_ATS_QualityPropertiesCount] = GNUNET_ATS_QualityProperties;
for (c = 0; c < GNUNET_ATS_QualityPropertiesCount; c++)
{
/* initialize quality coefficients with default value 1.0 */
mlp->co_Q[c] = 1.0;
mlp->q[c] = q[c];
if (q[c] == GNUNET_ATS_QUALITY_NET_DELAY)
i_delay = c;
if (q[c] == GNUNET_ATS_QUALITY_NET_DISTANCE)
i_distance = c;
}
if ((i_delay != -1) && (GNUNET_OK == GNUNET_CONFIGURATION_get_value_size (cfg, "ats",
"COEFFICIENT_QUALITY_DELAY",
&tmp)))
mlp->co_Q[i_delay] = (double) tmp / 100;
else
mlp->co_Q[i_delay] = 1.0;
if ((i_distance != -1) && (GNUNET_OK == GNUNET_CONFIGURATION_get_value_size (cfg, "ats",
"COEFFICIENT_QUALITY_DISTANCE",
&tmp)))
mlp->co_Q[i_distance] = (double) tmp / 100;
else
mlp->co_Q[i_distance] = 1.0;
/* Get minimum bandwidth per used address from configuration */
if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_size (cfg, "ats",
"MIN_BANDWIDTH",
&tmp))
b_min = tmp;
else
{
b_min = ntohl (GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT.value__);
}
/* Get minimum number of connections from configuration */
if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_size (cfg, "ats",
"MIN_CONNECTIONS",
&tmp))
n_min = tmp;
else
n_min = 4;
/* Init network quotas */
int quotas[GNUNET_ATS_NetworkTypeCount] = GNUNET_ATS_NetworkType;
for (c = 0; c < GNUNET_ATS_NetworkTypeCount; c++)
{
mlp->quota_index[c] = quotas[c];
static char * entry_in = NULL;
static char * entry_out = NULL;
unsigned long long quota_in = 0;
unsigned long long quota_out = 0;
switch (quotas[c]) {
case GNUNET_ATS_NET_UNSPECIFIED:
entry_out = "UNSPECIFIED_QUOTA_OUT";
entry_in = "UNSPECIFIED_QUOTA_IN";
break;
case GNUNET_ATS_NET_LOOPBACK:
entry_out = "LOOPBACK_QUOTA_OUT";
entry_in = "LOOPBACK_QUOTA_IN";
break;
case GNUNET_ATS_NET_LAN:
entry_out = "LAN_QUOTA_OUT";
entry_in = "LAN_QUOTA_IN";
break;
case GNUNET_ATS_NET_WAN:
entry_out = "WAN_QUOTA_OUT";
entry_in = "WAN_QUOTA_IN";
break;
case GNUNET_ATS_NET_WLAN:
entry_out = "WLAN_QUOTA_OUT";
entry_in = "WLAN_QUOTA_IN";
break;
default:
break;
}
if ((entry_in == NULL) || (entry_out == NULL))
continue;
if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, "ats", entry_out, "a_out_str))
{
if (0 == strcmp(quota_out_str, BIG_M_STRING) ||
(GNUNET_SYSERR == GNUNET_STRINGS_fancy_size_to_bytes (quota_out_str, "a_out)))
quota_out = mlp->BIG_M;
GNUNET_free (quota_out_str);
quota_out_str = NULL;
}
else if (GNUNET_ATS_NET_UNSPECIFIED == quotas[c])
{
quota_out = mlp->BIG_M;
}
else
{
quota_out = mlp->BIG_M;
}
if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, "ats", entry_in, "a_in_str))
{
if (0 == strcmp(quota_in_str, BIG_M_STRING) ||
(GNUNET_SYSERR == GNUNET_STRINGS_fancy_size_to_bytes (quota_in_str, "a_in)))
quota_in = mlp->BIG_M;
GNUNET_free (quota_in_str);
quota_in_str = NULL;
}
else if (GNUNET_ATS_NET_UNSPECIFIED == quotas[c])
{
quota_in = mlp->BIG_M;
}
else
{
quota_in = mlp->BIG_M;
}
/* Check if defined quota could make problem unsolvable */
if (((n_min * b_min) > quota_out) && (GNUNET_ATS_NET_UNSPECIFIED != quotas[c]))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Inconsistent quota configuration value `%s': "
"outbound quota (%u Bps) too small for combination of minimum connections and minimum bandwidth per peer (%u * %u Bps = %u)\n", entry_out, quota_out, n_min, b_min, n_min * b_min);
GAS_mlp_done(mlp);
mlp = NULL;
return NULL;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found `%s' quota %llu and `%s' quota %llu\n",
entry_out, quota_out, entry_in, quota_in);
GNUNET_STATISTICS_update ((struct GNUNET_STATISTICS_Handle *) stats, entry_out, quota_out, GNUNET_NO);
GNUNET_STATISTICS_update ((struct GNUNET_STATISTICS_Handle *) stats, entry_in, quota_in, GNUNET_NO);
mlp->quota_out[c] = quota_out;
mlp->quota_in[c] = quota_in;
}
/* Get minimum number of connections from configuration */
if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_time (cfg, "ats",
"ATS_EXEC_INTERVAL",
&i_exec))
mlp->exec_interval = i_exec;
else
mlp->exec_interval = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 30);
mlp->stats = (struct GNUNET_STATISTICS_Handle *) stats;
mlp->max_iterations = max_iterations;
mlp->max_exec_duration = max_duration;
mlp->auto_solve = GNUNET_YES;
/* Redirect GLPK output to GNUnet logging */
glp_error_hook((void *) mlp, &mlp_term_hook);
/* Init LP solving parameters */
glp_init_smcp(&mlp->control_param_lp);
mlp->control_param_lp.msg_lev = GLP_MSG_OFF;
#if VERBOSE_GLPK
mlp->control_param_lp.msg_lev = GLP_MSG_ALL;
#endif
mlp->control_param_lp.it_lim = max_iterations;
mlp->control_param_lp.tm_lim = max_duration.rel_value;
/* Init MLP solving parameters */
glp_init_iocp(&mlp->control_param_mlp);
mlp->control_param_mlp.msg_lev = GLP_MSG_OFF;
#if VERBOSE_GLPK
mlp->control_param_mlp.msg_lev = GLP_MSG_ALL;
#endif
mlp->control_param_mlp.tm_lim = max_duration.rel_value;
mlp->last_execution = GNUNET_TIME_UNIT_FOREVER_ABS;
mlp->co_D = D;
mlp->co_R = R;
mlp->co_U = U;
mlp->b_min = b_min;
mlp->n_min = n_min;
mlp->m_q = GNUNET_ATS_QualityPropertiesCount;
mlp->semaphore = GNUNET_NO;
return mlp;
}
/**
* Initialize address subsystem.
*
* @param cfg configuration to use
* @param stats the statistics handle to use
*/
void
GAS_addresses_init (const struct GNUNET_CONFIGURATION_Handle *cfg,
const struct GNUNET_STATISTICS_Handle *stats)
{
int mode;
char *quota_wan_in_str;
char *quota_wan_out_str;
running = GNUNET_NO;
addresses = GNUNET_CONTAINER_multihashmap_create (128);
GNUNET_assert (NULL != addresses);
if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, "ats", "WAN_QUOTA_IN", "a_wan_in_str))
{
if (0 == strcmp(quota_wan_in_str, "unlimited") ||
(GNUNET_SYSERR == GNUNET_STRINGS_fancy_size_to_bytes (quota_wan_in_str, &wan_quota_in)))
wan_quota_in = (UINT32_MAX) /10;
GNUNET_free (quota_wan_in_str);
quota_wan_in_str = NULL;
}
else
{
wan_quota_in = (UINT32_MAX) /10;
}
if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, "ats", "WAN_QUOTA_OUT", "a_wan_out_str))
{
if (0 == strcmp(quota_wan_out_str, "unlimited") ||
(GNUNET_SYSERR == GNUNET_STRINGS_fancy_size_to_bytes (quota_wan_out_str, &wan_quota_out)))
wan_quota_out = (UINT32_MAX) /10;
GNUNET_free (quota_wan_out_str);
quota_wan_out_str = NULL;
}
else
{
wan_quota_out = (UINT32_MAX) /10;
}
mode = GNUNET_CONFIGURATION_get_value_yesno (cfg, "ats", "MLP");
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MLP mode %u", mode);
switch (mode)
{
/* MLP = YES */
case GNUNET_YES:
#if HAVE_LIBGLPK
ats_mode = MLP;
/* Init the MLP solver with default values */
mlp = GAS_mlp_init (cfg, stats, MLP_MAX_EXEC_DURATION, MLP_MAX_ITERATIONS);
if (NULL == mlp)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "MLP mode was configured, but libglpk is not installed, switching to simple mode\n");
GNUNET_STATISTICS_update (GSA_stats, "MLP mode enabled", 0, GNUNET_NO);
break;
}
else
{
GNUNET_STATISTICS_update (GSA_stats, "MLP enabled", 1, GNUNET_NO);
break;
}
#else
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "MLP mode was configured, but libglpk is not installed, switching to simple mode");
GNUNET_STATISTICS_update (GSA_stats, "MLP enabled", 0, GNUNET_NO);
ats_mode = SIMPLE;
break;
#endif
/* MLP = NO */
case GNUNET_NO:
GNUNET_STATISTICS_update (GSA_stats, "MLP enabled", 0, GNUNET_NO);
ats_mode = SIMPLE;
break;
/* No configuration value */
case GNUNET_SYSERR:
GNUNET_STATISTICS_update (GSA_stats, "MLP enabled", 0, GNUNET_NO);
ats_mode = SIMPLE;
break;
default:
break;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ATS started with %s mode\n", (SIMPLE == ats_mode) ? "SIMPLE" : "MLP");
running = GNUNET_YES;
}
static void
run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTING_Peer *peer)
{
char *quota_str;
if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, "ats", "WAN_QUOTA_OUT", "a_str))
{
fprintf (stderr, "Cannot load WAN outbound quota from configuration, exit!\n");
ret = 1;
return;
}
if (GNUNET_SYSERR == GNUNET_STRINGS_fancy_size_to_bytes (quota_str, &wan_quota_out))
{
fprintf (stderr, "Cannot load WAN outbound quota from configuration, exit!\n");
ret = 1;
GNUNET_free (quota_str);
return;
}
GNUNET_free (quota_str);
quota_str = NULL;
if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, "ats", "WAN_QUOTA_IN", "a_str))
{
fprintf (stderr, "Cannot load WAN inbound quota from configuration, exit!\n");
ret = 1;
return;
}
if (GNUNET_SYSERR == GNUNET_STRINGS_fancy_size_to_bytes (quota_str, &wan_quota_in))
{
fprintf (stderr, "Cannot load WAN inbound quota from configuration, exit!\n");
GNUNET_free (quota_str);
ret = 1;
return;
}
GNUNET_free (quota_str);
quota_str = NULL;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Configured WAN inbound quota: %llu\n", wan_quota_in);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Configured WAN outbound quota: %llu\n", wan_quota_out);
die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
/* Connect to ATS scheduling */
sched_ats = GNUNET_ATS_scheduling_init (cfg, &address_suggest_cb, NULL);
if (sched_ats == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not connect to ATS scheduling!\n");
ret = 1;
end ();
return;
}
perf_ats = GNUNET_ATS_performance_init (cfg, NULL, NULL);
if (perf_ats == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not connect to ATS performance!\n");
ret = 1;
end ();
return;
}
/* Set up peer 0 */
if (GNUNET_SYSERR == GNUNET_CRYPTO_hash_from_string(PEERID0, &p[0].id.hashPubKey))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not setup peer!\n");
ret = GNUNET_SYSERR;
end ();
return;
}
GNUNET_assert (0 == strcmp (PEERID0, GNUNET_i2s_full (&p[0].id)));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Created peer `%s'\n",
GNUNET_i2s(&p[0].id));
/* Set up peer 0 */
if (GNUNET_SYSERR == GNUNET_CRYPTO_hash_from_string(PEERID1, &p[1].id.hashPubKey))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not setup peer!\n");
ret = GNUNET_SYSERR;
end ();
return;
}
GNUNET_assert (0 == strcmp (PEERID1, GNUNET_i2s_full (&p[1].id)));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Created peer `%s'\n",
GNUNET_i2s(&p[1].id));
/* Prepare ATS Information */
test_ats_info[0].type = htonl (GNUNET_ATS_NETWORK_TYPE);
test_ats_info[0].value = htonl(GNUNET_ATS_NET_WAN);
test_ats_info[1].type = htonl (GNUNET_ATS_QUALITY_NET_DISTANCE);
test_ats_info[1].value = htonl(1);
test_ats_count = 2;
/* Adding address with session */
test_session[0] = &test_addr[0];
create_test_address (&test_addr[0], "test0", test_session[0], "test0", strlen ("test0") + 1);
test_hello_address[0].peer = p[0].id;
test_hello_address[0].transport_name = test_addr[0].plugin;
test_hello_address[0].address = test_addr[0].addr;
test_hello_address[0].address_length = test_addr[0].addr_len;
GNUNET_ATS_address_add (sched_ats, &test_hello_address[0], test_session[0], test_ats_info, test_ats_count);
/* Adding address with session */
test_session[1] = &test_addr[1];
create_test_address (&test_addr[1], "test1", test_session[1], "test1", strlen ("test1") + 1);
test_hello_address[1].peer = p[1].id;
test_hello_address[1].transport_name = test_addr[0].plugin;
test_hello_address[1].address = test_addr[0].addr;
test_hello_address[1].address_length = test_addr[0].addr_len;
GNUNET_ATS_address_add (sched_ats, &test_hello_address[1], test_session[1], test_ats_info, test_ats_count);
/* Change bandwidth preference */
GNUNET_ATS_change_preference (perf_ats,
&p[0].id,
GNUNET_ATS_PREFERENCE_BANDWIDTH,(double) 1000, GNUNET_ATS_PREFERENCE_END);
GNUNET_ATS_change_preference (perf_ats,
&p[1].id,
GNUNET_ATS_PREFERENCE_BANDWIDTH,(double) 1000, GNUNET_ATS_PREFERENCE_END);
/* Change latency preference */
GNUNET_ATS_change_preference (perf_ats,
&p[0].id,
GNUNET_ATS_PREFERENCE_LATENCY,(double) 10, GNUNET_ATS_PREFERENCE_END);
GNUNET_ATS_change_preference (perf_ats,
&p[1].id,
GNUNET_ATS_PREFERENCE_LATENCY,(double) 100, GNUNET_ATS_PREFERENCE_END);
GNUNET_SCHEDULER_add_delayed (SLEEP, &sleep_task, NULL);
}
