* highly dependent on the maxmin lmm module.
*/
-/* Copyright (c) 2009, 2010, 2011. The SimGrid Team.
+/* Copyright (c) 2004-2013. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
#include "surf/surfxml_parse_values.h"
#include "surf/surf_resource.h"
#include "surf/surf_resource_lmm.h"
+#include "simgrid/sg_config.h"
#undef GENERIC_LMM_ACTION
#undef GENERIC_ACTION
static int factor_cmp(const void *pa, const void *pb)
{
- return (((s_smpi_factor_t*)pa)->factor > ((s_smpi_factor_t*)pb)->factor);
+ return (((s_smpi_factor_t*)pa)->factor > ((s_smpi_factor_t*)pb)->factor) ? 1 :
+ (((s_smpi_factor_t*)pa)->factor < ((s_smpi_factor_t*)pb)->factor) ? -1 : 0;
}
{
if (!smpi_bw_factor)
smpi_bw_factor =
- parse_factor(surf_cfg_get_string("smpi/bw_factor"));
+ parse_factor(sg_cfg_get_string("smpi/bw_factor"));
unsigned int iter = 0;
s_smpi_factor_t fact;
double current=1.0;
xbt_dynar_foreach(smpi_bw_factor, iter, fact) {
if (size <= fact.factor) {
- XBT_DEBUG("%lf <= %ld return %f", size, fact.factor, current);
+ XBT_DEBUG("%f <= %ld return %f", size, fact.factor, current);
return current;
}else
current=fact.value;
}
- XBT_DEBUG("%lf > %ld return %f", size, fact.factor, current);
+ XBT_DEBUG("%f > %ld return %f", size, fact.factor, current);
return current;
}
{
if (!smpi_lat_factor)
smpi_lat_factor =
- parse_factor(surf_cfg_get_string("smpi/lat_factor"));
+ parse_factor(sg_cfg_get_string("smpi/lat_factor"));
unsigned int iter = 0;
s_smpi_factor_t fact;
double current=1.0;
xbt_dynar_foreach(smpi_lat_factor, iter, fact) {
if (size <= fact.factor) {
- XBT_DEBUG("%lf <= %ld return %f", size, fact.factor, current);
+ XBT_DEBUG("%f <= %ld return %f", size, fact.factor, current);
return current;
}else
current=fact.value;
}
- XBT_DEBUG("%lf > %ld return %f", size, fact.factor, current);
+ XBT_DEBUG("%f > %ld return %f", size, fact.factor, current);
return current;
}
}
#endif
-static double net_share_resources_full(double now)
+static double net_share_resources_full(surf_model_t network_model, double now)
{
s_surf_action_lmm_t s_action;
surf_action_network_CM02_t action = NULL;
xbt_swag_t running_actions =
- surf_network_model->states.running_action_set;
+ network_model->states.running_action_set;
double min;
min = generic_maxmin_share_resources(running_actions,
xbt_swag_offset(s_action,
variable),
- surf_network_model->model_private->maxmin_system,
+ network_model->model_private->maxmin_system,
network_solve);
#define VARIABLE(action) (*((lmm_variable_t*)(((char *) (action)) + xbt_swag_offset(s_action, variable) )))
return min;
}
-static double net_share_resources_lazy(double now)
+static double net_share_resources_lazy(surf_model_t network_model, double now)
{
- return generic_share_resources_lazy(now, surf_network_model);
+ return generic_share_resources_lazy(now, network_model);
}
-static void net_update_actions_state_full(double now, double delta)
+static void net_update_actions_state_full(surf_model_t network_model, double now, double delta)
{
- generic_update_actions_state_full(now, delta, surf_network_model);
+ generic_update_actions_state_full(now, delta, network_model);
}
-static void net_update_actions_state_lazy(double now, double delta)
+static void net_update_actions_state_lazy(surf_model_t network_model, double now, double delta)
{
- generic_update_actions_state_lazy(now, delta, surf_network_model);
+ generic_update_actions_state_lazy(now, delta, network_model);
}
static void net_update_resource_state(void *id,
double value, double date)
{
link_CM02_t nw_link = id;
- /* printf("[" "%lg" "] Asking to update network card \"%s\" with value " */
- /* "%lg" " for event %p\n", surf_get_clock(), nw_link->name, */
+ /* printf("[" "%g" "] Asking to update network card \"%s\" with value " */
+ /* "%g" " for event %p\n", surf_get_clock(), nw_link->name, */
/* value, event_type); */
if (event_type == nw_link->lmm_resource.power.event) {
lmm_constraint_is_shared(((surf_resource_lmm_t) link)->constraint);
}
-static void net_finalize(void)
+static void net_finalize(surf_model_t network_model)
{
- lmm_system_free(surf_network_model->model_private->maxmin_system);
- surf_network_model->model_private->maxmin_system = NULL;
+ lmm_system_free(network_model->model_private->maxmin_system);
+ network_model->model_private->maxmin_system = NULL;
- if (surf_network_model->model_private->update_mechanism == UM_LAZY) {
- xbt_heap_free(surf_network_model->model_private->action_heap);
- xbt_swag_free(surf_network_model->model_private->modified_set);
+ if (network_model->model_private->update_mechanism == UM_LAZY) {
+ xbt_heap_free(network_model->model_private->action_heap);
+ xbt_swag_free(network_model->model_private->modified_set);
}
- surf_model_exit(surf_network_model);
- surf_network_model = NULL;
+ surf_model_exit(network_model);
+ network_model = NULL;
- if (smpi_bw_factor)
- xbt_dynar_free(&smpi_bw_factor);
- if (smpi_lat_factor)
- xbt_dynar_free(&smpi_lat_factor);
+ xbt_dict_free(&gap_lookup);
+ xbt_dynar_free(&smpi_bw_factor);
+ xbt_dynar_free(&smpi_lat_factor);
}
static void smpi_gap_append(double size, const link_CM02_t link,
{
const char *src = link->lmm_resource.generic_resource.name;
xbt_fifo_t fifo;
- surf_action_network_CM02_t last_action;
- double bw;
+ //surf_action_network_CM02_t last_action;
+ //double bw;
if (sg_sender_gap > 0.0) {
if (!gap_lookup) {
- gap_lookup = xbt_dict_new();
+ gap_lookup = xbt_dict_new_homogeneous(NULL);
}
fifo = (xbt_fifo_t) xbt_dict_get_or_null(gap_lookup, src);
action->sender.gap = 0.0;
if (fifo && xbt_fifo_size(fifo) > 0) {
/* Compute gap from last send */
- last_action =
+ /*last_action =
(surf_action_network_CM02_t)
- xbt_fifo_get_item_content(xbt_fifo_get_last_item(fifo));
- bw = net_get_link_bandwidth(link);
- action->sender.gap =
- max(sg_sender_gap,last_action->sender.size / bw);
+ xbt_fifo_get_item_content(xbt_fifo_get_last_item(fifo));*/
+ // bw = net_get_link_bandwidth(link);
+ action->sender.gap = sg_sender_gap;
+ /* max(sg_sender_gap,last_action->sender.size / bw);*/
action->latency += action->sender.gap;
}
/* Append action as last send */
- action->sender.link_name = link->lmm_resource.generic_resource.name;
+ /*action->sender.link_name = link->lmm_resource.generic_resource.name;
fifo =
(xbt_fifo_t) xbt_dict_get_or_null(gap_lookup,
action->sender.link_name);
fifo = xbt_fifo_new();
xbt_dict_set(gap_lookup, action->sender.link_name, fifo, NULL);
}
- action->sender.fifo_item = xbt_fifo_push(fifo, action);
+ action->sender.fifo_item = xbt_fifo_push(fifo, action);*/
action->sender.size = size;
}
}
static void set_update_mechanism(void)
{
- char *optim = xbt_cfg_get_string(_surf_cfg_set, "network/optim");
+ char *optim = xbt_cfg_get_string(_sg_cfg_set, "network/optim");
int select =
- xbt_cfg_get_int(_surf_cfg_set, "network/maxmin_selective_update");
+ xbt_cfg_get_boolean(_sg_cfg_set, "network/maxmin_selective_update");
if (!strcmp(optim, "Full")) {
surf_network_model->model_private->update_mechanism = UM_FULL;
xbt_assert((select == 1)
||
(xbt_cfg_is_default_value
- (_surf_cfg_set, "network/maxmin_selective_update")),
+ (_sg_cfg_set, "network/maxmin_selective_update")),
"Disabling selective update while using the lazy update mechanism is dumb!");
} else {
xbt_die("Unsupported optimization (%s) for this model", optim);
set_update_mechanism();
surf_network_model->name = "network";
+ surf_network_model->type = SURF_MODEL_TYPE_NETWORK;
surf_network_model->action_unref = surf_action_unref;
surf_network_model->action_cancel = surf_action_cancel;
surf_network_model->action_recycle = net_action_recycle;
surf_network_model->suspend = surf_action_suspend;
surf_network_model->resume = surf_action_resume;
surf_network_model->is_suspended = surf_action_is_suspended;
- surf_cpu_model->set_max_duration = surf_action_set_max_duration;
+
+ xbt_assert(surf_cpu_model_pm);
+ xbt_assert(surf_cpu_model_vm);
+ surf_cpu_model_pm->set_max_duration = surf_action_set_max_duration;
+ surf_cpu_model_vm->set_max_duration = surf_action_set_max_duration;
surf_network_model->extension.network.communicate = net_communicate;
surf_network_model->extension.network.get_route = net_get_route;
net_get_link_latency;
surf_network_model->extension.network.link_shared = net_link_shared;
surf_network_model->extension.network.add_traces = net_add_traces;
- surf_network_model->extension.network.create_resource =
- net_create_resource;
if (!surf_network_model->model_private->maxmin_system)
surf_network_model->model_private->maxmin_system = lmm_system_new(surf_network_model->model_private->selective_update);
xbt_dynar_push(model_list, &surf_network_model);
network_solve = lmm_solve;
- xbt_cfg_setdefault_double(_surf_cfg_set, "network/sender_gap", 10e-6);
- xbt_cfg_setdefault_double(_surf_cfg_set, "network/weight_S", 8775);
+ xbt_cfg_setdefault_double(_sg_cfg_set, "network/sender_gap", 10e-6);
+ xbt_cfg_setdefault_double(_sg_cfg_set, "network/weight_S", 8775);
}
/************************************************************************/
xbt_dynar_push(model_list, &surf_network_model);
network_solve = lmm_solve;
- xbt_cfg_setdefault_double(_surf_cfg_set, "network/latency_factor",
+ xbt_cfg_setdefault_double(_sg_cfg_set, "network/latency_factor",
13.01);
- xbt_cfg_setdefault_double(_surf_cfg_set, "network/bandwidth_factor",
+ xbt_cfg_setdefault_double(_sg_cfg_set, "network/bandwidth_factor",
0.97);
- xbt_cfg_setdefault_double(_surf_cfg_set, "network/weight_S", 20537);
+ xbt_cfg_setdefault_double(_sg_cfg_set, "network/weight_S", 20537);
}
/***************************************************************************/
xbt_dynar_push(model_list, &surf_network_model);
network_solve = lmm_solve;
- xbt_cfg_setdefault_double(_surf_cfg_set, "network/latency_factor", 1.0);
- xbt_cfg_setdefault_double(_surf_cfg_set, "network/bandwidth_factor",
+ xbt_cfg_setdefault_double(_sg_cfg_set, "network/latency_factor", 1.0);
+ xbt_cfg_setdefault_double(_sg_cfg_set, "network/bandwidth_factor",
1.0);
- xbt_cfg_setdefault_double(_surf_cfg_set, "network/weight_S", 0.0);
+ xbt_cfg_setdefault_double(_sg_cfg_set, "network/weight_S", 0.0);
}
/***************************************************************************/
func_reno_fpi);
network_solve = lagrange_solve;
- xbt_cfg_setdefault_double(_surf_cfg_set, "network/latency_factor", 10.4);
- xbt_cfg_setdefault_double(_surf_cfg_set, "network/bandwidth_factor",
+ xbt_cfg_setdefault_double(_sg_cfg_set, "network/latency_factor", 10.4);
+ xbt_cfg_setdefault_double(_sg_cfg_set, "network/bandwidth_factor",
0.92);
- xbt_cfg_setdefault_double(_surf_cfg_set, "network/weight_S", 8775);
+ xbt_cfg_setdefault_double(_sg_cfg_set, "network/weight_S", 8775);
}
func_reno2_fpi);
network_solve = lagrange_solve;
- xbt_cfg_setdefault_double(_surf_cfg_set, "network/latency_factor", 10.4);
- xbt_cfg_setdefault_double(_surf_cfg_set, "network/bandwidth_factor",
+ xbt_cfg_setdefault_double(_sg_cfg_set, "network/latency_factor", 10.4);
+ xbt_cfg_setdefault_double(_sg_cfg_set, "network/bandwidth_factor",
0.92);
- xbt_cfg_setdefault_double(_surf_cfg_set, "network/weight_S_parameter",
+ xbt_cfg_setdefault_double(_sg_cfg_set, "network/weight_S_parameter",
8775);
}
func_vegas_fpi);
network_solve = lagrange_solve;
- xbt_cfg_setdefault_double(_surf_cfg_set, "network/latency_factor", 10.4);
- xbt_cfg_setdefault_double(_surf_cfg_set, "network/bandwidth_factor",
+ xbt_cfg_setdefault_double(_sg_cfg_set, "network/latency_factor", 10.4);
+ xbt_cfg_setdefault_double(_sg_cfg_set, "network/bandwidth_factor",
0.92);
- xbt_cfg_setdefault_double(_surf_cfg_set, "network/weight_S", 8775);
+ xbt_cfg_setdefault_double(_sg_cfg_set, "network/weight_S", 8775);
}
