3 /* Copyright (c) 2005 Arnaud Legrand. All rights reserved. */
5 /* This program is free software; you can redistribute it and/or modify it
6 * under the terms of the license (GNU LGPL) which comes with this package. */
10 #include "workstation_KCCFLN05_private.h"
12 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(workstation_KCCFLN05, surf,
13 "Logging specific to the SURF workstation module (KCCFLN05)");
16 static lmm_system_t maxmin_system_cpu_KCCFLN05 = NULL;
17 static lmm_system_t maxmin_system_network_KCCFLN05 = NULL;
18 static xbt_dict_t network_link_set = NULL;
19 static int nb_workstation = 0;
20 static s_route_KCCFLN05_t *routing_table = NULL;
21 #define ROUTE(i,j) routing_table[(i)+(j)*nb_workstation]
23 /**************************************/
24 /************* CPU object *************/
25 /**************************************/
27 /************ workstation creation *********/
28 static void workstation_free(void *workstation)
30 free(((workstation_KCCFLN05_t)workstation)->name);
31 xbt_dynar_free(&(((workstation_KCCFLN05_t)workstation)->incomming_communications));
32 xbt_dynar_free(&(((workstation_KCCFLN05_t)workstation)->outgoing_communications));
36 static workstation_KCCFLN05_t workstation_new(const char *name,
39 tmgr_trace_t power_trace,
40 e_surf_cpu_state_t state_initial,
41 tmgr_trace_t state_trace,
42 double interference_send,
43 double interference_recv,
44 double interference_send_recv,
45 double max_outgoing_rate)
47 workstation_KCCFLN05_t workstation = xbt_new0(s_workstation_KCCFLN05_t, 1);
49 workstation->resource = (surf_resource_t) surf_workstation_resource;
50 workstation->name = xbt_strdup(name);
51 workstation->id = nb_workstation++;
53 workstation->power_scale = power_scale;
54 xbt_assert0(workstation->power_scale>0,"Power has to be >0");
56 workstation->power_current = power_initial;
58 workstation->power_event =
59 tmgr_history_add_trace(history, power_trace, 0.0, 0, workstation);
61 workstation->state_current = state_initial;
63 workstation->state_event =
64 tmgr_history_add_trace(history, state_trace, 0.0, 0, workstation);
66 workstation->interference_send=interference_send;
67 workstation->interference_recv=interference_recv;
68 workstation->interference_send_recv=interference_send_recv;
70 workstation->constraint =
71 lmm_constraint_new(maxmin_system_cpu_KCCFLN05, workstation,
72 workstation->power_current * workstation->power_scale);
73 if(max_outgoing_rate>0)
75 lmm_constraint_new(maxmin_system_cpu_KCCFLN05, workstation,
78 workstation->incomming_communications =
79 xbt_dynar_new(sizeof(surf_action_network_KCCFLN05_t),NULL);
80 workstation->outgoing_communications =
81 xbt_dynar_new(sizeof(surf_action_network_KCCFLN05_t),NULL);
83 xbt_dict_set(workstation_set, name, workstation, workstation_free);
88 static void parse_workstation(void)
90 double power_scale = 0.0;
91 double power_initial = 0.0;
92 tmgr_trace_t power_trace = NULL;
93 e_surf_cpu_state_t state_initial = SURF_CPU_OFF;
94 tmgr_trace_t state_trace = NULL;
95 double interference_send = 0.0;
96 double interference_recv = 0.0;
97 double interference_send_recv = 0.0;
98 double max_outgoing_rate = -1.0;
100 surf_parse_get_double(&power_scale,A_cpu_power);
101 surf_parse_get_double(&power_initial,A_cpu_availability);
102 surf_parse_get_trace(&power_trace,A_cpu_availability_file);
104 xbt_assert0((A_cpu_state==A_cpu_state_ON)||
105 (A_cpu_state==A_cpu_state_OFF),
107 if (A_cpu_state==A_cpu_state_ON) state_initial = SURF_CPU_ON;
108 if (A_cpu_state==A_cpu_state_OFF) state_initial = SURF_CPU_OFF;
109 surf_parse_get_trace(&state_trace,A_cpu_state_file);
111 surf_parse_get_double(&interference_send,A_cpu_interference_send);
112 surf_parse_get_double(&interference_recv,A_cpu_interference_recv);
113 surf_parse_get_double(&interference_send_recv,A_cpu_interference_send_recv);
114 surf_parse_get_double(&max_outgoing_rate,A_cpu_max_outgoing_rate);
116 workstation_new(A_cpu_name, power_scale, power_initial, power_trace, state_initial,
117 state_trace, interference_send, interference_recv,
118 interference_send_recv, max_outgoing_rate);
121 /*********** resource management ***********/
123 static void *name_service(const char *name)
125 return xbt_dict_get_or_null(workstation_set, name);
128 static const char *get_resource_name(void *resource_id)
130 return ((workstation_KCCFLN05_t) resource_id)->name;
133 static int cpu_used(void *resource_id)
135 return lmm_constraint_used(maxmin_system_cpu_KCCFLN05,
136 ((workstation_KCCFLN05_t) resource_id)->constraint);
139 static int link_used(void *resource_id)
141 return lmm_constraint_used(maxmin_system_network_KCCFLN05,
142 ((network_link_KCCFLN05_t) resource_id)->constraint);
145 static e_surf_cpu_state_t get_state(void *cpu)
147 return ((workstation_KCCFLN05_t) cpu)->state_current;
150 static void update_cpu_KCCFLN05_state(void *id,
151 tmgr_trace_event_t event_type,
154 workstation_KCCFLN05_t cpu = id;
156 if (event_type == cpu->power_event) {
157 cpu->power_current = value;
158 /*** The bound is updated in share_cpu_KCCFLN05_resources ***/
159 /* lmm_update_constraint_bound(maxmin_system_cpu_KCCFLN05, cpu->constraint, */
160 /* cpu->power_current * cpu->power_scale); */
161 } else if (event_type == cpu->state_event) {
163 cpu->state_current = SURF_CPU_ON;
165 cpu->state_current = SURF_CPU_OFF;
167 CRITICAL0("Unknown event ! \n");
174 /**************************************/
175 /*********** network object ***********/
176 /**************************************/
178 static void create_routing_table(void)
180 routing_table = xbt_new0(s_route_KCCFLN05_t, nb_workstation * nb_workstation);
183 static void network_link_free(void *nw_link)
185 free(((network_link_KCCFLN05_t)nw_link)->name);
189 static network_link_KCCFLN05_t network_link_new(char *name,
191 tmgr_trace_t bw_trace,
192 e_surf_network_link_state_t
194 tmgr_trace_t state_trace)
196 network_link_KCCFLN05_t nw_link = xbt_new0(s_network_link_KCCFLN05_t, 1);
199 nw_link->resource = (surf_resource_t) surf_network_resource;
200 nw_link->name = name;
201 nw_link->bw_current = bw_initial;
204 tmgr_history_add_trace(history, bw_trace, 0.0, 0, nw_link);
205 nw_link->state_current = state_initial;
207 nw_link->state_event =
208 tmgr_history_add_trace(history, state_trace, 0.0, 0, nw_link);
210 nw_link->constraint =
211 lmm_constraint_new(maxmin_system_network_KCCFLN05, nw_link, nw_link->bw_current);
213 xbt_dict_set(network_link_set, name, nw_link, network_link_free);
218 static void parse_network_link(void)
222 tmgr_trace_t bw_trace;
223 e_surf_network_link_state_t state_initial = SURF_NETWORK_LINK_ON;
224 tmgr_trace_t state_trace;
226 name = xbt_strdup(A_network_link_name);
227 surf_parse_get_double(&bw_initial,A_network_link_bandwidth);
228 surf_parse_get_trace(&bw_trace, A_network_link_bandwidth_file);
230 xbt_assert0((A_network_link_state==A_network_link_state_ON)||
231 (A_network_link_state==A_network_link_state_OFF),
233 if (A_network_link_state==A_network_link_state_ON)
234 state_initial = SURF_NETWORK_LINK_ON;
235 if (A_network_link_state==A_network_link_state_OFF)
236 state_initial = SURF_NETWORK_LINK_OFF;
237 surf_parse_get_trace(&state_trace,A_network_link_state_file);
239 network_link_new(name, bw_initial, bw_trace, state_initial, state_trace);
242 static void route_new(int src_id, int dst_id, char **links, int nb_link,
243 double impact_on_src, double impact_on_dst,
244 double impact_on_src_with_other_recv,
245 double impact_on_dst_with_other_send)
247 network_link_KCCFLN05_t *link_list = NULL;
249 route_KCCFLN05_t route = &(ROUTE(src_id,dst_id));
251 route->size= nb_link;
252 link_list = route->links = xbt_new0(network_link_KCCFLN05_t, nb_link);
253 for (i = 0; i < nb_link; i++) {
254 link_list[i] = xbt_dict_get_or_null(network_link_set, links[i]);
258 route->impact_on_src=impact_on_src;
259 route->impact_on_dst=impact_on_src;
260 route->impact_on_src_with_other_recv=impact_on_src_with_other_recv;
261 route->impact_on_dst_with_other_send=impact_on_dst_with_other_send;
264 static int nb_link = 0;
265 static char **link_name = NULL;
266 static int src_id = -1;
267 static int dst_id = -1;
268 static double impact_on_src;
269 static double impact_on_dst;
270 static double impact_on_src_with_other_recv;
271 static double impact_on_dst_with_other_send;
273 static void parse_route_set_endpoints(void)
275 src_id = ((workstation_KCCFLN05_t) name_service(A_route_src))->id;
276 dst_id = ((workstation_KCCFLN05_t) name_service(A_route_dst))->id;
277 surf_parse_get_double(&impact_on_src,A_route_impact_on_src);
278 surf_parse_get_double(&impact_on_dst,A_route_impact_on_dst);
279 surf_parse_get_double(&impact_on_src_with_other_recv,A_route_impact_on_src_with_other_recv);
280 surf_parse_get_double(&impact_on_dst_with_other_send,A_route_impact_on_dst_with_other_send);
286 static void parse_route_elem(void)
289 link_name = xbt_realloc(link_name, (nb_link) * sizeof(char *));
290 link_name[(nb_link) - 1] = xbt_strdup(A_route_element_name);
293 static void parse_route_set_route(void)
295 route_new(src_id, dst_id, link_name, nb_link, impact_on_src, impact_on_dst,
296 impact_on_src_with_other_recv, impact_on_dst_with_other_send);
299 static void parse_file(const char *file)
301 /* Figuring out the workstations */
302 surf_parse_reset_parser();
303 ETag_cpu_fun=parse_workstation;
304 surf_parse_open(file);
305 xbt_assert1((!surf_parse()),"Parse error in %s",file);
308 create_routing_table();
310 /* Figuring out the network links */
311 surf_parse_reset_parser();
312 ETag_network_link_fun=parse_network_link;
313 surf_parse_open(file);
314 xbt_assert1((!surf_parse()),"Parse error in %s",file);
317 /* Building the routes */
318 surf_parse_reset_parser();
319 STag_route_fun=parse_route_set_endpoints;
320 ETag_route_element_fun=parse_route_elem;
321 ETag_route_fun=parse_route_set_route;
322 surf_parse_open(file);
323 xbt_assert1((!surf_parse()),"Parse error in %s",file);
327 static void update_network_KCCFLN05_state(void *id,
328 tmgr_trace_event_t event_type,
331 network_link_KCCFLN05_t nw_link = id;
333 if (event_type == nw_link->bw_event) {
334 nw_link->bw_current = value;
335 lmm_update_constraint_bound(maxmin_system_network_KCCFLN05, nw_link->constraint,
336 nw_link->bw_current);
337 } else if (event_type == nw_link->state_event) {
339 nw_link->state_current = SURF_NETWORK_LINK_ON;
341 nw_link->state_current = SURF_NETWORK_LINK_OFF;
343 CRITICAL0("Unknown event ! \n");
350 /**************************************/
351 /*************** actions **************/
352 /**************************************/
353 /*************** network **************/
354 static int action_network_KCCFLN05_free(surf_action_t action)
357 surf_action_t act = NULL;
358 workstation_KCCFLN05_t src = ((surf_action_network_KCCFLN05_t) action)->src;
359 workstation_KCCFLN05_t dst = ((surf_action_network_KCCFLN05_t) action)->dst;
364 xbt_swag_remove(action, action->state_set);
365 if(((surf_action_network_KCCFLN05_t)action)->variable)
366 lmm_variable_free(maxmin_system_network_KCCFLN05,
367 ((surf_action_network_KCCFLN05_t) action)->variable);
369 xbt_dynar_foreach (src->outgoing_communications,cpt,act) {
371 xbt_dynar_remove_at(src->outgoing_communications, cpt, &act);
376 xbt_dynar_foreach (dst->incomming_communications,cpt,act) {
378 xbt_dynar_remove_at(dst->incomming_communications, cpt, &act);
389 static void action_network_KCCFLN05_use(surf_action_t action)
394 static double share_network_KCCFLN05_resources(double now)
396 s_surf_action_network_KCCFLN05_t action;
397 return generic_maxmin_share_resources2(surf_network_resource->common_public->
398 states.running_action_set,
399 xbt_swag_offset(action, variable),
400 maxmin_system_network_KCCFLN05);
403 static void action_network_KCCFLN05_change_state(surf_action_t action,
404 e_surf_action_state_t state)
407 surf_action_t act = NULL;
408 workstation_KCCFLN05_t src = ((surf_action_network_KCCFLN05_t) action)->src;
409 workstation_KCCFLN05_t dst = ((surf_action_network_KCCFLN05_t) action)->dst;
411 /* if((state==SURF_ACTION_DONE) || (state==SURF_ACTION_FAILED)) */
412 /* if(((surf_action_network_KCCFLN05_t)action)->variable) { */
413 /* lmm_variable_disable(maxmin_system_network_KCCFLN05, */
414 /* ((surf_action_network_KCCFLN05_t)action)->variable); */
415 /* ((surf_action_network_KCCFLN05_t)action)->variable = NULL; */
418 xbt_dynar_foreach (src->outgoing_communications,cpt,act) {
420 xbt_dynar_remove_at(src->outgoing_communications, cpt, &act);
425 xbt_dynar_foreach (dst->incomming_communications,cpt,act) {
427 xbt_dynar_remove_at(dst->incomming_communications, cpt, &act);
431 surf_action_change_state(action, state);
435 static void update_actions_network_KCCFLN05_state(double now, double delta)
437 surf_action_network_KCCFLN05_t action = NULL;
438 surf_action_network_KCCFLN05_t next_action = NULL;
439 xbt_swag_t running_actions =
440 surf_network_resource->common_public->states.running_action_set;
442 xbt_swag_t failed_actions =
443 surf_network_resource->common_public->states.failed_action_set;
445 xbt_swag_foreach_safe(action, next_action, running_actions) {
446 surf_double_update(&(action->generic_action.remains),
447 lmm_variable_getvalue(action->variable) * delta);
448 if (action->generic_action.max_duration != NO_MAX_DURATION)
449 surf_double_update(&(action->generic_action.max_duration), delta);
450 if ((action->generic_action.remains <= 0.0) &&
451 (lmm_get_variable_weight(action->variable)>0)) {
452 action->generic_action.finish = surf_get_clock();
453 action_network_KCCFLN05_change_state((surf_action_t) action, SURF_ACTION_DONE);
454 } else if ((action->generic_action.max_duration != NO_MAX_DURATION) &&
455 (action->generic_action.max_duration <= 0.0)) {
456 action->generic_action.finish = surf_get_clock();
457 action_network_KCCFLN05_change_state((surf_action_t) action, SURF_ACTION_DONE);
458 } else { /* Need to check that none of the resource has failed */
459 /* FIXME : FAILURES ARE NOT HANDLED YET */
466 static surf_action_t communicate_KCCFLN05(void *src, void *dst, double size,
469 surf_action_network_KCCFLN05_t action = NULL;
470 workstation_KCCFLN05_t card_src = src;
471 workstation_KCCFLN05_t card_dst = dst;
472 route_KCCFLN05_t route = &ROUTE(card_src->id, card_dst->id);
475 action = xbt_new0(s_surf_action_network_KCCFLN05_t, 1);
477 action->generic_action.using = 1;
478 action->generic_action.cost = size;
479 action->generic_action.remains = size;
480 action->generic_action.max_duration = NO_MAX_DURATION;
481 action->generic_action.start = -1.0;
482 action->generic_action.finish = -1.0;
483 action->generic_action.resource_type =
484 (surf_resource_t) surf_network_resource;
486 action->generic_action.state_set =
487 surf_network_resource->common_public->states.running_action_set;
489 xbt_swag_insert(action, action->generic_action.state_set);
492 action->variable = lmm_variable_new(maxmin_system_network_KCCFLN05, action, 1.0, rate,
495 action->variable = lmm_variable_new(maxmin_system_network_KCCFLN05, action, 1.0, -1.0,
498 for (i = 0; i < route->size; i++)
499 lmm_expand(maxmin_system_network_KCCFLN05, route->links[i]->constraint,
500 action->variable, 1.0);
503 lmm_expand(maxmin_system_network_KCCFLN05, card_src->bus,
504 action->variable, 1.0);
509 xbt_dynar_push(card_src->outgoing_communications,&action);
510 xbt_dynar_push(card_dst->incomming_communications,&action);
512 return (surf_action_t) action;
515 static surf_action_t execute_parallel_task_KCCFLN05 (int workstation_nb,
516 void **workstation_list,
517 double *computation_amount,
518 double *communication_amount,
526 static void network_KCCFLN05_action_suspend(surf_action_t action)
528 lmm_update_variable_weight(maxmin_system_network_KCCFLN05,
529 ((surf_action_network_KCCFLN05_t) action)->variable, 0.0);
532 static void network_KCCFLN05_action_resume(surf_action_t action)
534 lmm_update_variable_weight(maxmin_system_network_KCCFLN05,
535 ((surf_action_network_KCCFLN05_t) action)->variable, 1.0);
538 static int network_KCCFLN05_action_is_suspended(surf_action_t action)
540 return (lmm_get_variable_weight(((surf_action_network_KCCFLN05_t) action)->variable) == 0.0);
543 static void network_KCCFLN05_action_set_max_duration(surf_action_t action, double duration)
545 action->max_duration = duration;
548 /***************** CPU ****************/
549 static int action_cpu_KCCFLN05_free(surf_action_t action)
553 xbt_swag_remove(action, action->state_set);
554 if(((surf_action_cpu_KCCFLN05_t)action)->variable)
555 lmm_variable_free(maxmin_system_cpu_KCCFLN05, ((surf_action_cpu_KCCFLN05_t)action)->variable);
562 static void action_cpu_KCCFLN05_use(surf_action_t action)
567 static void action_cpu_KCCFLN05_change_state(surf_action_t action,
568 e_surf_action_state_t state)
570 /* if((state==SURF_ACTION_DONE) || (state==SURF_ACTION_FAILED)) */
571 /* if(((surf_action_cpu_KCCFLN05_t)action)->variable) { */
572 /* lmm_variable_disable(maxmin_system_cpu_KCCFLN05, */
573 /* ((surf_action_cpu_KCCFLN05_t)action)->variable); */
574 /* ((surf_action_cpu_KCCFLN05_t)action)->variable = NULL; */
577 surf_action_change_state(action, state);
581 static double share_cpu_KCCFLN05_resources(double now)
583 s_surf_action_cpu_KCCFLN05_t s_cpu_action;
584 lmm_constraint_t cnst = NULL;
585 workstation_KCCFLN05_t workstation = NULL;
589 surf_action_network_KCCFLN05_t action;
591 if(surf_get_clock()>=475.895)
596 for(cnst = lmm_get_first_active_constraint(maxmin_system_cpu_KCCFLN05);
598 cnst= lmm_get_next_active_constraint(maxmin_system_cpu_KCCFLN05, cnst))
600 workstation = lmm_constraint_id(cnst);
601 W=workstation->power_current * workstation->power_scale;
603 if((!xbt_dynar_length(workstation->incomming_communications)) &&
604 (!xbt_dynar_length(workstation->outgoing_communications))) {
606 } else if((!xbt_dynar_length(workstation->incomming_communications)) &&
607 (xbt_dynar_length(workstation->outgoing_communications))) {
608 scale = workstation->interference_send;
609 xbt_dynar_foreach (workstation->outgoing_communications,cpt,action) {
610 /* VOIRD(action->src->id); */
611 /* VOIRD(action->dst->id); */
612 /* VOIRP(&ROUTE(action->src->id,action->dst->id)); */
613 /* VOIRG(ROUTE(action->src->id,action->dst->id).impact_on_src); */
614 scale -= ROUTE(action->src->id,action->dst->id).impact_on_src *
615 lmm_variable_getvalue(action->variable);
617 if(scale<0.0) scale=0.0;
618 xbt_assert0(scale>=0.0,"Negative interference !");
619 } else if((xbt_dynar_length(workstation->incomming_communications)) &&
620 (!xbt_dynar_length(workstation->outgoing_communications))) {
621 scale = workstation->interference_recv;
622 xbt_dynar_foreach (workstation->incomming_communications,cpt,action) {
623 scale -= ROUTE(action->src->id,action->dst->id).impact_on_dst *
624 lmm_variable_getvalue(action->variable);
626 if(scale<0.0) scale=0.0;
627 xbt_assert0(scale>=0.0,"Negative interference !");
629 scale = workstation->interference_send_recv;
630 xbt_dynar_foreach (workstation->outgoing_communications,cpt,action) {
631 scale -= ROUTE(action->src->id,action->dst->id).impact_on_src_with_other_recv *
632 lmm_variable_getvalue(action->variable);
634 xbt_dynar_foreach (workstation->incomming_communications,cpt,action) {
635 scale -= ROUTE(action->src->id,action->dst->id).impact_on_dst_with_other_send *
636 lmm_variable_getvalue(action->variable);
638 if(scale<0.0) scale=0.1;
639 xbt_assert0(scale>=0.0,"Negative interference !");
641 lmm_update_constraint_bound(maxmin_system_cpu_KCCFLN05,workstation->constraint,
645 return generic_maxmin_share_resources2(surf_cpu_resource->common_public->
646 states.running_action_set,
647 xbt_swag_offset(s_cpu_action, variable),
648 maxmin_system_cpu_KCCFLN05);
651 static void update_actions_cpu_KCCFLN05_state(double now, double delta)
653 surf_action_cpu_KCCFLN05_t action = NULL;
654 surf_action_cpu_KCCFLN05_t next_action = NULL;
655 xbt_swag_t running_actions =
656 surf_cpu_resource->common_public->states.running_action_set;
658 xbt_swag_t failed_actions =
659 surf_cpu_resource->common_public->states.failed_action_set;
662 xbt_swag_foreach_safe(action, next_action, running_actions) {
663 surf_double_update(&(action->generic_action.remains),
664 lmm_variable_getvalue(action->variable) * delta);
665 if (action->generic_action.max_duration != NO_MAX_DURATION)
666 action->generic_action.max_duration -= delta;
667 if ((action->generic_action.remains <= 0) &&
668 (lmm_get_variable_weight(action->variable)>0)) {
669 action->generic_action.finish = surf_get_clock();
670 action_cpu_KCCFLN05_change_state((surf_action_t) action, SURF_ACTION_DONE);
671 } else if ((action->generic_action.max_duration != NO_MAX_DURATION) &&
672 (action->generic_action.max_duration <= 0)) {
673 action->generic_action.finish = surf_get_clock();
674 action_cpu_KCCFLN05_change_state((surf_action_t) action, SURF_ACTION_DONE);
675 } else { /* Need to check that none of the resource has failed */
676 lmm_constraint_t cnst = NULL;
678 workstation_KCCFLN05_t cpu = NULL;
681 lmm_get_cnst_from_var(maxmin_system_cpu_KCCFLN05, action->variable,
683 cpu = lmm_constraint_id(cnst);
684 if (cpu->state_current == SURF_CPU_OFF) {
685 action->generic_action.finish = surf_get_clock();
686 action_cpu_KCCFLN05_change_state((surf_action_t) action, SURF_ACTION_FAILED);
696 static surf_action_t execute_KCCFLN05(void *cpu, double size)
698 surf_action_cpu_KCCFLN05_t action = NULL;
699 workstation_KCCFLN05_t CPU = cpu;
701 action = xbt_new0(s_surf_action_cpu_KCCFLN05_t, 1);
703 action->generic_action.using = 1;
704 action->generic_action.cost = size;
705 action->generic_action.remains = size;
706 action->generic_action.max_duration = NO_MAX_DURATION;
707 action->generic_action.start = surf_get_clock();
708 action->generic_action.finish = -1.0;
709 action->generic_action.resource_type =
710 (surf_resource_t) surf_cpu_resource;
712 if (CPU->state_current == SURF_CPU_ON)
713 action->generic_action.state_set =
714 surf_cpu_resource->common_public->states.running_action_set;
716 action->generic_action.state_set =
717 surf_cpu_resource->common_public->states.failed_action_set;
718 xbt_swag_insert(action, action->generic_action.state_set);
720 action->variable = lmm_variable_new(maxmin_system_cpu_KCCFLN05, action, 1.0, -1.0, 1);
721 lmm_expand(maxmin_system_cpu_KCCFLN05, CPU->constraint, action->variable,
724 return (surf_action_t) action;
727 static void cpu_KCCFLN05_action_suspend(surf_action_t action)
729 lmm_update_variable_weight(maxmin_system_cpu_KCCFLN05,
730 ((surf_action_cpu_KCCFLN05_t) action)->variable, 0.0);
733 static void cpu_KCCFLN05_action_resume(surf_action_t action)
735 lmm_update_variable_weight(maxmin_system_cpu_KCCFLN05,
736 ((surf_action_cpu_KCCFLN05_t) action)->variable, 1.0);
739 static int cpu_KCCFLN05_action_is_suspended(surf_action_t action)
741 return (lmm_get_variable_weight(((surf_action_cpu_KCCFLN05_t) action)->variable) == 0.0);
744 static void cpu_KCCFLN05_action_set_max_duration(surf_action_t action, double duration)
746 action->max_duration = duration;
749 /************* workstation ************/
750 static void action_change_state(surf_action_t action,
751 e_surf_action_state_t state)
753 if(action->resource_type==(surf_resource_t)surf_network_resource)
754 surf_network_resource->common_public->action_change_state(action,state);
755 else if(action->resource_type==(surf_resource_t)surf_cpu_resource)
756 surf_cpu_resource->common_public->action_change_state(action,state);
761 static int action_free(surf_action_t action)
763 if(action->resource_type==(surf_resource_t)surf_network_resource)
764 return surf_network_resource->common_public->action_free(action);
765 else if(action->resource_type==(surf_resource_t)surf_cpu_resource)
766 return surf_cpu_resource->common_public->action_free(action);
771 static void action_use(surf_action_t action)
773 if(action->resource_type==(surf_resource_t)surf_network_resource)
774 surf_network_resource->common_public->action_use(action);
775 else if(action->resource_type==(surf_resource_t)surf_cpu_resource)
776 surf_cpu_resource->common_public->action_use(action);
781 static int resource_used(void *resource_id)
783 xbt_assert0(0, "Workstation is a virtual resource. I should not be there!");
787 static double share_resources(double now)
792 static void update_actions_state(double now, double delta)
797 static void update_resource_state(void *id,
798 tmgr_trace_event_t event_type,
801 xbt_assert0(0, "Workstation is a virtual resource. I should not be there!");
805 static void action_suspend(surf_action_t action)
807 if(action->resource_type==(surf_resource_t)surf_network_resource)
808 surf_network_resource->common_public->suspend(action);
809 else if(action->resource_type==(surf_resource_t)surf_cpu_resource)
810 surf_cpu_resource->common_public->suspend(action);
814 static void action_resume(surf_action_t action)
816 if(action->resource_type==(surf_resource_t)surf_network_resource)
817 surf_network_resource->common_public->resume(action);
818 else if(action->resource_type==(surf_resource_t)surf_cpu_resource)
819 surf_cpu_resource->common_public->resume(action);
823 static int action_is_suspended(surf_action_t action)
825 if(action->resource_type==(surf_resource_t)surf_network_resource)
826 return surf_network_resource->common_public->is_suspended(action);
827 if(action->resource_type==(surf_resource_t)surf_cpu_resource)
828 return surf_cpu_resource->common_public->is_suspended(action);
832 static void action_set_max_duration(surf_action_t action, double duration)
834 if(action->resource_type==(surf_resource_t)surf_network_resource)
835 surf_network_resource->common_public->set_max_duration(action,duration);
836 else if(action->resource_type==(surf_resource_t)surf_cpu_resource)
837 surf_cpu_resource->common_public->set_max_duration(action,duration);
842 /**************************************/
843 /********* Module creation ***********/
844 /**************************************/
845 static void cpu_KCCFLN05_finalize(void)
847 xbt_dict_free(&workstation_set);
848 xbt_swag_free(surf_cpu_resource->common_public->states.ready_action_set);
849 xbt_swag_free(surf_cpu_resource->common_public->states.
851 xbt_swag_free(surf_cpu_resource->common_public->states.
853 xbt_swag_free(surf_cpu_resource->common_public->states.done_action_set);
854 free(surf_cpu_resource->common_public);
855 free(surf_cpu_resource->common_private);
856 free(surf_cpu_resource->extension_public);
858 free(surf_cpu_resource);
859 surf_cpu_resource = NULL;
861 if (maxmin_system_cpu_KCCFLN05) {
862 lmm_system_free(maxmin_system_cpu_KCCFLN05);
863 maxmin_system_cpu_KCCFLN05 = NULL;
867 static void cpu_KCCFLN05_resource_init_internal(void)
869 s_surf_action_t action;
871 surf_cpu_resource = xbt_new0(s_surf_cpu_resource_t, 1);
873 surf_cpu_resource->common_private =
874 xbt_new0(s_surf_resource_private_t, 1);
875 surf_cpu_resource->common_public =
876 xbt_new0(s_surf_resource_public_t, 1);
878 surf_cpu_resource->extension_public =
879 xbt_new0(s_surf_cpu_resource_extension_public_t, 1);
881 surf_cpu_resource->common_public->states.ready_action_set =
882 xbt_swag_new(xbt_swag_offset(action, state_hookup));
883 surf_cpu_resource->common_public->states.running_action_set =
884 xbt_swag_new(xbt_swag_offset(action, state_hookup));
885 surf_cpu_resource->common_public->states.failed_action_set =
886 xbt_swag_new(xbt_swag_offset(action, state_hookup));
887 surf_cpu_resource->common_public->states.done_action_set =
888 xbt_swag_new(xbt_swag_offset(action, state_hookup));
890 surf_cpu_resource->common_public->name_service = name_service;
891 surf_cpu_resource->common_public->get_resource_name = get_resource_name;
892 surf_cpu_resource->common_public->action_get_state =
893 surf_action_get_state;
894 surf_cpu_resource->common_public->action_free = action_cpu_KCCFLN05_free;
895 surf_cpu_resource->common_public->action_use = action_cpu_KCCFLN05_use;
896 surf_cpu_resource->common_public->action_cancel = NULL;
897 surf_cpu_resource->common_public->action_recycle = NULL;
898 surf_cpu_resource->common_public->action_change_state = action_cpu_KCCFLN05_change_state;
899 surf_cpu_resource->common_public->action_set_data = surf_action_set_data;
900 surf_cpu_resource->common_public->name = "CPU KCCFLN05";
902 surf_cpu_resource->common_private->resource_used = cpu_used;
903 surf_cpu_resource->common_private->share_resources = share_cpu_KCCFLN05_resources;
904 surf_cpu_resource->common_private->update_actions_state =
905 update_actions_cpu_KCCFLN05_state;
906 surf_cpu_resource->common_private->update_resource_state =
907 update_cpu_KCCFLN05_state;
908 surf_cpu_resource->common_private->finalize = cpu_KCCFLN05_finalize;
910 surf_cpu_resource->extension_public->execute = execute_KCCFLN05;
911 /*FIXME*//* surf_cpu_resource->extension_public->sleep = action_sleep; */
913 surf_cpu_resource->common_public->suspend = cpu_KCCFLN05_action_suspend;
914 surf_cpu_resource->common_public->resume = cpu_KCCFLN05_action_resume;
915 surf_cpu_resource->common_public->is_suspended = cpu_KCCFLN05_action_is_suspended;
917 surf_cpu_resource->extension_public->get_state = get_state;
919 workstation_set = xbt_dict_new();
921 maxmin_system_cpu_KCCFLN05 = lmm_system_new();
924 static void network_KCCFLN05_finalize(void)
928 xbt_dict_free(&network_link_set);
929 xbt_swag_free(surf_network_resource->common_public->states.
931 xbt_swag_free(surf_network_resource->common_public->states.
933 xbt_swag_free(surf_network_resource->common_public->states.
935 xbt_swag_free(surf_network_resource->common_public->states.
937 free(surf_network_resource->common_public);
938 free(surf_network_resource->common_private);
939 free(surf_network_resource->extension_public);
941 free(surf_network_resource);
942 surf_network_resource = NULL;
944 for (i = 0; i < nb_workstation; i++)
945 for (j = 0; j < nb_workstation; j++)
946 free(ROUTE(i,j).links);
948 routing_table = NULL;
951 if (maxmin_system_network_KCCFLN05) {
952 lmm_system_free(maxmin_system_network_KCCFLN05);
953 maxmin_system_network_KCCFLN05 = NULL;
957 static void network_KCCFLN05_resource_init_internal(void)
959 s_surf_action_t action;
961 surf_network_resource = xbt_new0(s_surf_network_resource_t, 1);
963 surf_network_resource->common_private =
964 xbt_new0(s_surf_resource_private_t, 1);
965 surf_network_resource->common_public =
966 xbt_new0(s_surf_resource_public_t, 1);
967 surf_network_resource->extension_public =
968 xbt_new0(s_surf_network_resource_extension_public_t, 1);
970 surf_network_resource->common_public->states.ready_action_set =
971 xbt_swag_new(xbt_swag_offset(action, state_hookup));
972 surf_network_resource->common_public->states.running_action_set =
973 xbt_swag_new(xbt_swag_offset(action, state_hookup));
974 surf_network_resource->common_public->states.failed_action_set =
975 xbt_swag_new(xbt_swag_offset(action, state_hookup));
976 surf_network_resource->common_public->states.done_action_set =
977 xbt_swag_new(xbt_swag_offset(action, state_hookup));
979 surf_network_resource->common_public->name_service = name_service;
980 surf_network_resource->common_public->get_resource_name = get_resource_name;
981 surf_network_resource->common_public->action_get_state =
982 surf_action_get_state;
983 surf_network_resource->common_public->action_free = action_network_KCCFLN05_free;
984 surf_network_resource->common_public->action_use = action_network_KCCFLN05_use;
985 surf_network_resource->common_public->action_cancel = NULL;
986 surf_network_resource->common_public->action_recycle = NULL;
987 surf_network_resource->common_public->action_change_state = action_network_KCCFLN05_change_state;
988 surf_network_resource->common_public->action_set_data = surf_action_set_data;
989 surf_network_resource->common_public->name = "network KCCFLN05";
991 surf_network_resource->common_private->resource_used = link_used;
992 surf_network_resource->common_private->share_resources = share_network_KCCFLN05_resources;
993 surf_network_resource->common_private->update_actions_state =
994 update_actions_network_KCCFLN05_state;
995 surf_network_resource->common_private->update_resource_state =
996 update_network_KCCFLN05_state;
997 surf_network_resource->common_private->finalize = network_KCCFLN05_finalize;
999 surf_network_resource->common_public->suspend = network_KCCFLN05_action_suspend;
1000 surf_network_resource->common_public->resume = network_KCCFLN05_action_resume;
1001 surf_network_resource->common_public->is_suspended = network_KCCFLN05_action_is_suspended;
1003 surf_network_resource->extension_public->communicate = communicate_KCCFLN05;
1005 network_link_set = xbt_dict_new();
1007 maxmin_system_network_KCCFLN05 = lmm_system_new();
1010 static void workstation_KCCFLN05_finalize(void)
1012 xbt_swag_free(surf_workstation_resource->common_public->states.ready_action_set);
1013 xbt_swag_free(surf_workstation_resource->common_public->states.running_action_set);
1014 xbt_swag_free(surf_workstation_resource->common_public->states.failed_action_set);
1015 xbt_swag_free(surf_workstation_resource->common_public->states.done_action_set);
1017 free(surf_workstation_resource->common_public);
1018 free(surf_workstation_resource->common_private);
1019 free(surf_workstation_resource->extension_public);
1021 free(surf_workstation_resource);
1022 surf_workstation_resource = NULL;
1025 static void workstation_KCCFLN05_resource_init_internal(void)
1027 s_surf_action_t action;
1029 surf_workstation_resource = xbt_new0(s_surf_workstation_resource_t, 1);
1031 surf_workstation_resource->common_private =
1032 xbt_new0(s_surf_resource_private_t, 1);
1033 surf_workstation_resource->common_public =
1034 xbt_new0(s_surf_resource_public_t, 1);
1035 surf_workstation_resource->extension_public =
1036 xbt_new0(s_surf_workstation_resource_extension_public_t, 1);
1038 surf_workstation_resource->common_public->states.ready_action_set =
1039 xbt_swag_new(xbt_swag_offset(action, state_hookup));
1040 surf_workstation_resource->common_public->states.running_action_set =
1041 xbt_swag_new(xbt_swag_offset(action, state_hookup));
1042 surf_workstation_resource->common_public->states.failed_action_set =
1043 xbt_swag_new(xbt_swag_offset(action, state_hookup));
1044 surf_workstation_resource->common_public->states.done_action_set =
1045 xbt_swag_new(xbt_swag_offset(action, state_hookup));
1047 surf_workstation_resource->common_public->name_service = name_service;
1048 surf_workstation_resource->common_public->get_resource_name =
1050 surf_workstation_resource->common_public->action_get_state =
1051 surf_action_get_state;
1052 surf_workstation_resource->common_public->action_free = action_free;
1053 surf_workstation_resource->common_public->action_use = action_use;
1054 surf_workstation_resource->common_public->action_cancel = NULL;
1055 surf_workstation_resource->common_public->action_recycle = NULL;
1056 surf_workstation_resource->common_public->action_change_state = action_change_state;
1057 surf_workstation_resource->common_public->action_set_data = surf_action_set_data;
1058 surf_workstation_resource->common_public->name = "Workstation KCCFLN05";
1060 surf_workstation_resource->common_private->resource_used = resource_used;
1061 surf_workstation_resource->common_private->share_resources = share_resources;
1062 surf_workstation_resource->common_private->update_actions_state = update_actions_state;
1063 surf_workstation_resource->common_private->update_resource_state = update_resource_state;
1064 surf_workstation_resource->common_private->finalize = workstation_KCCFLN05_finalize;
1067 surf_workstation_resource->common_public->suspend = action_suspend;
1068 surf_workstation_resource->common_public->resume = action_resume;
1069 surf_workstation_resource->common_public->is_suspended = action_is_suspended;
1070 surf_workstation_resource->common_public->set_max_duration = action_set_max_duration;
1072 surf_workstation_resource->extension_public->execute = execute_KCCFLN05;
1073 /*FIXME*//* surf_workstation_resource->extension_public->sleep = action_sleep; */
1074 surf_workstation_resource->extension_public->get_state = get_state;
1075 surf_workstation_resource->extension_public->communicate = communicate_KCCFLN05;
1076 surf_workstation_resource->extension_public->execute_parallel_task =
1077 execute_parallel_task_KCCFLN05;
1081 /**************************************/
1082 /*************** Generic **************/
1083 /**************************************/
1085 void surf_workstation_resource_init_KCCFLN05(const char *filename)
1087 xbt_assert0(!surf_cpu_resource,"CPU resource type already defined");
1088 cpu_KCCFLN05_resource_init_internal();
1089 xbt_assert0(!surf_network_resource,"network resource type already defined");
1090 network_KCCFLN05_resource_init_internal();
1091 workstation_KCCFLN05_resource_init_internal();
1092 parse_file(filename);
1094 xbt_dynar_push(resource_list, &surf_network_resource);
1095 xbt_dynar_push(resource_list, &surf_cpu_resource);
1096 xbt_dynar_push(resource_list, &surf_workstation_resource);
1098 if (maxmin_system) { /* To avoid using this useless system */
1099 lmm_system_free(maxmin_system);
1100 maxmin_system = NULL;