/* Replace the content of elem_a with elem_b. The content of elem_b is cleared. */ static void renew_elem_entry(lmm_element_t elem_a, lmm_element_t elem_b) { elem_a->constraint = elem_b->constraint; elem_a->variable = elem_b->variable; elem_a->value = elem_b->value; /* If elem_b is in the element_set swag, register the new element to the swag. */ if (xbt_swag_remove(elem_b, &(elem_b->constraint->element_set))) { if (elem_a->variable->weight) xbt_swag_insert_at_head(elem_a, &(elem_a->constraint->element_set)); else xbt_swag_insert_at_tail(elem_a, &(elem_a->constraint->element_set)); } if (xbt_swag_remove(elem_b, &(elem_b->constraint->active_element_set))) { if (elem_a->variable->weight) xbt_swag_insert_at_head(elem_a, &(elem_a->constraint->active_element_set)); else xbt_swag_insert_at_tail(elem_a, &(elem_a->constraint->active_element_set)); } elem_b->constraint = NULL; elem_b->variable = NULL; elem_b->value = 0; }
void SIMIX_synchro_stop_waiting(smx_process_t process, smx_simcall_t simcall) { XBT_IN("(%p, %p)",process,simcall); switch (simcall->call) { case SIMCALL_MUTEX_LOCK: xbt_swag_remove(process, simcall_mutex_lock__get__mutex(simcall)->sleeping); break; case SIMCALL_COND_WAIT: xbt_swag_remove(process, simcall_cond_wait__get__cond(simcall)->sleeping); break; case SIMCALL_COND_WAIT_TIMEOUT: xbt_swag_remove(process, simcall_cond_wait_timeout__get__cond(simcall)->sleeping); break; case SIMCALL_SEM_ACQUIRE: xbt_swag_remove(process, simcall_sem_acquire__get__sem(simcall)->sleeping); break; case SIMCALL_SEM_ACQUIRE_TIMEOUT: xbt_swag_remove(process, simcall_sem_acquire_timeout__get__sem(simcall)->sleeping); break; default: THROW_IMPOSSIBLE; } XBT_OUT(); }
static XBT_INLINE void lmm_variable_disable(lmm_system_t sys, lmm_variable_t var) { int i; int n; lmm_element_t elem = NULL; XBT_IN("(sys=%p, var=%p)", sys, var); sys->modified = 1; n = 0; for (i = 0; i < var->cnsts_number; i++) { elem = &var->cnsts[i]; xbt_swag_remove(elem, &(elem->constraint->element_set)); xbt_swag_remove(elem, &(elem->constraint->active_element_set)); if (!xbt_swag_size(&(elem->constraint->element_set))) make_constraint_inactive(sys, elem->constraint); else { if (n < i) var->cnsts[n].constraint = elem->constraint; n++; } } if (n) { var->cnsts_number = n; lmm_update_modified_set(sys, var->cnsts[0].constraint); } var->cnsts_number = 0; XBT_OUT(); }
void lmm_shrink(lmm_system_t sys, lmm_constraint_t cnst, lmm_variable_t var) { lmm_element_t elem = NULL; int found = 0; int i; for (i = 0; i < var->cnsts_number; i++) { elem = &(var->cnsts[i]); if (elem->constraint == cnst) { found = 1; break; } } if (!found) { XBT_DEBUG("cnst %p is not found in var %p", cnst, var); return; } sys->modified = 1; XBT_DEBUG("remove elem(value %f, cnst %p, var %p) in var %p", elem->value, elem->constraint, elem->variable, var); /* We are going to change the constraint object and the variable object. * Propagate this change to other objects. Calling here (not after * modification) is correct? */ lmm_update_modified_set(sys, cnst); lmm_update_modified_set(sys, var->cnsts[0].constraint); // will look up element_set of this constraint, and then each var in the element_set, and each var->cnsts[i]. /* now var->cnsts[i] is not necessary any more */ xbt_swag_remove(elem, &(elem->constraint->element_set)); xbt_swag_remove(elem, &(elem->constraint->active_element_set)); elem->constraint = NULL; elem->variable = NULL; elem->value = 0; /* We do not want to have an empty element entry before the last entry. So, * plug up the hole with the last one. */ if (i < var->cnsts_number - 1) renew_elem_entry(&var->cnsts[i], &var->cnsts[var->cnsts_number - 1]); var->cnsts_number -= 1; if (xbt_swag_size(&(cnst->element_set)) == 0) make_constraint_inactive(sys, cnst); }
void lmm_shrink(lmm_system_t sys, lmm_constraint_t cnst, lmm_variable_t var) { lmm_element_t elem = NULL; int found = 0; int i; for (i = 0; i < var->cnsts_number; i++) { elem = &(var->cnsts[i]); if (elem->constraint == cnst) { found = 1; break; } } if (!found) { XBT_DEBUG("cnst %p is not found in var %p", cnst, var); return; } sys->modified = 1; XBT_DEBUG("remove elem(value %f, cnst %p, var %p) in var %p", elem->value, elem->constraint, elem->variable, var); /* We are going to change the constraint object and the variable object. * Propagate this change to other objects. Calling here before removing variable from not active elements * (inactive elements are not visited) */ lmm_update_modified_set(sys, cnst); //Useful in case var was already removed from the constraint lmm_update_modified_set(sys, var->cnsts[0].constraint); // will look up enabled_element_set of this constraint, and //then each var in the enabled_element_set, and each var->cnsts[i]. if(xbt_swag_remove(elem, &(elem->constraint->enabled_element_set))) lmm_decrease_concurrency(elem); xbt_swag_remove(elem, &(elem->constraint->active_element_set)); elem->constraint = NULL; elem->variable = NULL; elem->value = 0; var->cnsts_number -= 1; //No variable in this constraint -> make it inactive if (xbt_swag_size(&(cnst->enabled_element_set))+xbt_swag_size(&(cnst->disabled_element_set)) == 0) make_constraint_inactive(sys, cnst); else { //Check maxconcurrency to see if we can enable new variables lmm_on_disabled_var(sys,elem->constraint); } lmm_check_concurrency(sys); }
void bottleneck_solve(lmm_system_t sys) { void *_var, *_var_next, *_cnst, *_cnst_next, *_elem; lmm_variable_t var = nullptr; lmm_constraint_t cnst = nullptr; s_lmm_constraint_t s_cnst; lmm_element_t elem = nullptr; xbt_swag_t cnst_list = nullptr; xbt_swag_t var_list = nullptr; xbt_swag_t elem_list = nullptr; int i; static s_xbt_swag_t cnst_to_update; if (!(sys->modified)) return; /* Init */ xbt_swag_init(&(cnst_to_update), xbt_swag_offset(s_cnst, saturated_constraint_set_hookup)); var_list = &(sys->variable_set); XBT_DEBUG("Variable set : %d", xbt_swag_size(var_list)); xbt_swag_foreach(_var, var_list) { var = (lmm_variable_t)_var; int nb = 0; var->value = 0.0; XBT_DEBUG("Handling variable %p", var); xbt_swag_insert(var, &(sys->saturated_variable_set)); for (i = 0; i < var->cnsts_number; i++) { if (var->cnsts[i].value == 0.0) nb++; } if ((nb == var->cnsts_number) && (var->weight > 0.0)) { XBT_DEBUG("Err, finally, there is no need to take care of variable %p", var); xbt_swag_remove(var, &(sys->saturated_variable_set)); var->value = 1.0; } if (var->weight <= 0.0) { XBT_DEBUG("Err, finally, there is no need to take care of variable %p", var); xbt_swag_remove(var, &(sys->saturated_variable_set)); } }
static inline void lmm_variable_remove(lmm_system_t sys, lmm_variable_t var) { int i; int nelements; lmm_element_t elem = NULL; XBT_IN("(sys=%p, var=%p)", sys, var); sys->modified = 1; //TODOLATER Can do better than that by leaving only the variable in only one enabled_element_set, call //lmm_update_modified_set, and then remove it.. if(var->cnsts_number) lmm_update_modified_set(sys, var->cnsts[0].constraint); for (i = 0; i < var->cnsts_number; i++) { elem = &var->cnsts[i]; if(var->weight>0) lmm_decrease_concurrency(elem); xbt_swag_remove(elem, &(elem->constraint->enabled_element_set)); xbt_swag_remove(elem, &(elem->constraint->disabled_element_set)); xbt_swag_remove(elem, &(elem->constraint->active_element_set)); nelements=xbt_swag_size(&(elem->constraint->enabled_element_set)) + xbt_swag_size(&(elem->constraint->disabled_element_set)); if (!nelements) make_constraint_inactive(sys, elem->constraint); else lmm_on_disabled_var(sys,elem->constraint); } //Check if we can enable new variables going through the constraints where var was. //Do it after removing all elements, so he first disabled variables get priority over those with smaller requirement for (i = 0; i < var->cnsts_number; i++) { elem = &var->cnsts[i]; if(xbt_swag_size(&(elem->constraint->disabled_element_set))) lmm_on_disabled_var(sys,elem->constraint); } var->cnsts_number = 0; lmm_check_concurrency(sys); XBT_OUT(); }
void surf_action_cancel(surf_action_t action) { surf_model_t model = action->model_type; surf_action_state_set(action, SURF_ACTION_FAILED); if (model->model_private->update_mechanism == UM_LAZY) { xbt_swag_remove(action, model->model_private->modified_set); surf_action_lmm_heap_remove(model->model_private->action_heap,(surf_action_lmm_t)action); } return; }
int surf_action_unref(surf_action_t action) { surf_model_t model = action->model_type; action->refcount--; if (!action->refcount) { xbt_swag_remove(action, action->state_set); if (((surf_action_lmm_t) action)->variable) lmm_variable_free(model->model_private->maxmin_system, ((surf_action_lmm_t) action)->variable); if (model->model_private->update_mechanism == UM_LAZY) { /* remove from heap */ surf_action_lmm_heap_remove(model->model_private->action_heap,(surf_action_lmm_t)action); xbt_swag_remove(action, model->model_private->modified_set); } #ifdef HAVE_TRACING xbt_free(action->category); #endif surf_action_free(&action); return 1; } return 0; }
void surf_action_state_set(surf_action_t action, e_surf_action_state_t state) { surf_action_state_t action_state = &(action->model_type->states); XBT_IN("(%p,%s)", action, surf_action_state_names[state]); xbt_swag_remove(action, action->state_set); if (state == SURF_ACTION_READY) action->state_set = action_state->ready_action_set; else if (state == SURF_ACTION_RUNNING) action->state_set = action_state->running_action_set; else if (state == SURF_ACTION_FAILED) action->state_set = action_state->failed_action_set; else if (state == SURF_ACTION_DONE) action->state_set = action_state->done_action_set; else action->state_set = NULL; if (action->state_set) xbt_swag_insert(action, action->state_set); XBT_OUT(); }
obj1->name = "Obj 1"; obj2->name = "Obj 2"; xbt_test_add("Basic usage"); xbt_test_log("%p %p %ld\n", obj1, &(obj1->setB), (long) ((char *) &(obj1->setB) - (char *) obj1)); setA = xbt_swag_new(xbt_swag_offset(*obj1, setA)); setB = xbt_swag_new(xbt_swag_offset(*obj1, setB)); xbt_swag_insert(obj1, setA); xbt_swag_insert(obj1, setB); xbt_swag_insert(obj2, setA); xbt_swag_insert(obj2, setB); xbt_test_assert(xbt_swag_remove(NULL, setB) == NULL); xbt_test_assert(xbt_swag_remove(obj1, setB) == obj1); /* xbt_test_assert(xbt_swag_remove(obj2, setB) == obj2); */ xbt_test_add("Traverse set A"); xbt_swag_foreach(obj, setA) { xbt_test_log("Saw: %s", obj->name); } xbt_test_add("Traverse set B"); xbt_swag_foreach(obj, setB) { xbt_test_log("Saw: %s", obj->name); } xbt_test_add("Ensure set content and length"); xbt_test_assert(xbt_swag_belongs(obj1, setA));