action_get_state -> action_state_get
* Change model methods into classical functions:
action_use -> surf_action_ref
+ * Use dynar to represent routes
XBT:
* Add xbt_set_get_by_name_or_null() [Silas De Munck]
typedef struct surf_network_model_extension_public {
surf_action_t(*communicate) (void *src, void *dst, double size,
double max_rate);
- const void **(*get_route) (void *src, void *dst);
- int (*get_route_size) (void *src, void *dst);
+ xbt_dynar_t (*get_route) (void *src, void *dst);
double (*get_link_bandwidth) (const void *link);
double (*get_link_latency) (const void *link);
int (*link_shared) (const void *link);
double *computation_amount,
double *communication_amount,
double amount, double rate);
- const void **(*get_route) (void *src, void *dst); /**< Return the network link list between two workstations */
- int (*get_route_size) (void *src, void *dst); /**< Return the route size between two workstations */
+ xbt_dynar_t (*get_route) (void *src, void *dst); /**< Return the network link list between two workstations */
double (*get_link_bandwidth) (const void *link); /**< Return the current bandwidth of a network link */
double (*get_link_latency) (const void *link); /**< Return the current latency of a network link */
int (*link_shared) (const void *link);
{
void *surf_src;
void *surf_dst;
- const void **surf_route;
- int route_size;
+ xbt_dynar_t surf_route;
const char *link_name;
- int i;
+ void *surf_link;
+ unsigned int cpt;
SD_CHECK_INIT_DONE();
surf_route =
surf_workstation_model->extension.workstation.get_route(surf_src,
surf_dst);
- route_size =
- surf_workstation_model->extension.workstation.get_route_size(surf_src,
- surf_dst);
-
- for (i = 0; i < route_size; i++) {
- link_name = surf_resource_name(surf_route[i]);
- sd_global->recyclable_route[i] =
+ xbt_dynar_foreach(surf_route, cpt, surf_link) {
+ link_name = surf_resource_name(surf_link);
+ sd_global->recyclable_route[cpt] =
xbt_dict_get(sd_global->links, link_name);
}
int SD_route_get_size(SD_workstation_t src, SD_workstation_t dst)
{
SD_CHECK_INIT_DONE();
- return surf_workstation_model->extension.workstation.
- get_route_size(src->surf_workstation, dst->surf_workstation);
+ return xbt_dynar_length(surf_workstation_model->extension.workstation.get_route(
+ src->surf_workstation,dst->surf_workstation));
}
/**
int card_number = 0;
int host_number = 0;
-link_CM02_t **routing_table = NULL;
-int *routing_table_size = NULL;
+xbt_dynar_t *routing_table = NULL;
static link_CM02_t loopback = NULL;
double sg_tcp_gamma = 0.0;
static void create_routing_table(void)
{
- routing_table = xbt_new0(link_CM02_t *, /*card_number * card_number */
+ int i,j;
+ routing_table = xbt_new0(xbt_dynar_t, /*card_number * card_number */
host_number * host_number);
- routing_table_size =
- xbt_new0(int, /*card_number * card_number */ host_number * host_number);
+ for (i=0;i<host_number;i++)
+ for (j=0;j<host_number;j++)
+ ROUTE(i,j) = xbt_dynar_new(sizeof(link_CM02_t),NULL);
+
}
static void link_free(void *nw_link)
return card->id;
}
-static void route_new(int src_id, int dst_id,
- link_CM02_t * link_list, int nb_link)
-{
- ROUTE_SIZE(src_id, dst_id) = nb_link;
- ROUTE(src_id, dst_id) = link_list =
- xbt_realloc(link_list, sizeof(link_CM02_t) * nb_link);
-}
-
static void parse_link_init(void)
{
char *name_link;
int i;
/* Adding loopback if needed */
for (i = 0; i < host_number; i++)
- if (!ROUTE_SIZE(i, i)) {
+ if (!xbt_dynar_length(ROUTE(i, i))) {
if (!loopback)
loopback = link_new(xbt_strdup("__MSG_loopback__"),
498000000, NULL, 0.000015, NULL,
SURF_LINK_ON, NULL, SURF_LINK_FATPIPE, NULL);
- ROUTE_SIZE(i, i) = 1;
- ROUTE(i, i) = xbt_new0(link_CM02_t, 1);
- ROUTE(i, i)[0] = loopback;
+ ROUTE(i, i) = xbt_dynar_new(sizeof(link_CM02_t),NULL);
+ xbt_dynar_push(ROUTE(i,i),&loopback);
}
}
xbt_ex_t e;
int nb_link = 0;
unsigned int cpt = 0;
- int link_list_capacity = 0;
- link_CM02_t *link_list = NULL;
xbt_dict_cursor_t cursor = NULL;
char *key, *data, *end;
const char *sep = "#";
create_routing_table();
xbt_dict_foreach(route_table, cursor, key, data) {
- char *link = NULL;
+ char *link_name = NULL;
nb_link = 0;
links = (xbt_dynar_t) data;
keys = xbt_str_split_str(key, sep);
- link_list_capacity = xbt_dynar_length(links);
- link_list = xbt_new(link_CM02_t, link_list_capacity);
-
src_id = strtol(xbt_dynar_get_as(keys, 0, char *), &end, 16);
dst_id = strtol(xbt_dynar_get_as(keys, 1, char *), &end, 16);
xbt_dynar_free(&keys);
- xbt_dynar_foreach(links, cpt, link) {
+ xbt_dynar_foreach(links, cpt, link_name) {
TRY {
- link_list[nb_link++] = xbt_dict_get(link_set, link);
+ link_CM02_t link = xbt_dict_get(link_set, link_name);
+ xbt_dynar_push(ROUTE(src_id,dst_id),&link);
}
CATCH(e) {
- RETHROW1("Link %s not found (dict raised this exception: %s)", link);
+ RETHROW1("Link %s not found (dict raised this exception: %s)", link_name);
}
}
- route_new(src_id, dst_id, link_list, nb_link);
}
+
+ int i,j;
+ for (i=0;i<host_number;i++)
+ for (j=0;j<host_number;j++)
+ xbt_dynar_shrink(ROUTE(i,j),0);
}
static void count_hosts(void)
Use the cluster_id for ->id */
network_card_CM02_t card_src = src;
network_card_CM02_t card_dst = dst;
- int route_size = ROUTE_SIZE(card_src->id, card_dst->id);
- link_CM02_t *route = ROUTE(card_src->id, card_dst->id);
+ xbt_dynar_t route = ROUTE(card_src->id, card_dst->id);
/* LARGE PLATFORMS HACK:
total_route_size = route_size + src->link_nb + dst->nb */
- int i;
+ unsigned int i;
XBT_IN4("(%s,%s,%g,%g)", card_src->generic_resource.name, card_dst->generic_resource.name, size, rate);
/* LARGE PLATFORMS HACK:
assert on total_route_size */
- xbt_assert2(route_size,
- "You're trying to send data from %s to %s but there is no connexion between these two cards.",
+ xbt_assert2(xbt_dynar_length(route),
+ "You're trying to send data from %s to %s but there is no connection between these two cards.",
card_src->generic_resource.name, card_dst->generic_resource.name);
action = xbt_new0(s_surf_action_network_CM02_t, 1);
calloc but it seems to help valgrind... */
action->generic_action.state_set =
surf_network_model->states.running_action_set;
- for (i = 0; i < route_size; i++)
- if (route[i]->state_current == SURF_LINK_OFF) {
+
+ link_CM02_t link;
+ xbt_dynar_foreach(route,i,link) {
+ if (link->state_current == SURF_LINK_OFF) {
action->generic_action.state_set =
surf_network_model->states.failed_action_set;
break;
}
+ }
xbt_swag_insert(action, action->generic_action.state_set);
action->rate = rate;
action->latency = 0.0;
action->weight = 0.0;
- for (i = 0; i < route_size; i++) {
- action->latency += route[i]->lat_current;
+ xbt_dynar_foreach(route,i,link) {
+ action->latency += link->lat_current;
action->weight +=
- route[i]->lat_current + weight_S_parameter / route[i]->bw_current;
+ link->lat_current + weight_S_parameter / link->bw_current;
}
/* LARGE PLATFORMS HACK:
Add src->link and dst->link latencies */
lmm_variable_new(..., total_route_size) */
if (action->latency > 0)
action->variable =
- lmm_variable_new(network_maxmin_system, action, 0.0, -1.0, route_size);
+ lmm_variable_new(network_maxmin_system, action, 0.0, -1.0, xbt_dynar_length(route));
else
action->variable =
- lmm_variable_new(network_maxmin_system, action, 1.0, -1.0, route_size);
+ lmm_variable_new(network_maxmin_system, action, 1.0, -1.0, xbt_dynar_length(route));
if (action->rate < 0) {
if (action->lat_current > 0)
action->rate);
}
- for (i = 0; i < route_size; i++)
- lmm_expand(network_maxmin_system, route[i]->constraint,
+ xbt_dynar_foreach(route,i,link) {
+ lmm_expand(network_maxmin_system, link->constraint,
action->variable, 1.0);
+ }
/* LARGE PLATFORMS HACK:
expand also with src->link and dst->link */
}
/* returns an array of link_CM02_t */
-static const void **get_route(void *src, void *dst)
-{
- network_card_CM02_t card_src = src;
- network_card_CM02_t card_dst = dst;
- return (const void **) ROUTE(card_src->id, card_dst->id);
-}
-
-static int get_route_size(void *src, void *dst)
+static xbt_dynar_t get_route(void *src, void *dst)
{
network_card_CM02_t card_src = src;
network_card_CM02_t card_dst = dst;
- return ROUTE_SIZE(card_src->id, card_dst->id);
+ return ROUTE(card_src->id, card_dst->id);
}
static double get_link_bandwidth(const void *link)
loopback = NULL;
for (i = 0; i < host_number; i++)
for (j = 0; j < host_number; j++)
- free(ROUTE(i, j));
+ xbt_dynar_free(&ROUTE(i, j));
free(routing_table);
routing_table = NULL;
- free(routing_table_size);
- routing_table_size = NULL;
host_number = 0;
lmm_system_free(network_maxmin_system);
network_maxmin_system = NULL;
surf_network_model->extension.network.communicate = communicate;
surf_network_model->extension.network.get_route = get_route;
- surf_network_model->extension.network.get_route_size = get_route_size;
surf_network_model->extension.network.get_link_bandwidth =
get_link_bandwidth;
surf_network_model->extension.network.get_link_latency = get_link_latency;
}
/* returns an array of link_Constant_t */
-static const void **get_route(void *src, void *dst)
+static xbt_dynar_t get_route(void *src, void *dst)
{
- xbt_assert0(0, "Calling this function does not make any sense");
- return (const void **) NULL;
-}
-
-static int get_route_size(void *src, void *dst)
-{
- xbt_assert0(0, "Calling this function does not make any sense");
- return 0;
+ xbt_die("Calling this function does not make any sense");
}
static double get_link_bandwidth(const void *link)
surf_network_model->extension.network.communicate = communicate;
surf_network_model->extension.network.get_route = get_route;
- surf_network_model->extension.network.get_route_size = get_route_size;
surf_network_model->extension.network.get_link_bandwidth =
get_link_bandwidth;
surf_network_model->extension.network.get_link_latency = get_link_latency;
} s_surf_action_network_CM02_t, *surf_action_network_CM02_t;
extern int card_number;
-extern link_CM02_t **routing_table;
-extern int *routing_table_size;
+extern xbt_dynar_t *routing_table;
#define ROUTE(i,j) routing_table[(i)+(j)*host_number]
-#define ROUTE_SIZE(i,j) routing_table_size[(i)+(j)*host_number]
#endif /* _SURF_NETWORK_PRIVATE_H */
/* returns an array of network_link_CM02_t */
-static const void **get_route(void *src, void *dst)
+static xbt_dynar_t get_route(void *src, void *dst)
{
workstation_CLM03_t workstation_src = (workstation_CLM03_t) src;
workstation_CLM03_t workstation_dst = (workstation_CLM03_t) dst;
network_card);
}
-static int get_route_size(void *src, void *dst)
-{
- workstation_CLM03_t workstation_src = (workstation_CLM03_t) src;
- workstation_CLM03_t workstation_dst = (workstation_CLM03_t) dst;
- return surf_network_model->extension.
- network.get_route_size(workstation_src->network_card,
- workstation_dst->network_card);
-}
-
static double get_link_bandwidth(const void *link)
{
return surf_network_model->extension.network.get_link_bandwidth(link);
surf_workstation_model->extension.workstation.execute_parallel_task =
execute_parallel_task;
surf_workstation_model->extension.workstation.get_route = get_route;
- surf_workstation_model->extension.workstation.get_route_size =
- get_route_size;
surf_workstation_model->extension.workstation.get_link_bandwidth =
get_link_bandwidth;
surf_workstation_model->extension.workstation.get_link_latency =
tmgr_trace_event_t state_event;
} s_link_L07_t, *link_L07_t;
-
-typedef struct s_route_L07 {
- link_L07_t *links;
- int size;
-} s_route_L07_t, *route_L07_t;
-
/**************************************/
/*************** actions **************/
/**************************************/
XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(surf_workstation);
static int nb_workstation = 0;
-static s_route_L07_t *routing_table = NULL;
+static xbt_dynar_t *routing_table = NULL;
#define ROUTE(i,j) routing_table[(i)+(j)*nb_workstation]
static link_L07_t loopback = NULL;
static xbt_dict_t parallel_task_link_set = NULL;
int workstation_nb = action->workstation_nb;
double lat_current = 0.0;
double lat_bound = -1.0;
- int i, j, k;
+ int i, j;
+ unsigned int cpt;
+ link_L07_t link;
for (i = 0; i < workstation_nb; i++) {
for (j = 0; j < workstation_nb; j++) {
cpu_L07_t card_src = action->workstation_list[i];
cpu_L07_t card_dst = action->workstation_list[j];
- int route_size = ROUTE(card_src->id, card_dst->id).size;
- link_L07_t *route = ROUTE(card_src->id, card_dst->id).links;
+ xbt_dynar_t route = ROUTE(card_src->id, card_dst->id);
double lat = 0.0;
if (action->communication_amount[i * workstation_nb + j] > 0) {
- for (k = 0; k < route_size; k++) {
- lat += route[k]->lat_current;
+ xbt_dynar_foreach(route,cpt,link) {
+ lat += link->lat_current;
}
lat_current =
MAX(lat_current,
for (i = 0; i < nb_workstation; i++)
for (j = 0; j < nb_workstation; j++)
- free(ROUTE(i, j).links);
+ xbt_dynar_free(&ROUTE(i, j));
free(routing_table);
routing_table = NULL;
nb_workstation = 0;
double amount, double rate)
{
surf_action_workstation_L07_t action = NULL;
- int i, j, k;
+ int i, j;
+ unsigned int cpt;
int nb_link = 0;
int nb_host = 0;
double latency = 0.0;
for (j = 0; j < workstation_nb; j++) {
cpu_L07_t card_src = workstation_list[i];
cpu_L07_t card_dst = workstation_list[j];
- int route_size = ROUTE(card_src->id, card_dst->id).size;
- link_L07_t *route = ROUTE(card_src->id, card_dst->id).links;
+ link_L07_t link;
+ xbt_dynar_t route = ROUTE(card_src->id, card_dst->id);
double lat = 0.0;
if (communication_amount[i * workstation_nb + j] > 0)
- for (k = 0; k < route_size; k++) {
- lat += route[k]->lat_current;
- xbt_dict_set(parallel_task_link_set, route[k]->generic_resource.name,
- route[k], NULL);
+ xbt_dynar_foreach(route,cpt,link) {
+ lat += link->lat_current;
+ xbt_dict_set(parallel_task_link_set, link->generic_resource.name,
+ link, NULL);
}
latency = MAX(latency, lat);
}
for (j = 0; j < workstation_nb; j++) {
cpu_L07_t card_src = workstation_list[i];
cpu_L07_t card_dst = workstation_list[j];
- int route_size = ROUTE(card_src->id, card_dst->id).size;
- link_L07_t *route = ROUTE(card_src->id, card_dst->id).links;
+ link_L07_t link;
+ xbt_dynar_t route = ROUTE(card_src->id, card_dst->id);
if (communication_amount[i * workstation_nb + j] == 0.0)
continue;
- for (k = 0; k < route_size; k++) {
- lmm_expand_add(ptask_maxmin_system, route[k]->constraint,
+ xbt_dynar_foreach(route,cpt,link) {
+ lmm_expand_add(ptask_maxmin_system, link->constraint,
action->variable,
communication_amount[i * workstation_nb + j]);
}
return (surf_action_t) action;
}
-/* returns an array of link_L07_t */
-static const void **get_route(void *src, void *dst)
+/* returns a dynar of link_L07_t */
+static xbt_dynar_t get_route(void *src, void *dst)
{
cpu_L07_t card_src = src;
cpu_L07_t card_dst = dst;
- route_L07_t route = &(ROUTE(card_src->id, card_dst->id));
- return (const void **) route->links;
-}
-
-static int get_route_size(void *src, void *dst)
-{
- cpu_L07_t card_src = src;
- cpu_L07_t card_dst = dst;
- route_L07_t route = &(ROUTE(card_src->id, card_dst->id));
- return route->size;
+ return ROUTE(card_src->id, card_dst->id);
}
static double get_link_bandwidth(const void *link)
static void create_routing_table(void)
{
- routing_table = xbt_new0(s_route_L07_t, nb_workstation * nb_workstation);
+ int i,j;
+ routing_table = xbt_new0(xbt_dynar_t, /*card_number * card_number */
+ nb_workstation * nb_workstation);
+ for (i=0;i<nb_workstation;i++)
+ for (j=0;j<nb_workstation;j++)
+ ROUTE(i,j) = xbt_dynar_new(sizeof(link_L07_t),NULL);
}
static void parse_cpu_init(void)
current_property_set);
}
-static void route_new(int src_id, int dst_id,
- link_L07_t * link_list, int nb_link)
-{
- route_L07_t route = &(ROUTE(src_id, dst_id));
-
- route->size = nb_link;
- route->links = link_list =
- xbt_realloc(link_list, sizeof(link_L07_t) * nb_link);
-}
-
-
static int src_id = -1;
static int dst_id = -1;
/* Adding loopback if needed */
for (i = 0; i < nb_workstation; i++)
- if (!ROUTE(i, i).size) {
+ if (!xbt_dynar_length(ROUTE(i, i))) {
if (!loopback)
loopback = link_new(xbt_strdup("__MSG_loopback__"),
498000000, NULL, 0.000015, NULL,
SURF_LINK_ON, NULL, SURF_LINK_FATPIPE, NULL);
- ROUTE(i, i).size = 1;
- ROUTE(i, i).links = xbt_new0(link_L07_t, 1);
- ROUTE(i, i).links[0] = loopback;
+ xbt_dynar_push(ROUTE(i,i),&loopback);
}
}
xbt_ex_t e;
int nb_link = 0;
unsigned int cpt = 0;
- int link_list_capacity = 0;
- link_L07_t *link_list = NULL;
xbt_dict_cursor_t cursor = NULL;
char *key, *data, *end;
const char *sep = "#";
xbt_dynar_t links, keys;
- char *link = NULL;
+ char *link_name = NULL;
if (routing_table == NULL)
create_routing_table();
dst_id = strtol(xbt_dynar_get_as(keys, 1, char *), &end, 16);
xbt_dynar_free(&keys);
- link_list_capacity = xbt_dynar_length(links);
- link_list = xbt_new(link_L07_t, link_list_capacity);
-
-
- xbt_dynar_foreach(links, cpt, link) {
+ xbt_dynar_foreach(links, cpt, link_name) {
TRY {
- link_list[nb_link++] = xbt_dict_get(link_set, link);
+ link_L07_t link = xbt_dict_get(link_set, link_name);
+ xbt_dynar_push(ROUTE(src_id,dst_id),&link);
}
CATCH(e) {
- RETHROW1("Link %s not found (dict raised this exception: %s)", link);
+ RETHROW1("Link %s not found (dict raised this exception: %s)", link_name);
}
}
- route_new(src_id, dst_id, link_list, nb_link);
}
}
surf_workstation_model->extension.workstation.execute_parallel_task =
execute_parallel_task;
surf_workstation_model->extension.workstation.get_route = get_route;
- surf_workstation_model->extension.workstation.get_route_size =
- get_route_size;
surf_workstation_model->extension.workstation.get_link_bandwidth =
get_link_bandwidth;
surf_workstation_model->extension.workstation.get_link_latency =
