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. */
9 #include "workstation_KCCFLN05_private.h"
11 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(workstation_KCCFLN05, surf,
12 "Logging specific to the SURF workstation module (KCCFLN05)");
15 static lmm_system_t maxmin_system_cpu_KCCFLN05 = NULL;
16 static lmm_system_t maxmin_system_network_KCCFLN05 = NULL;
17 static xbt_dict_t network_link_set = NULL;
18 static int nb_workstation = 0;
19 s_route_KCCFLN05_t *routing_table = NULL;
20 #define ROUTE(i,j) routing_table[(i)+(j)*nb_workstation]
22 /**************************************/
23 /************* CPU object *************/
24 /**************************************/
26 /************ workstation creation *********/
27 static void workstation_free(void *workstation)
29 xbt_free(((workstation_KCCFLN05_t)workstation)->name);
30 xbt_dynar_free(&(((workstation_KCCFLN05_t)workstation)->incomming_communications));
31 xbt_dynar_free(&(((workstation_KCCFLN05_t)workstation)->outgoing_communications));
32 xbt_free(workstation);
35 static workstation_KCCFLN05_t workstation_new(const char *name,
38 tmgr_trace_t power_trace,
39 e_surf_cpu_state_t state_initial,
40 tmgr_trace_t state_trace,
41 double interference_send,
42 double interference_recv,
43 double interference_send_recv)
45 workstation_KCCFLN05_t workstation = xbt_new0(s_workstation_KCCFLN05_t, 1);
47 workstation->resource = (surf_resource_t) surf_workstation_resource;
48 workstation->name = xbt_strdup(name);
49 workstation->id = nb_workstation++;
51 workstation->power_scale = power_scale;
52 workstation->power_current = power_initial;
54 workstation->power_event =
55 tmgr_history_add_trace(history, power_trace, 0.0, 0, workstation);
57 workstation->state_current = state_initial;
59 workstation->state_event =
60 tmgr_history_add_trace(history, state_trace, 0.0, 0, workstation);
62 workstation->interference_send=interference_send;
63 workstation->interference_recv=interference_recv;
64 workstation->interference_send_recv=interference_send_recv;
66 workstation->constraint =
67 lmm_constraint_new(maxmin_system_cpu_KCCFLN05, workstation,
68 workstation->power_current * workstation->power_scale);
70 workstation->incomming_communications =
71 xbt_dynar_new(sizeof(surf_action_network_KCCFLN05_t),NULL);
72 workstation->outgoing_communications =
73 xbt_dynar_new(sizeof(surf_action_network_KCCFLN05_t),NULL);
75 xbt_dict_set(workstation_set, name, workstation, workstation_free);
80 static void parse_workstation(void)
82 double power_scale = 0.0;
83 double power_initial = 0.0;
84 tmgr_trace_t power_trace = NULL;
85 e_surf_cpu_state_t state_initial = SURF_CPU_OFF;
86 tmgr_trace_t state_trace = NULL;
87 double interference_send = 0.0;
88 double interference_recv = 0.0;
89 double interference_send_recv = 0.0;
91 surf_parse_get_double(&power_scale,A_cpu_power);
92 surf_parse_get_double(&power_initial,A_cpu_availability);
93 surf_parse_get_trace(&power_trace,A_cpu_availability_file);
95 xbt_assert0((A_cpu_state==A_cpu_state_ON)||
96 (A_cpu_state==A_cpu_state_OFF),
98 if (A_cpu_state==A_cpu_state_ON) state_initial = SURF_CPU_ON;
99 if (A_cpu_state==A_cpu_state_OFF) state_initial = SURF_CPU_OFF;
100 surf_parse_get_trace(&state_trace,A_cpu_state_file);
102 surf_parse_get_double(&interference_send,A_cpu_interference_send);
103 surf_parse_get_double(&interference_recv,A_cpu_interference_recv);
104 surf_parse_get_double(&interference_send_recv,A_cpu_interference_send_recv);
106 workstation_new(A_cpu_name, power_scale, power_initial, power_trace, state_initial,
107 state_trace, interference_send, interference_recv,
108 interference_send_recv);
111 /*********** resource management ***********/
113 static void *name_service(const char *name)
115 void *workstation = NULL;
117 xbt_dict_get(workstation_set, name, &workstation);
122 static const char *get_resource_name(void *resource_id)
124 return ((workstation_KCCFLN05_t) resource_id)->name;
127 static int cpu_used(void *resource_id)
129 return lmm_constraint_used(maxmin_system_cpu_KCCFLN05,
130 ((workstation_KCCFLN05_t) resource_id)->constraint);
133 static int link_used(void *resource_id)
135 return lmm_constraint_used(maxmin_system_network_KCCFLN05,
136 ((network_link_KCCFLN05_t) resource_id)->constraint);
139 static e_surf_cpu_state_t get_state(void *cpu)
141 return ((workstation_KCCFLN05_t) cpu)->state_current;
144 static void update_cpu_KCCFLN05_state(void *id,
145 tmgr_trace_event_t event_type,
148 workstation_KCCFLN05_t cpu = id;
150 if (event_type == cpu->power_event) {
151 cpu->power_current = value;
152 /*** The bound is updated in share_cpu_KCCFLN05_resources ***/
153 /* lmm_update_constraint_bound(maxmin_system_cpu_KCCFLN05, cpu->constraint, */
154 /* cpu->power_current * cpu->power_scale); */
155 } else if (event_type == cpu->state_event) {
157 cpu->state_current = SURF_CPU_ON;
159 cpu->state_current = SURF_CPU_OFF;
161 CRITICAL0("Unknown event ! \n");
168 /**************************************/
169 /*********** network object ***********/
170 /**************************************/
172 static void create_routing_table(void)
174 routing_table = xbt_new0(s_route_KCCFLN05_t, nb_workstation * nb_workstation);
177 static void network_link_free(void *nw_link)
179 xbt_free(((network_link_KCCFLN05_t)nw_link)->name);
183 static network_link_KCCFLN05_t network_link_new(char *name,
185 tmgr_trace_t bw_trace,
186 e_surf_network_link_state_t
188 tmgr_trace_t state_trace)
190 network_link_KCCFLN05_t nw_link = xbt_new0(s_network_link_KCCFLN05_t, 1);
193 nw_link->resource = (surf_resource_t) surf_network_resource;
194 nw_link->name = name;
195 nw_link->bw_current = bw_initial;
198 tmgr_history_add_trace(history, bw_trace, 0.0, 0, nw_link);
199 nw_link->state_current = state_initial;
201 nw_link->state_event =
202 tmgr_history_add_trace(history, state_trace, 0.0, 0, nw_link);
204 nw_link->constraint =
205 lmm_constraint_new(maxmin_system_network_KCCFLN05, nw_link, nw_link->bw_current);
207 xbt_dict_set(network_link_set, name, nw_link, network_link_free);
212 static void parse_network_link(void)
216 tmgr_trace_t bw_trace;
217 e_surf_network_link_state_t state_initial = SURF_NETWORK_LINK_ON;
218 tmgr_trace_t state_trace;
220 name = xbt_strdup(A_network_link_name);
221 surf_parse_get_double(&bw_initial,A_network_link_bandwidth);
222 surf_parse_get_trace(&bw_trace, A_network_link_bandwidth_file);
224 xbt_assert0((A_network_link_state==A_network_link_state_ON)||
225 (A_network_link_state==A_network_link_state_OFF),
227 if (A_network_link_state==A_network_link_state_ON)
228 state_initial = SURF_NETWORK_LINK_ON;
229 if (A_network_link_state==A_network_link_state_OFF)
230 state_initial = SURF_NETWORK_LINK_OFF;
231 surf_parse_get_trace(&state_trace,A_network_link_state_file);
233 network_link_new(name, bw_initial, bw_trace, state_initial, state_trace);
236 static void route_new(int src_id, int dst_id, char **links, int nb_link,
237 double impact_on_src, double impact_on_dst,
238 double impact_on_src_with_other_recv,
239 double impact_on_dst_with_other_send)
241 network_link_KCCFLN05_t *link_list = NULL;
243 route_KCCFLN05_t route = &(ROUTE(src_id,dst_id));
245 route->size= nb_link;
246 link_list = route->links = xbt_new0(network_link_KCCFLN05_t, nb_link);
247 for (i = 0; i < nb_link; i++) {
248 xbt_dict_get(network_link_set, links[i], (void *) &(link_list[i]));
252 route->impact_on_src=impact_on_src;
253 route->impact_on_dst=impact_on_src;
254 route->impact_on_src_with_other_recv=impact_on_src_with_other_recv;
255 route->impact_on_dst_with_other_send=impact_on_dst_with_other_send;
258 static int nb_link = 0;
259 static char **link_name = NULL;
260 static int src_id = -1;
261 static int dst_id = -1;
262 static double impact_on_src;
263 static double impact_on_dst;
264 static double impact_on_src_with_other_recv;
265 static double impact_on_dst_with_other_send;
267 static void parse_route_set_endpoints(void)
269 src_id = ((workstation_KCCFLN05_t) name_service(A_route_src))->id;
270 dst_id = ((workstation_KCCFLN05_t) name_service(A_route_dst))->id;
271 surf_parse_get_double(&impact_on_src,A_route_impact_on_src);
272 surf_parse_get_double(&impact_on_dst,A_route_impact_on_dst);
273 surf_parse_get_double(&impact_on_src_with_other_recv,A_route_impact_on_src_with_other_recv);
274 surf_parse_get_double(&impact_on_dst_with_other_send,A_route_impact_on_dst_with_other_send);
280 static void parse_route_elem(void)
283 link_name = xbt_realloc(link_name, (nb_link) * sizeof(char *));
284 link_name[(nb_link) - 1] = xbt_strdup(A_route_element_name);
287 static void parse_route_set_route(void)
289 route_new(src_id, dst_id, link_name, nb_link, impact_on_src, impact_on_dst,
290 impact_on_src_with_other_recv, impact_on_dst_with_other_send);
293 static void parse_file(const char *file)
295 /* Figuring out the workstations */
296 surf_parse_reset_parser();
297 ETag_cpu_fun=parse_workstation;
298 surf_parse_open(file);
299 xbt_assert1((!surf_parse()),"Parse error in %s",file);
302 create_routing_table();
304 /* Figuring out the network links */
305 surf_parse_reset_parser();
306 ETag_network_link_fun=parse_network_link;
307 surf_parse_open(file);
308 xbt_assert1((!surf_parse()),"Parse error in %s",file);
311 /* Building the routes */
312 surf_parse_reset_parser();
313 STag_route_fun=parse_route_set_endpoints;
314 ETag_route_element_fun=parse_route_elem;
315 ETag_route_fun=parse_route_set_route;
316 surf_parse_open(file);
317 xbt_assert1((!surf_parse()),"Parse error in %s",file);
321 static void update_network_KCCFLN05_state(void *id,
322 tmgr_trace_event_t event_type,
325 network_link_KCCFLN05_t nw_link = id;
327 if (event_type == nw_link->bw_event) {
328 nw_link->bw_current = value;
329 lmm_update_constraint_bound(maxmin_system_network_KCCFLN05, nw_link->constraint,
330 nw_link->bw_current);
331 } else if (event_type == nw_link->state_event) {
333 nw_link->state_current = SURF_NETWORK_LINK_ON;
335 nw_link->state_current = SURF_NETWORK_LINK_OFF;
337 CRITICAL0("Unknown event ! \n");
344 /**************************************/
345 /*************** actions **************/
346 /**************************************/
347 /*************** network **************/
348 static void action_network_KCCFLN05_free(surf_action_t action)
351 surf_action_t act = NULL;
352 workstation_KCCFLN05_t src = ((surf_action_network_KCCFLN05_t) action)->src;
353 workstation_KCCFLN05_t dst = ((surf_action_network_KCCFLN05_t) action)->dst;
355 xbt_swag_remove(action, action->state_set);
356 lmm_variable_free(maxmin_system_network_KCCFLN05,
357 ((surf_action_network_KCCFLN05_t) action)->variable);
359 xbt_dynar_foreach (src->outgoing_communications,cpt,act) {
361 xbt_dynar_remove_at(src->outgoing_communications, cpt, &act);
366 xbt_dynar_foreach (dst->incomming_communications,cpt,act) {
368 xbt_dynar_remove_at(dst->incomming_communications, cpt, &act);
376 static double share_network_KCCFLN05_resources(double now)
378 s_surf_action_network_KCCFLN05_t action;
379 return generic_maxmin_share_resources2(surf_network_resource->common_public->
380 states.running_action_set,
381 xbt_swag_offset(action, variable),
382 maxmin_system_network_KCCFLN05);
385 static void action_network_KCCFLN05_change_state(surf_action_t action,
386 e_surf_action_state_t state)
388 surf_action_change_state(action, state);
392 static void update_actions_network_KCCFLN05_state(double now, double delta)
394 surf_action_network_KCCFLN05_t action = NULL;
395 surf_action_network_KCCFLN05_t next_action = NULL;
396 xbt_swag_t running_actions =
397 surf_network_resource->common_public->states.running_action_set;
398 xbt_swag_t failed_actions =
399 surf_network_resource->common_public->states.failed_action_set;
401 xbt_swag_foreach_safe(action, next_action, running_actions) {
402 action->generic_action.remains -=
403 lmm_variable_getvalue(action->variable) * delta;
404 if (action->generic_action.max_duration != NO_MAX_DURATION)
405 action->generic_action.max_duration -= delta;
406 if ((action->generic_action.remains <= 0) &&
407 (lmm_get_variable_weight(action->variable)>0)) {
408 action->generic_action.finish = surf_get_clock();
409 action_network_KCCFLN05_change_state((surf_action_t) action, SURF_ACTION_DONE);
410 } else if ((action->generic_action.max_duration != NO_MAX_DURATION) &&
411 (action->generic_action.max_duration <= 0)) {
412 action->generic_action.finish = surf_get_clock();
413 action_network_KCCFLN05_change_state((surf_action_t) action, SURF_ACTION_DONE);
414 } else { /* Need to check that none of the resource has failed */
415 /* FIXME : FAILURES ARE NOT HANDLED YET */
419 xbt_swag_foreach_safe(action, next_action, failed_actions) {
420 lmm_variable_disable(maxmin_system_network_KCCFLN05, action->variable);
426 static surf_action_t communicate_KCCFLN05(void *src, void *dst, double size,
429 surf_action_network_KCCFLN05_t action = NULL;
430 workstation_KCCFLN05_t card_src = src;
431 workstation_KCCFLN05_t card_dst = dst;
432 route_KCCFLN05_t route = &ROUTE(card_src->id, card_dst->id);
435 action = xbt_new0(s_surf_action_network_KCCFLN05_t, 1);
437 action->generic_action.cost = size;
438 action->generic_action.remains = size;
439 action->generic_action.max_duration = NO_MAX_DURATION;
440 action->generic_action.start = -1.0;
441 action->generic_action.finish = -1.0;
442 action->generic_action.resource_type =
443 (surf_resource_t) surf_network_resource;
445 action->generic_action.state_set =
446 surf_network_resource->common_public->states.running_action_set;
448 xbt_swag_insert(action, action->generic_action.state_set);
451 action->variable = lmm_variable_new(maxmin_system_network_KCCFLN05, action, 1.0, rate,
454 action->variable = lmm_variable_new(maxmin_system_network_KCCFLN05, action, 1.0, -1.0,
457 for (i = 0; i < route->size; i++)
458 lmm_expand(maxmin_system_network_KCCFLN05, route->links[i]->constraint,
459 action->variable, 1.0);
464 xbt_dynar_push(card_src->outgoing_communications,&action);
465 xbt_dynar_push(card_dst->incomming_communications,&action);
467 return (surf_action_t) action;
470 static void network_KCCFLN05_action_suspend(surf_action_t action)
472 lmm_update_variable_weight(maxmin_system_network_KCCFLN05,
473 ((surf_action_network_KCCFLN05_t) action)->variable, 0.0);
476 static void network_KCCFLN05_action_resume(surf_action_t action)
478 lmm_update_variable_weight(maxmin_system_network_KCCFLN05,
479 ((surf_action_network_KCCFLN05_t) action)->variable, 1.0);
482 static int network_KCCFLN05_action_is_suspended(surf_action_t action)
484 return (lmm_get_variable_weight(((surf_action_network_KCCFLN05_t) action)->variable) == 0.0);
487 /***************** CPU ****************/
488 static void action_cpu_KCCFLN05_free(surf_action_t action)
490 xbt_swag_remove(action, action->state_set);
491 lmm_variable_free(maxmin_system_cpu_KCCFLN05, ((surf_action_cpu_KCCFLN05_t)action)->variable);
495 /* #define WARNING(format, ...) (fprintf(stderr, "[%s , %s : %d] ", __FILE__, __FUNCTION__, __LINE__),\ */
496 /* fprintf(stderr, format, ## __VA_ARGS__), \ */
497 /* fprintf(stderr, "\n")) */
498 /* #define VOIRP(expr) WARNING(" {" #expr " = %p }", expr) */
499 /* #define VOIRD(expr) WARNING(" {" #expr " = %d }", expr) */
500 /* #define VOIRG(expr) WARNING(" {" #expr " = %lg }", expr) */
502 static double share_cpu_KCCFLN05_resources(double now)
504 s_surf_action_cpu_KCCFLN05_t s_cpu_action;
505 lmm_constraint_t cnst = NULL;
506 workstation_KCCFLN05_t workstation = NULL;
510 surf_action_network_KCCFLN05_t action;
512 for(cnst = lmm_get_first_active_constraint(maxmin_system_cpu_KCCFLN05);
514 cnst= lmm_get_next_active_constraint(maxmin_system_cpu_KCCFLN05, cnst))
516 workstation = lmm_constraint_id(cnst);
517 W=workstation->power_current * workstation->power_scale;
519 if((!xbt_dynar_length(workstation->incomming_communications)) &&
520 (!xbt_dynar_length(workstation->outgoing_communications))) {
522 } else if((!xbt_dynar_length(workstation->incomming_communications)) &&
523 (xbt_dynar_length(workstation->outgoing_communications))) {
524 scale = workstation->interference_send;
525 xbt_dynar_foreach (workstation->outgoing_communications,cpt,action) {
526 /* VOIRD(action->src->id); */
527 /* VOIRD(action->dst->id); */
528 /* VOIRP(&ROUTE(action->src->id,action->dst->id)); */
529 /* VOIRG(ROUTE(action->src->id,action->dst->id).impact_on_src); */
530 scale -= ROUTE(action->src->id,action->dst->id).impact_on_src *
531 lmm_variable_getvalue(action->variable);
533 xbt_assert0(scale>0.0,"Negative interference !");
534 } else if((xbt_dynar_length(workstation->incomming_communications)) &&
535 (!xbt_dynar_length(workstation->outgoing_communications))) {
536 scale = workstation->interference_recv;
537 xbt_dynar_foreach (workstation->incomming_communications,cpt,action) {
538 scale -= ROUTE(action->src->id,action->dst->id).impact_on_dst *
539 lmm_variable_getvalue(action->variable);
541 xbt_assert0(scale>0.0,"Negative interference !");
543 scale = workstation->interference_send_recv;
544 xbt_dynar_foreach (workstation->outgoing_communications,cpt,action) {
545 scale -= ROUTE(action->src->id,action->dst->id).impact_on_src_with_other_recv *
546 lmm_variable_getvalue(action->variable);
548 xbt_dynar_foreach (workstation->incomming_communications,cpt,action) {
549 scale -= ROUTE(action->src->id,action->dst->id).impact_on_dst_with_other_send *
550 lmm_variable_getvalue(action->variable);
552 xbt_assert0(scale>0.0,"Negative interference !");
554 lmm_update_constraint_bound(maxmin_system_cpu_KCCFLN05,workstation->constraint,
558 return generic_maxmin_share_resources2(surf_cpu_resource->common_public->
559 states.running_action_set,
560 xbt_swag_offset(s_cpu_action, variable),
561 maxmin_system_cpu_KCCFLN05);
564 static void update_actions_cpu_KCCFLN05_state(double now, double delta)
566 surf_action_cpu_KCCFLN05_t action = NULL;
567 surf_action_cpu_KCCFLN05_t next_action = NULL;
568 xbt_swag_t running_actions =
569 surf_cpu_resource->common_public->states.running_action_set;
570 xbt_swag_t failed_actions =
571 surf_cpu_resource->common_public->states.failed_action_set;
573 xbt_swag_foreach_safe(action, next_action, running_actions) {
574 action->generic_action.remains -=
575 lmm_variable_getvalue(action->variable) * delta;
576 if (action->generic_action.max_duration != NO_MAX_DURATION)
577 action->generic_action.max_duration -= delta;
578 if ((action->generic_action.remains <= 0) &&
579 (lmm_get_variable_weight(action->variable)>0)) {
580 action->generic_action.finish = surf_get_clock();
581 surf_action_change_state((surf_action_t) action, SURF_ACTION_DONE);
582 } else if ((action->generic_action.max_duration != NO_MAX_DURATION) &&
583 (action->generic_action.max_duration <= 0)) {
584 action->generic_action.finish = surf_get_clock();
585 surf_action_change_state((surf_action_t) action, SURF_ACTION_DONE);
586 } else { /* Need to check that none of the resource has failed */
587 lmm_constraint_t cnst = NULL;
589 workstation_KCCFLN05_t cpu = NULL;
592 lmm_get_cnst_from_var(maxmin_system_cpu_KCCFLN05, action->variable,
594 cpu = lmm_constraint_id(cnst);
595 if (cpu->state_current == SURF_CPU_OFF) {
596 action->generic_action.finish = surf_get_clock();
597 surf_action_change_state((surf_action_t) action, SURF_ACTION_FAILED);
604 xbt_swag_foreach_safe(action, next_action, failed_actions) {
605 lmm_variable_disable(maxmin_system_cpu_KCCFLN05, action->variable);
611 static surf_action_t execute_KCCFLN05(void *cpu, double size)
613 surf_action_cpu_KCCFLN05_t action = NULL;
614 workstation_KCCFLN05_t CPU = cpu;
616 action = xbt_new0(s_surf_action_cpu_KCCFLN05_t, 1);
618 action->generic_action.cost = size;
619 action->generic_action.remains = size;
620 action->generic_action.max_duration = NO_MAX_DURATION;
621 action->generic_action.start = surf_get_clock();
622 action->generic_action.finish = -1.0;
623 action->generic_action.resource_type =
624 (surf_resource_t) surf_cpu_resource;
626 if (CPU->state_current == SURF_CPU_ON)
627 action->generic_action.state_set =
628 surf_cpu_resource->common_public->states.running_action_set;
630 action->generic_action.state_set =
631 surf_cpu_resource->common_public->states.failed_action_set;
632 xbt_swag_insert(action, action->generic_action.state_set);
634 action->variable = lmm_variable_new(maxmin_system_cpu_KCCFLN05, action, 1.0, -1.0, 1);
635 lmm_expand(maxmin_system_cpu_KCCFLN05, CPU->constraint, action->variable,
638 return (surf_action_t) action;
641 static void cpu_KCCFLN05_action_suspend(surf_action_t action)
643 lmm_update_variable_weight(maxmin_system_cpu_KCCFLN05,
644 ((surf_action_cpu_KCCFLN05_t) action)->variable, 0.0);
647 static void cpu_KCCFLN05_action_resume(surf_action_t action)
649 lmm_update_variable_weight(maxmin_system_cpu_KCCFLN05,
650 ((surf_action_cpu_KCCFLN05_t) action)->variable, 1.0);
653 static int cpu_KCCFLN05_action_is_suspended(surf_action_t action)
655 return (lmm_get_variable_weight(((surf_action_cpu_KCCFLN05_t) action)->variable) == 0.0);
658 /************* workstation ************/
659 static void action_change_state(surf_action_t action,
660 e_surf_action_state_t state)
662 xbt_assert0(0, "Workstation is a virtual resource. I should not be there!");
663 surf_action_change_state(action, state);
667 static void action_free(surf_action_t action)
669 xbt_assert0(0, "Workstation is a virtual resource. I should not be there!");
673 static int resource_used(void *resource_id)
675 xbt_assert0(0, "Workstation is a virtual resource. I should not be there!");
679 static double share_resources(double now)
684 static void update_actions_state(double now, double delta)
689 static void update_resource_state(void *id,
690 tmgr_trace_event_t event_type,
693 xbt_assert0(0, "Workstation is a virtual resource. I should not be there!");
697 static void action_suspend(surf_action_t action)
699 if(action->resource_type==(surf_resource_t)surf_network_resource)
700 surf_network_resource->common_public->suspend(action);
701 else if(action->resource_type==(surf_resource_t)surf_cpu_resource)
702 surf_cpu_resource->common_public->suspend(action);
706 static void action_resume(surf_action_t action)
708 if(action->resource_type==(surf_resource_t)surf_network_resource)
709 surf_network_resource->common_public->resume(action);
710 else if(action->resource_type==(surf_resource_t)surf_cpu_resource)
711 surf_cpu_resource->common_public->resume(action);
715 static int action_is_suspended(surf_action_t action)
717 if(action->resource_type==(surf_resource_t)surf_network_resource)
718 return surf_network_resource->common_public->is_suspended(action);
719 if(action->resource_type==(surf_resource_t)surf_cpu_resource)
720 return surf_cpu_resource->common_public->is_suspended(action);
724 /**************************************/
725 /********* Module creation ***********/
726 /**************************************/
727 static void cpu_KCCFLN05_finalize(void)
729 xbt_dict_free(&workstation_set);
730 xbt_swag_free(surf_cpu_resource->common_public->states.ready_action_set);
731 xbt_swag_free(surf_cpu_resource->common_public->states.
733 xbt_swag_free(surf_cpu_resource->common_public->states.
735 xbt_swag_free(surf_cpu_resource->common_public->states.done_action_set);
736 xbt_free(surf_cpu_resource->common_public);
737 xbt_free(surf_cpu_resource->common_private);
738 xbt_free(surf_cpu_resource->extension_public);
740 xbt_free(surf_cpu_resource);
741 surf_cpu_resource = NULL;
743 if (maxmin_system_cpu_KCCFLN05) {
744 lmm_system_free(maxmin_system_cpu_KCCFLN05);
745 maxmin_system_cpu_KCCFLN05 = NULL;
749 static void cpu_KCCFLN05_resource_init_internal(void)
751 s_surf_action_t action;
753 surf_cpu_resource = xbt_new0(s_surf_cpu_resource_t, 1);
755 surf_cpu_resource->common_private =
756 xbt_new0(s_surf_resource_private_t, 1);
757 surf_cpu_resource->common_public =
758 xbt_new0(s_surf_resource_public_t, 1);
760 surf_cpu_resource->extension_public =
761 xbt_new0(s_surf_cpu_resource_extension_public_t, 1);
763 surf_cpu_resource->common_public->states.ready_action_set =
764 xbt_swag_new(xbt_swag_offset(action, state_hookup));
765 surf_cpu_resource->common_public->states.running_action_set =
766 xbt_swag_new(xbt_swag_offset(action, state_hookup));
767 surf_cpu_resource->common_public->states.failed_action_set =
768 xbt_swag_new(xbt_swag_offset(action, state_hookup));
769 surf_cpu_resource->common_public->states.done_action_set =
770 xbt_swag_new(xbt_swag_offset(action, state_hookup));
772 surf_cpu_resource->common_public->name_service = name_service;
773 surf_cpu_resource->common_public->get_resource_name = get_resource_name;
774 surf_cpu_resource->common_public->action_get_state =
775 surf_action_get_state;
776 surf_cpu_resource->common_public->action_free = action_cpu_KCCFLN05_free;
777 surf_cpu_resource->common_public->action_cancel = NULL;
778 surf_cpu_resource->common_public->action_recycle = NULL;
779 surf_cpu_resource->common_public->action_change_state = surf_action_change_state;
780 surf_cpu_resource->common_public->action_set_data = surf_action_set_data;
781 surf_cpu_resource->common_public->name = "CPU KCCFLN05";
783 surf_cpu_resource->common_private->resource_used = cpu_used;
784 surf_cpu_resource->common_private->share_resources = share_cpu_KCCFLN05_resources;
785 surf_cpu_resource->common_private->update_actions_state =
786 update_actions_cpu_KCCFLN05_state;
787 surf_cpu_resource->common_private->update_resource_state =
788 update_cpu_KCCFLN05_state;
789 surf_cpu_resource->common_private->finalize = cpu_KCCFLN05_finalize;
791 surf_cpu_resource->extension_public->execute = execute_KCCFLN05;
792 /*FIXME*//* surf_cpu_resource->extension_public->sleep = action_sleep; */
794 surf_cpu_resource->common_public->suspend = cpu_KCCFLN05_action_suspend;
795 surf_cpu_resource->common_public->resume = cpu_KCCFLN05_action_resume;
796 surf_cpu_resource->common_public->is_suspended = cpu_KCCFLN05_action_is_suspended;
798 surf_cpu_resource->extension_public->get_state = get_state;
800 workstation_set = xbt_dict_new();
802 maxmin_system_cpu_KCCFLN05 = lmm_system_new();
805 static void network_KCCFLN05_finalize(void)
809 xbt_dict_free(&network_link_set);
810 xbt_swag_free(surf_network_resource->common_public->states.
812 xbt_swag_free(surf_network_resource->common_public->states.
814 xbt_swag_free(surf_network_resource->common_public->states.
816 xbt_swag_free(surf_network_resource->common_public->states.
818 xbt_free(surf_network_resource->common_public);
819 xbt_free(surf_network_resource->common_private);
820 xbt_free(surf_network_resource->extension_public);
822 xbt_free(surf_network_resource);
823 surf_network_resource = NULL;
825 for (i = 0; i < nb_workstation; i++)
826 for (j = 0; j < nb_workstation; j++)
827 xbt_free(ROUTE(i,j).links);
828 xbt_free(routing_table);
829 routing_table = NULL;
832 if (maxmin_system_network_KCCFLN05) {
833 lmm_system_free(maxmin_system_network_KCCFLN05);
834 maxmin_system_network_KCCFLN05 = NULL;
838 static void network_KCCFLN05_resource_init_internal(void)
840 s_surf_action_t action;
842 surf_network_resource = xbt_new0(s_surf_network_resource_t, 1);
844 surf_network_resource->common_private =
845 xbt_new0(s_surf_resource_private_t, 1);
846 surf_network_resource->common_public =
847 xbt_new0(s_surf_resource_public_t, 1);
848 surf_network_resource->extension_public =
849 xbt_new0(s_surf_network_resource_extension_public_t, 1);
851 surf_network_resource->common_public->states.ready_action_set =
852 xbt_swag_new(xbt_swag_offset(action, state_hookup));
853 surf_network_resource->common_public->states.running_action_set =
854 xbt_swag_new(xbt_swag_offset(action, state_hookup));
855 surf_network_resource->common_public->states.failed_action_set =
856 xbt_swag_new(xbt_swag_offset(action, state_hookup));
857 surf_network_resource->common_public->states.done_action_set =
858 xbt_swag_new(xbt_swag_offset(action, state_hookup));
860 surf_network_resource->common_public->name_service = name_service;
861 surf_network_resource->common_public->get_resource_name = get_resource_name;
862 surf_network_resource->common_public->action_get_state =
863 surf_action_get_state;
864 surf_network_resource->common_public->action_free = action_network_KCCFLN05_free;
865 surf_network_resource->common_public->action_cancel = NULL;
866 surf_network_resource->common_public->action_recycle = NULL;
867 surf_network_resource->common_public->action_change_state = action_network_KCCFLN05_change_state;
868 surf_network_resource->common_public->action_set_data = surf_action_set_data;
869 surf_network_resource->common_public->name = "network KCCFLN05";
871 surf_network_resource->common_private->resource_used = link_used;
872 surf_network_resource->common_private->share_resources = share_network_KCCFLN05_resources;
873 surf_network_resource->common_private->update_actions_state =
874 update_actions_network_KCCFLN05_state;
875 surf_network_resource->common_private->update_resource_state =
876 update_network_KCCFLN05_state;
877 surf_network_resource->common_private->finalize = network_KCCFLN05_finalize;
879 surf_network_resource->common_public->suspend = network_KCCFLN05_action_suspend;
880 surf_network_resource->common_public->resume = network_KCCFLN05_action_resume;
881 surf_network_resource->common_public->is_suspended = network_KCCFLN05_action_is_suspended;
883 surf_network_resource->extension_public->communicate = communicate_KCCFLN05;
885 network_link_set = xbt_dict_new();
888 maxmin_system_network_KCCFLN05 = lmm_system_new();
891 static void workstation_KCCFLN05_finalize(void)
893 xbt_swag_free(surf_workstation_resource->common_public->states.ready_action_set);
894 xbt_swag_free(surf_workstation_resource->common_public->states.running_action_set);
895 xbt_swag_free(surf_workstation_resource->common_public->states.failed_action_set);
896 xbt_swag_free(surf_workstation_resource->common_public->states.done_action_set);
898 xbt_free(surf_workstation_resource->common_public);
899 xbt_free(surf_workstation_resource->common_private);
900 xbt_free(surf_workstation_resource->extension_public);
902 xbt_free(surf_workstation_resource);
903 surf_workstation_resource = NULL;
906 static void workstation_KCCFLN05_resource_init_internal(void)
908 s_surf_action_t action;
910 surf_workstation_resource = xbt_new0(s_surf_workstation_resource_t, 1);
912 surf_workstation_resource->common_private =
913 xbt_new0(s_surf_resource_private_t, 1);
914 surf_workstation_resource->common_public =
915 xbt_new0(s_surf_resource_public_t, 1);
916 surf_workstation_resource->extension_public =
917 xbt_new0(s_surf_workstation_resource_extension_public_t, 1);
919 surf_workstation_resource->common_public->states.ready_action_set =
920 xbt_swag_new(xbt_swag_offset(action, state_hookup));
921 surf_workstation_resource->common_public->states.running_action_set =
922 xbt_swag_new(xbt_swag_offset(action, state_hookup));
923 surf_workstation_resource->common_public->states.failed_action_set =
924 xbt_swag_new(xbt_swag_offset(action, state_hookup));
925 surf_workstation_resource->common_public->states.done_action_set =
926 xbt_swag_new(xbt_swag_offset(action, state_hookup));
928 surf_workstation_resource->common_public->name_service = name_service;
929 surf_workstation_resource->common_public->get_resource_name =
931 surf_workstation_resource->common_public->action_get_state =
932 surf_action_get_state;
933 surf_workstation_resource->common_public->action_free = action_free;
934 surf_workstation_resource->common_public->action_cancel = NULL;
935 surf_workstation_resource->common_public->action_recycle = NULL;
936 surf_workstation_resource->common_public->action_change_state = action_change_state;
937 surf_workstation_resource->common_public->action_set_data = surf_action_set_data;
938 surf_workstation_resource->common_public->name = "Workstation KCCFLN05";
940 surf_workstation_resource->common_private->resource_used = resource_used;
941 surf_workstation_resource->common_private->share_resources = share_resources;
942 surf_workstation_resource->common_private->update_actions_state = update_actions_state;
943 surf_workstation_resource->common_private->update_resource_state = update_resource_state;
944 surf_workstation_resource->common_private->finalize = workstation_KCCFLN05_finalize;
947 surf_workstation_resource->common_public->suspend = action_suspend;
948 surf_workstation_resource->common_public->resume = action_resume;
949 surf_workstation_resource->common_public->is_suspended = action_is_suspended;
951 surf_workstation_resource->extension_public->execute = execute_KCCFLN05;
952 /*FIXME*//* surf_workstation_resource->extension_public->sleep = action_sleep; */
953 surf_workstation_resource->extension_public->get_state = get_state;
954 surf_workstation_resource->extension_public->communicate = communicate_KCCFLN05;
957 /**************************************/
958 /*************** Generic **************/
959 /**************************************/
961 void surf_workstation_resource_init_KCCFLN05(const char *filename)
963 xbt_assert0(!surf_cpu_resource,"CPU resource type already defined");
964 cpu_KCCFLN05_resource_init_internal();
965 xbt_assert0(!surf_network_resource,"network resource type already defined");
966 network_KCCFLN05_resource_init_internal();
967 workstation_KCCFLN05_resource_init_internal();
968 parse_file(filename);
970 xbt_dynar_push(resource_list, &surf_network_resource);
971 xbt_dynar_push(resource_list, &surf_cpu_resource);
972 xbt_dynar_push(resource_list, &surf_workstation_resource);
974 if (maxmin_system) { /* To avoid using this useless system */
975 lmm_system_free(maxmin_system);
976 maxmin_system = NULL;