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,
44 double max_outgoing_rate)
46 workstation_KCCFLN05_t workstation = xbt_new0(s_workstation_KCCFLN05_t, 1);
48 workstation->resource = (surf_resource_t) surf_workstation_resource;
49 workstation->name = xbt_strdup(name);
50 workstation->id = nb_workstation++;
52 workstation->power_scale = power_scale;
53 workstation->power_current = power_initial;
55 workstation->power_event =
56 tmgr_history_add_trace(history, power_trace, 0.0, 0, workstation);
58 workstation->state_current = state_initial;
60 workstation->state_event =
61 tmgr_history_add_trace(history, state_trace, 0.0, 0, workstation);
63 workstation->interference_send=interference_send;
64 workstation->interference_recv=interference_recv;
65 workstation->interference_send_recv=interference_send_recv;
67 workstation->constraint =
68 lmm_constraint_new(maxmin_system_cpu_KCCFLN05, workstation,
69 workstation->power_current * workstation->power_scale);
70 if(max_outgoing_rate>0)
72 lmm_constraint_new(maxmin_system_cpu_KCCFLN05, workstation,
75 workstation->incomming_communications =
76 xbt_dynar_new(sizeof(surf_action_network_KCCFLN05_t),NULL);
77 workstation->outgoing_communications =
78 xbt_dynar_new(sizeof(surf_action_network_KCCFLN05_t),NULL);
80 xbt_dict_set(workstation_set, name, workstation, workstation_free);
85 static void parse_workstation(void)
87 double power_scale = 0.0;
88 double power_initial = 0.0;
89 tmgr_trace_t power_trace = NULL;
90 e_surf_cpu_state_t state_initial = SURF_CPU_OFF;
91 tmgr_trace_t state_trace = NULL;
92 double interference_send = 0.0;
93 double interference_recv = 0.0;
94 double interference_send_recv = 0.0;
95 double max_outgoing_rate = -1.0;
97 surf_parse_get_double(&power_scale,A_cpu_power);
98 surf_parse_get_double(&power_initial,A_cpu_availability);
99 surf_parse_get_trace(&power_trace,A_cpu_availability_file);
101 xbt_assert0((A_cpu_state==A_cpu_state_ON)||
102 (A_cpu_state==A_cpu_state_OFF),
104 if (A_cpu_state==A_cpu_state_ON) state_initial = SURF_CPU_ON;
105 if (A_cpu_state==A_cpu_state_OFF) state_initial = SURF_CPU_OFF;
106 surf_parse_get_trace(&state_trace,A_cpu_state_file);
108 surf_parse_get_double(&interference_send,A_cpu_interference_send);
109 surf_parse_get_double(&interference_recv,A_cpu_interference_recv);
110 surf_parse_get_double(&interference_send_recv,A_cpu_interference_send_recv);
111 surf_parse_get_double(&max_outgoing_rate,A_cpu_max_outgoing_rate);
113 workstation_new(A_cpu_name, power_scale, power_initial, power_trace, state_initial,
114 state_trace, interference_send, interference_recv,
115 interference_send_recv, max_outgoing_rate);
118 /*********** resource management ***********/
120 static void *name_service(const char *name)
122 void *workstation = NULL;
124 xbt_dict_get(workstation_set, name, &workstation);
129 static const char *get_resource_name(void *resource_id)
131 return ((workstation_KCCFLN05_t) resource_id)->name;
134 static int cpu_used(void *resource_id)
136 return lmm_constraint_used(maxmin_system_cpu_KCCFLN05,
137 ((workstation_KCCFLN05_t) resource_id)->constraint);
140 static int link_used(void *resource_id)
142 return lmm_constraint_used(maxmin_system_network_KCCFLN05,
143 ((network_link_KCCFLN05_t) resource_id)->constraint);
146 static e_surf_cpu_state_t get_state(void *cpu)
148 return ((workstation_KCCFLN05_t) cpu)->state_current;
151 static void update_cpu_KCCFLN05_state(void *id,
152 tmgr_trace_event_t event_type,
155 workstation_KCCFLN05_t cpu = id;
157 if (event_type == cpu->power_event) {
158 cpu->power_current = value;
159 /*** The bound is updated in share_cpu_KCCFLN05_resources ***/
160 /* lmm_update_constraint_bound(maxmin_system_cpu_KCCFLN05, cpu->constraint, */
161 /* cpu->power_current * cpu->power_scale); */
162 } else if (event_type == cpu->state_event) {
164 cpu->state_current = SURF_CPU_ON;
166 cpu->state_current = SURF_CPU_OFF;
168 CRITICAL0("Unknown event ! \n");
175 /**************************************/
176 /*********** network object ***********/
177 /**************************************/
179 static void create_routing_table(void)
181 routing_table = xbt_new0(s_route_KCCFLN05_t, nb_workstation * nb_workstation);
184 static void network_link_free(void *nw_link)
186 xbt_free(((network_link_KCCFLN05_t)nw_link)->name);
190 static network_link_KCCFLN05_t network_link_new(char *name,
192 tmgr_trace_t bw_trace,
193 e_surf_network_link_state_t
195 tmgr_trace_t state_trace)
197 network_link_KCCFLN05_t nw_link = xbt_new0(s_network_link_KCCFLN05_t, 1);
200 nw_link->resource = (surf_resource_t) surf_network_resource;
201 nw_link->name = name;
202 nw_link->bw_current = bw_initial;
205 tmgr_history_add_trace(history, bw_trace, 0.0, 0, nw_link);
206 nw_link->state_current = state_initial;
208 nw_link->state_event =
209 tmgr_history_add_trace(history, state_trace, 0.0, 0, nw_link);
211 nw_link->constraint =
212 lmm_constraint_new(maxmin_system_network_KCCFLN05, nw_link, nw_link->bw_current);
214 xbt_dict_set(network_link_set, name, nw_link, network_link_free);
219 static void parse_network_link(void)
223 tmgr_trace_t bw_trace;
224 e_surf_network_link_state_t state_initial = SURF_NETWORK_LINK_ON;
225 tmgr_trace_t state_trace;
227 name = xbt_strdup(A_network_link_name);
228 surf_parse_get_double(&bw_initial,A_network_link_bandwidth);
229 surf_parse_get_trace(&bw_trace, A_network_link_bandwidth_file);
231 xbt_assert0((A_network_link_state==A_network_link_state_ON)||
232 (A_network_link_state==A_network_link_state_OFF),
234 if (A_network_link_state==A_network_link_state_ON)
235 state_initial = SURF_NETWORK_LINK_ON;
236 if (A_network_link_state==A_network_link_state_OFF)
237 state_initial = SURF_NETWORK_LINK_OFF;
238 surf_parse_get_trace(&state_trace,A_network_link_state_file);
240 network_link_new(name, bw_initial, bw_trace, state_initial, state_trace);
243 static void route_new(int src_id, int dst_id, char **links, int nb_link,
244 double impact_on_src, double impact_on_dst,
245 double impact_on_src_with_other_recv,
246 double impact_on_dst_with_other_send)
248 network_link_KCCFLN05_t *link_list = NULL;
250 route_KCCFLN05_t route = &(ROUTE(src_id,dst_id));
252 route->size= nb_link;
253 link_list = route->links = xbt_new0(network_link_KCCFLN05_t, nb_link);
254 for (i = 0; i < nb_link; i++) {
255 xbt_dict_get(network_link_set, links[i], (void *) &(link_list[i]));
259 route->impact_on_src=impact_on_src;
260 route->impact_on_dst=impact_on_src;
261 route->impact_on_src_with_other_recv=impact_on_src_with_other_recv;
262 route->impact_on_dst_with_other_send=impact_on_dst_with_other_send;
265 static int nb_link = 0;
266 static char **link_name = NULL;
267 static int src_id = -1;
268 static int dst_id = -1;
269 static double impact_on_src;
270 static double impact_on_dst;
271 static double impact_on_src_with_other_recv;
272 static double impact_on_dst_with_other_send;
274 static void parse_route_set_endpoints(void)
276 src_id = ((workstation_KCCFLN05_t) name_service(A_route_src))->id;
277 dst_id = ((workstation_KCCFLN05_t) name_service(A_route_dst))->id;
278 surf_parse_get_double(&impact_on_src,A_route_impact_on_src);
279 surf_parse_get_double(&impact_on_dst,A_route_impact_on_dst);
280 surf_parse_get_double(&impact_on_src_with_other_recv,A_route_impact_on_src_with_other_recv);
281 surf_parse_get_double(&impact_on_dst_with_other_send,A_route_impact_on_dst_with_other_send);
287 static void parse_route_elem(void)
290 link_name = xbt_realloc(link_name, (nb_link) * sizeof(char *));
291 link_name[(nb_link) - 1] = xbt_strdup(A_route_element_name);
294 static void parse_route_set_route(void)
296 route_new(src_id, dst_id, link_name, nb_link, impact_on_src, impact_on_dst,
297 impact_on_src_with_other_recv, impact_on_dst_with_other_send);
300 static void parse_file(const char *file)
302 /* Figuring out the workstations */
303 surf_parse_reset_parser();
304 ETag_cpu_fun=parse_workstation;
305 surf_parse_open(file);
306 xbt_assert1((!surf_parse()),"Parse error in %s",file);
309 create_routing_table();
311 /* Figuring out the network links */
312 surf_parse_reset_parser();
313 ETag_network_link_fun=parse_network_link;
314 surf_parse_open(file);
315 xbt_assert1((!surf_parse()),"Parse error in %s",file);
318 /* Building the routes */
319 surf_parse_reset_parser();
320 STag_route_fun=parse_route_set_endpoints;
321 ETag_route_element_fun=parse_route_elem;
322 ETag_route_fun=parse_route_set_route;
323 surf_parse_open(file);
324 xbt_assert1((!surf_parse()),"Parse error in %s",file);
328 static void update_network_KCCFLN05_state(void *id,
329 tmgr_trace_event_t event_type,
332 network_link_KCCFLN05_t nw_link = id;
334 if (event_type == nw_link->bw_event) {
335 nw_link->bw_current = value;
336 lmm_update_constraint_bound(maxmin_system_network_KCCFLN05, nw_link->constraint,
337 nw_link->bw_current);
338 } else if (event_type == nw_link->state_event) {
340 nw_link->state_current = SURF_NETWORK_LINK_ON;
342 nw_link->state_current = SURF_NETWORK_LINK_OFF;
344 CRITICAL0("Unknown event ! \n");
351 /**************************************/
352 /*************** actions **************/
353 /**************************************/
354 /*************** network **************/
355 static void action_network_KCCFLN05_free(surf_action_t action)
358 surf_action_t act = NULL;
359 workstation_KCCFLN05_t src = ((surf_action_network_KCCFLN05_t) action)->src;
360 workstation_KCCFLN05_t dst = ((surf_action_network_KCCFLN05_t) action)->dst;
362 xbt_swag_remove(action, action->state_set);
363 lmm_variable_free(maxmin_system_network_KCCFLN05,
364 ((surf_action_network_KCCFLN05_t) action)->variable);
366 xbt_dynar_foreach (src->outgoing_communications,cpt,act) {
368 xbt_dynar_remove_at(src->outgoing_communications, cpt, &act);
373 xbt_dynar_foreach (dst->incomming_communications,cpt,act) {
375 xbt_dynar_remove_at(dst->incomming_communications, cpt, &act);
383 static double share_network_KCCFLN05_resources(double now)
385 s_surf_action_network_KCCFLN05_t action;
386 return generic_maxmin_share_resources2(surf_network_resource->common_public->
387 states.running_action_set,
388 xbt_swag_offset(action, variable),
389 maxmin_system_network_KCCFLN05);
392 static void action_network_KCCFLN05_change_state(surf_action_t action,
393 e_surf_action_state_t state)
395 surf_action_change_state(action, state);
399 static void update_actions_network_KCCFLN05_state(double now, double delta)
401 surf_action_network_KCCFLN05_t action = NULL;
402 surf_action_network_KCCFLN05_t next_action = NULL;
403 xbt_swag_t running_actions =
404 surf_network_resource->common_public->states.running_action_set;
405 xbt_swag_t failed_actions =
406 surf_network_resource->common_public->states.failed_action_set;
408 xbt_swag_foreach_safe(action, next_action, running_actions) {
409 surf_double_update(&(action->generic_action.remains),
410 lmm_variable_getvalue(action->variable) * delta);
411 if (action->generic_action.max_duration != NO_MAX_DURATION)
412 surf_double_update(&(action->generic_action.max_duration), delta);
413 if ((action->generic_action.remains <= 0.0) &&
414 (lmm_get_variable_weight(action->variable)>0)) {
415 action->generic_action.finish = surf_get_clock();
416 action_network_KCCFLN05_change_state((surf_action_t) action, SURF_ACTION_DONE);
417 } else if ((action->generic_action.max_duration != NO_MAX_DURATION) &&
418 (action->generic_action.max_duration <= 0.0)) {
419 action->generic_action.finish = surf_get_clock();
420 action_network_KCCFLN05_change_state((surf_action_t) action, SURF_ACTION_DONE);
421 } else { /* Need to check that none of the resource has failed */
422 /* FIXME : FAILURES ARE NOT HANDLED YET */
426 xbt_swag_foreach_safe(action, next_action, failed_actions) {
427 lmm_variable_disable(maxmin_system_network_KCCFLN05, action->variable);
433 static surf_action_t communicate_KCCFLN05(void *src, void *dst, double size,
436 surf_action_network_KCCFLN05_t action = NULL;
437 workstation_KCCFLN05_t card_src = src;
438 workstation_KCCFLN05_t card_dst = dst;
439 route_KCCFLN05_t route = &ROUTE(card_src->id, card_dst->id);
442 action = xbt_new0(s_surf_action_network_KCCFLN05_t, 1);
444 action->generic_action.cost = size;
445 action->generic_action.remains = size;
446 action->generic_action.max_duration = NO_MAX_DURATION;
447 action->generic_action.start = -1.0;
448 action->generic_action.finish = -1.0;
449 action->generic_action.resource_type =
450 (surf_resource_t) surf_network_resource;
452 action->generic_action.state_set =
453 surf_network_resource->common_public->states.running_action_set;
455 xbt_swag_insert(action, action->generic_action.state_set);
458 action->variable = lmm_variable_new(maxmin_system_network_KCCFLN05, action, 1.0, rate,
461 action->variable = lmm_variable_new(maxmin_system_network_KCCFLN05, action, 1.0, -1.0,
464 for (i = 0; i < route->size; i++)
465 lmm_expand(maxmin_system_network_KCCFLN05, route->links[i]->constraint,
466 action->variable, 1.0);
469 lmm_expand(maxmin_system_network_KCCFLN05, card_src->bus,
470 action->variable, 1.0);
475 xbt_dynar_push(card_src->outgoing_communications,&action);
476 xbt_dynar_push(card_dst->incomming_communications,&action);
478 return (surf_action_t) action;
481 static void network_KCCFLN05_action_suspend(surf_action_t action)
483 lmm_update_variable_weight(maxmin_system_network_KCCFLN05,
484 ((surf_action_network_KCCFLN05_t) action)->variable, 0.0);
487 static void network_KCCFLN05_action_resume(surf_action_t action)
489 lmm_update_variable_weight(maxmin_system_network_KCCFLN05,
490 ((surf_action_network_KCCFLN05_t) action)->variable, 1.0);
493 static int network_KCCFLN05_action_is_suspended(surf_action_t action)
495 return (lmm_get_variable_weight(((surf_action_network_KCCFLN05_t) action)->variable) == 0.0);
498 /***************** CPU ****************/
499 static void action_cpu_KCCFLN05_free(surf_action_t action)
501 xbt_swag_remove(action, action->state_set);
502 lmm_variable_free(maxmin_system_cpu_KCCFLN05, ((surf_action_cpu_KCCFLN05_t)action)->variable);
506 /* #define WARNING(format, ...) (fprintf(stderr, "[%s , %s : %d] ", __FILE__, __FUNCTION__, __LINE__),\ */
507 /* fprintf(stderr, format, ## __VA_ARGS__), \ */
508 /* fprintf(stderr, "\n")) */
509 /* #define VOIRP(expr) WARNING(" {" #expr " = %p }", expr) */
510 /* #define VOIRD(expr) WARNING(" {" #expr " = %d }", expr) */
511 /* #define VOIRG(expr) WARNING(" {" #expr " = %lg }", expr) */
513 static double share_cpu_KCCFLN05_resources(double now)
515 s_surf_action_cpu_KCCFLN05_t s_cpu_action;
516 lmm_constraint_t cnst = NULL;
517 workstation_KCCFLN05_t workstation = NULL;
521 surf_action_network_KCCFLN05_t action;
523 for(cnst = lmm_get_first_active_constraint(maxmin_system_cpu_KCCFLN05);
525 cnst= lmm_get_next_active_constraint(maxmin_system_cpu_KCCFLN05, cnst))
527 workstation = lmm_constraint_id(cnst);
528 W=workstation->power_current * workstation->power_scale;
530 if((!xbt_dynar_length(workstation->incomming_communications)) &&
531 (!xbt_dynar_length(workstation->outgoing_communications))) {
533 } else if((!xbt_dynar_length(workstation->incomming_communications)) &&
534 (xbt_dynar_length(workstation->outgoing_communications))) {
535 scale = workstation->interference_send;
536 xbt_dynar_foreach (workstation->outgoing_communications,cpt,action) {
537 /* VOIRD(action->src->id); */
538 /* VOIRD(action->dst->id); */
539 /* VOIRP(&ROUTE(action->src->id,action->dst->id)); */
540 /* VOIRG(ROUTE(action->src->id,action->dst->id).impact_on_src); */
541 scale -= ROUTE(action->src->id,action->dst->id).impact_on_src *
542 lmm_variable_getvalue(action->variable);
544 if(scale<0.0) scale=0.0;
545 xbt_assert0(scale>=0.0,"Negative interference !");
546 } else if((xbt_dynar_length(workstation->incomming_communications)) &&
547 (!xbt_dynar_length(workstation->outgoing_communications))) {
548 scale = workstation->interference_recv;
549 xbt_dynar_foreach (workstation->incomming_communications,cpt,action) {
550 scale -= ROUTE(action->src->id,action->dst->id).impact_on_dst *
551 lmm_variable_getvalue(action->variable);
553 if(scale<0.0) scale=0.0;
554 xbt_assert0(scale>=0.0,"Negative interference !");
556 scale = workstation->interference_send_recv;
557 xbt_dynar_foreach (workstation->outgoing_communications,cpt,action) {
558 scale -= ROUTE(action->src->id,action->dst->id).impact_on_src_with_other_recv *
559 lmm_variable_getvalue(action->variable);
561 xbt_dynar_foreach (workstation->incomming_communications,cpt,action) {
562 scale -= ROUTE(action->src->id,action->dst->id).impact_on_dst_with_other_send *
563 lmm_variable_getvalue(action->variable);
565 if(scale<0.0) scale=0.0;
566 xbt_assert0(scale>=0.0,"Negative interference !");
568 lmm_update_constraint_bound(maxmin_system_cpu_KCCFLN05,workstation->constraint,
572 return generic_maxmin_share_resources2(surf_cpu_resource->common_public->
573 states.running_action_set,
574 xbt_swag_offset(s_cpu_action, variable),
575 maxmin_system_cpu_KCCFLN05);
578 static void update_actions_cpu_KCCFLN05_state(double now, double delta)
580 surf_action_cpu_KCCFLN05_t action = NULL;
581 surf_action_cpu_KCCFLN05_t next_action = NULL;
582 xbt_swag_t running_actions =
583 surf_cpu_resource->common_public->states.running_action_set;
584 xbt_swag_t failed_actions =
585 surf_cpu_resource->common_public->states.failed_action_set;
587 xbt_swag_foreach_safe(action, next_action, running_actions) {
588 surf_double_update(&(action->generic_action.remains),
589 lmm_variable_getvalue(action->variable) * delta);
590 if (action->generic_action.max_duration != NO_MAX_DURATION)
591 action->generic_action.max_duration -= delta;
592 if ((action->generic_action.remains <= 0) &&
593 (lmm_get_variable_weight(action->variable)>0)) {
594 action->generic_action.finish = surf_get_clock();
595 surf_action_change_state((surf_action_t) action, SURF_ACTION_DONE);
596 } else if ((action->generic_action.max_duration != NO_MAX_DURATION) &&
597 (action->generic_action.max_duration <= 0)) {
598 action->generic_action.finish = surf_get_clock();
599 surf_action_change_state((surf_action_t) action, SURF_ACTION_DONE);
600 } else { /* Need to check that none of the resource has failed */
601 lmm_constraint_t cnst = NULL;
603 workstation_KCCFLN05_t cpu = NULL;
606 lmm_get_cnst_from_var(maxmin_system_cpu_KCCFLN05, action->variable,
608 cpu = lmm_constraint_id(cnst);
609 if (cpu->state_current == SURF_CPU_OFF) {
610 action->generic_action.finish = surf_get_clock();
611 surf_action_change_state((surf_action_t) action, SURF_ACTION_FAILED);
618 xbt_swag_foreach_safe(action, next_action, failed_actions) {
619 lmm_variable_disable(maxmin_system_cpu_KCCFLN05, action->variable);
625 static surf_action_t execute_KCCFLN05(void *cpu, double size)
627 surf_action_cpu_KCCFLN05_t action = NULL;
628 workstation_KCCFLN05_t CPU = cpu;
630 action = xbt_new0(s_surf_action_cpu_KCCFLN05_t, 1);
632 action->generic_action.cost = size;
633 action->generic_action.remains = size;
634 action->generic_action.max_duration = NO_MAX_DURATION;
635 action->generic_action.start = surf_get_clock();
636 action->generic_action.finish = -1.0;
637 action->generic_action.resource_type =
638 (surf_resource_t) surf_cpu_resource;
640 if (CPU->state_current == SURF_CPU_ON)
641 action->generic_action.state_set =
642 surf_cpu_resource->common_public->states.running_action_set;
644 action->generic_action.state_set =
645 surf_cpu_resource->common_public->states.failed_action_set;
646 xbt_swag_insert(action, action->generic_action.state_set);
648 action->variable = lmm_variable_new(maxmin_system_cpu_KCCFLN05, action, 1.0, -1.0, 1);
649 lmm_expand(maxmin_system_cpu_KCCFLN05, CPU->constraint, action->variable,
652 return (surf_action_t) action;
655 static void cpu_KCCFLN05_action_suspend(surf_action_t action)
657 lmm_update_variable_weight(maxmin_system_cpu_KCCFLN05,
658 ((surf_action_cpu_KCCFLN05_t) action)->variable, 0.0);
661 static void cpu_KCCFLN05_action_resume(surf_action_t action)
663 lmm_update_variable_weight(maxmin_system_cpu_KCCFLN05,
664 ((surf_action_cpu_KCCFLN05_t) action)->variable, 1.0);
667 static int cpu_KCCFLN05_action_is_suspended(surf_action_t action)
669 return (lmm_get_variable_weight(((surf_action_cpu_KCCFLN05_t) action)->variable) == 0.0);
672 /************* workstation ************/
673 static void action_change_state(surf_action_t action,
674 e_surf_action_state_t state)
676 xbt_assert0(0, "Workstation is a virtual resource. I should not be there!");
677 surf_action_change_state(action, state);
681 static void action_free(surf_action_t action)
683 xbt_assert0(0, "Workstation is a virtual resource. I should not be there!");
687 static int resource_used(void *resource_id)
689 xbt_assert0(0, "Workstation is a virtual resource. I should not be there!");
693 static double share_resources(double now)
698 static void update_actions_state(double now, double delta)
703 static void update_resource_state(void *id,
704 tmgr_trace_event_t event_type,
707 xbt_assert0(0, "Workstation is a virtual resource. I should not be there!");
711 static void action_suspend(surf_action_t action)
713 if(action->resource_type==(surf_resource_t)surf_network_resource)
714 surf_network_resource->common_public->suspend(action);
715 else if(action->resource_type==(surf_resource_t)surf_cpu_resource)
716 surf_cpu_resource->common_public->suspend(action);
720 static void action_resume(surf_action_t action)
722 if(action->resource_type==(surf_resource_t)surf_network_resource)
723 surf_network_resource->common_public->resume(action);
724 else if(action->resource_type==(surf_resource_t)surf_cpu_resource)
725 surf_cpu_resource->common_public->resume(action);
729 static int action_is_suspended(surf_action_t action)
731 if(action->resource_type==(surf_resource_t)surf_network_resource)
732 return surf_network_resource->common_public->is_suspended(action);
733 if(action->resource_type==(surf_resource_t)surf_cpu_resource)
734 return surf_cpu_resource->common_public->is_suspended(action);
738 /**************************************/
739 /********* Module creation ***********/
740 /**************************************/
741 static void cpu_KCCFLN05_finalize(void)
743 xbt_dict_free(&workstation_set);
744 xbt_swag_free(surf_cpu_resource->common_public->states.ready_action_set);
745 xbt_swag_free(surf_cpu_resource->common_public->states.
747 xbt_swag_free(surf_cpu_resource->common_public->states.
749 xbt_swag_free(surf_cpu_resource->common_public->states.done_action_set);
750 xbt_free(surf_cpu_resource->common_public);
751 xbt_free(surf_cpu_resource->common_private);
752 xbt_free(surf_cpu_resource->extension_public);
754 xbt_free(surf_cpu_resource);
755 surf_cpu_resource = NULL;
757 if (maxmin_system_cpu_KCCFLN05) {
758 lmm_system_free(maxmin_system_cpu_KCCFLN05);
759 maxmin_system_cpu_KCCFLN05 = NULL;
763 static void cpu_KCCFLN05_resource_init_internal(void)
765 s_surf_action_t action;
767 surf_cpu_resource = xbt_new0(s_surf_cpu_resource_t, 1);
769 surf_cpu_resource->common_private =
770 xbt_new0(s_surf_resource_private_t, 1);
771 surf_cpu_resource->common_public =
772 xbt_new0(s_surf_resource_public_t, 1);
774 surf_cpu_resource->extension_public =
775 xbt_new0(s_surf_cpu_resource_extension_public_t, 1);
777 surf_cpu_resource->common_public->states.ready_action_set =
778 xbt_swag_new(xbt_swag_offset(action, state_hookup));
779 surf_cpu_resource->common_public->states.running_action_set =
780 xbt_swag_new(xbt_swag_offset(action, state_hookup));
781 surf_cpu_resource->common_public->states.failed_action_set =
782 xbt_swag_new(xbt_swag_offset(action, state_hookup));
783 surf_cpu_resource->common_public->states.done_action_set =
784 xbt_swag_new(xbt_swag_offset(action, state_hookup));
786 surf_cpu_resource->common_public->name_service = name_service;
787 surf_cpu_resource->common_public->get_resource_name = get_resource_name;
788 surf_cpu_resource->common_public->action_get_state =
789 surf_action_get_state;
790 surf_cpu_resource->common_public->action_free = action_cpu_KCCFLN05_free;
791 surf_cpu_resource->common_public->action_cancel = NULL;
792 surf_cpu_resource->common_public->action_recycle = NULL;
793 surf_cpu_resource->common_public->action_change_state = surf_action_change_state;
794 surf_cpu_resource->common_public->action_set_data = surf_action_set_data;
795 surf_cpu_resource->common_public->name = "CPU KCCFLN05";
797 surf_cpu_resource->common_private->resource_used = cpu_used;
798 surf_cpu_resource->common_private->share_resources = share_cpu_KCCFLN05_resources;
799 surf_cpu_resource->common_private->update_actions_state =
800 update_actions_cpu_KCCFLN05_state;
801 surf_cpu_resource->common_private->update_resource_state =
802 update_cpu_KCCFLN05_state;
803 surf_cpu_resource->common_private->finalize = cpu_KCCFLN05_finalize;
805 surf_cpu_resource->extension_public->execute = execute_KCCFLN05;
806 /*FIXME*//* surf_cpu_resource->extension_public->sleep = action_sleep; */
808 surf_cpu_resource->common_public->suspend = cpu_KCCFLN05_action_suspend;
809 surf_cpu_resource->common_public->resume = cpu_KCCFLN05_action_resume;
810 surf_cpu_resource->common_public->is_suspended = cpu_KCCFLN05_action_is_suspended;
812 surf_cpu_resource->extension_public->get_state = get_state;
814 workstation_set = xbt_dict_new();
816 maxmin_system_cpu_KCCFLN05 = lmm_system_new();
819 static void network_KCCFLN05_finalize(void)
823 xbt_dict_free(&network_link_set);
824 xbt_swag_free(surf_network_resource->common_public->states.
826 xbt_swag_free(surf_network_resource->common_public->states.
828 xbt_swag_free(surf_network_resource->common_public->states.
830 xbt_swag_free(surf_network_resource->common_public->states.
832 xbt_free(surf_network_resource->common_public);
833 xbt_free(surf_network_resource->common_private);
834 xbt_free(surf_network_resource->extension_public);
836 xbt_free(surf_network_resource);
837 surf_network_resource = NULL;
839 for (i = 0; i < nb_workstation; i++)
840 for (j = 0; j < nb_workstation; j++)
841 xbt_free(ROUTE(i,j).links);
842 xbt_free(routing_table);
843 routing_table = NULL;
846 if (maxmin_system_network_KCCFLN05) {
847 lmm_system_free(maxmin_system_network_KCCFLN05);
848 maxmin_system_network_KCCFLN05 = NULL;
852 static void network_KCCFLN05_resource_init_internal(void)
854 s_surf_action_t action;
856 surf_network_resource = xbt_new0(s_surf_network_resource_t, 1);
858 surf_network_resource->common_private =
859 xbt_new0(s_surf_resource_private_t, 1);
860 surf_network_resource->common_public =
861 xbt_new0(s_surf_resource_public_t, 1);
862 surf_network_resource->extension_public =
863 xbt_new0(s_surf_network_resource_extension_public_t, 1);
865 surf_network_resource->common_public->states.ready_action_set =
866 xbt_swag_new(xbt_swag_offset(action, state_hookup));
867 surf_network_resource->common_public->states.running_action_set =
868 xbt_swag_new(xbt_swag_offset(action, state_hookup));
869 surf_network_resource->common_public->states.failed_action_set =
870 xbt_swag_new(xbt_swag_offset(action, state_hookup));
871 surf_network_resource->common_public->states.done_action_set =
872 xbt_swag_new(xbt_swag_offset(action, state_hookup));
874 surf_network_resource->common_public->name_service = name_service;
875 surf_network_resource->common_public->get_resource_name = get_resource_name;
876 surf_network_resource->common_public->action_get_state =
877 surf_action_get_state;
878 surf_network_resource->common_public->action_free = action_network_KCCFLN05_free;
879 surf_network_resource->common_public->action_cancel = NULL;
880 surf_network_resource->common_public->action_recycle = NULL;
881 surf_network_resource->common_public->action_change_state = action_network_KCCFLN05_change_state;
882 surf_network_resource->common_public->action_set_data = surf_action_set_data;
883 surf_network_resource->common_public->name = "network KCCFLN05";
885 surf_network_resource->common_private->resource_used = link_used;
886 surf_network_resource->common_private->share_resources = share_network_KCCFLN05_resources;
887 surf_network_resource->common_private->update_actions_state =
888 update_actions_network_KCCFLN05_state;
889 surf_network_resource->common_private->update_resource_state =
890 update_network_KCCFLN05_state;
891 surf_network_resource->common_private->finalize = network_KCCFLN05_finalize;
893 surf_network_resource->common_public->suspend = network_KCCFLN05_action_suspend;
894 surf_network_resource->common_public->resume = network_KCCFLN05_action_resume;
895 surf_network_resource->common_public->is_suspended = network_KCCFLN05_action_is_suspended;
897 surf_network_resource->extension_public->communicate = communicate_KCCFLN05;
899 network_link_set = xbt_dict_new();
902 maxmin_system_network_KCCFLN05 = lmm_system_new();
905 static void workstation_KCCFLN05_finalize(void)
907 xbt_swag_free(surf_workstation_resource->common_public->states.ready_action_set);
908 xbt_swag_free(surf_workstation_resource->common_public->states.running_action_set);
909 xbt_swag_free(surf_workstation_resource->common_public->states.failed_action_set);
910 xbt_swag_free(surf_workstation_resource->common_public->states.done_action_set);
912 xbt_free(surf_workstation_resource->common_public);
913 xbt_free(surf_workstation_resource->common_private);
914 xbt_free(surf_workstation_resource->extension_public);
916 xbt_free(surf_workstation_resource);
917 surf_workstation_resource = NULL;
920 static void workstation_KCCFLN05_resource_init_internal(void)
922 s_surf_action_t action;
924 surf_workstation_resource = xbt_new0(s_surf_workstation_resource_t, 1);
926 surf_workstation_resource->common_private =
927 xbt_new0(s_surf_resource_private_t, 1);
928 surf_workstation_resource->common_public =
929 xbt_new0(s_surf_resource_public_t, 1);
930 surf_workstation_resource->extension_public =
931 xbt_new0(s_surf_workstation_resource_extension_public_t, 1);
933 surf_workstation_resource->common_public->states.ready_action_set =
934 xbt_swag_new(xbt_swag_offset(action, state_hookup));
935 surf_workstation_resource->common_public->states.running_action_set =
936 xbt_swag_new(xbt_swag_offset(action, state_hookup));
937 surf_workstation_resource->common_public->states.failed_action_set =
938 xbt_swag_new(xbt_swag_offset(action, state_hookup));
939 surf_workstation_resource->common_public->states.done_action_set =
940 xbt_swag_new(xbt_swag_offset(action, state_hookup));
942 surf_workstation_resource->common_public->name_service = name_service;
943 surf_workstation_resource->common_public->get_resource_name =
945 surf_workstation_resource->common_public->action_get_state =
946 surf_action_get_state;
947 surf_workstation_resource->common_public->action_free = action_free;
948 surf_workstation_resource->common_public->action_cancel = NULL;
949 surf_workstation_resource->common_public->action_recycle = NULL;
950 surf_workstation_resource->common_public->action_change_state = action_change_state;
951 surf_workstation_resource->common_public->action_set_data = surf_action_set_data;
952 surf_workstation_resource->common_public->name = "Workstation KCCFLN05";
954 surf_workstation_resource->common_private->resource_used = resource_used;
955 surf_workstation_resource->common_private->share_resources = share_resources;
956 surf_workstation_resource->common_private->update_actions_state = update_actions_state;
957 surf_workstation_resource->common_private->update_resource_state = update_resource_state;
958 surf_workstation_resource->common_private->finalize = workstation_KCCFLN05_finalize;
961 surf_workstation_resource->common_public->suspend = action_suspend;
962 surf_workstation_resource->common_public->resume = action_resume;
963 surf_workstation_resource->common_public->is_suspended = action_is_suspended;
965 surf_workstation_resource->extension_public->execute = execute_KCCFLN05;
966 /*FIXME*//* surf_workstation_resource->extension_public->sleep = action_sleep; */
967 surf_workstation_resource->extension_public->get_state = get_state;
968 surf_workstation_resource->extension_public->communicate = communicate_KCCFLN05;
971 /**************************************/
972 /*************** Generic **************/
973 /**************************************/
975 void surf_workstation_resource_init_KCCFLN05(const char *filename)
977 xbt_assert0(!surf_cpu_resource,"CPU resource type already defined");
978 cpu_KCCFLN05_resource_init_internal();
979 xbt_assert0(!surf_network_resource,"network resource type already defined");
980 network_KCCFLN05_resource_init_internal();
981 workstation_KCCFLN05_resource_init_internal();
982 parse_file(filename);
984 xbt_dynar_push(resource_list, &surf_network_resource);
985 xbt_dynar_push(resource_list, &surf_cpu_resource);
986 xbt_dynar_push(resource_list, &surf_workstation_resource);
988 if (maxmin_system) { /* To avoid using this useless system */
989 lmm_system_free(maxmin_system);
990 maxmin_system = NULL;