Пример #1
0
void lmm_expand(lmm_system_t sys, lmm_constraint_t cnst,
                lmm_variable_t var, double value)
{
  lmm_element_t elem = NULL;

  sys->modified = 1;

  xbt_assert(var->cnsts_number < var->cnsts_size, "Too much constraints");

  elem = &(var->cnsts[var->cnsts_number++]);

  elem->value = value;
  elem->constraint = cnst;
  elem->variable = var;

  if (var->weight)
    xbt_swag_insert_at_head(elem, &(elem->constraint->element_set));
  else
    xbt_swag_insert_at_tail(elem, &(elem->constraint->element_set));
  if(!sys->selective_update_active) {
    make_constraint_active(sys, cnst);
  } else if(elem->value>0 || var->weight >0) {
    make_constraint_active(sys, cnst);
    lmm_update_modified_set(sys, cnst);
    if (var->cnsts_number > 1)
      lmm_update_modified_set(sys, var->cnsts[0].constraint);
  }
}
Пример #2
0
void lmm_expand(lmm_system_t sys, lmm_constraint_t cnst, lmm_variable_t var, double value)
{
  lmm_element_t elem = NULL;
  double weight;
  int i,current_share;

  sys->modified = 1;

  //Check if this variable already has an active element in this constraint
  //If it does, substract it from the required slack
  current_share=0;
  if(var->concurrency_share>1){
    for( i=0; i<var->cnsts_number;i++){
      if(var->cnsts[i].constraint==cnst &&
         xbt_swag_belongs(&var->cnsts[i],&(var->cnsts[i].constraint->enabled_element_set)))
         current_share+=lmm_element_concurrency(&(var->cnsts[i]));
    }
  }

  //Check if we need to disable the variable 
  if(var->weight>0 && var->concurrency_share-current_share>lmm_concurrency_slack(cnst)) {
    weight=var->weight;
    lmm_disable_var(sys,var);
    for (i = 0; i < var->cnsts_number; i++)
      lmm_on_disabled_var(sys,var->cnsts[i].constraint);
    value=0;
    var->staged_weight=weight;
    xbt_assert(!var->weight);
  }

  xbt_assert(var->cnsts_number < var->cnsts_size, "Too much constraints");

  elem = &(var->cnsts[var->cnsts_number++]);

  elem->value = value;
  elem->constraint = cnst;
  elem->variable = var;

  if (var->weight){
    xbt_swag_insert_at_head(elem, &(elem->constraint->enabled_element_set));
    lmm_increase_concurrency(elem);
  } else
    xbt_swag_insert_at_tail(elem, &(elem->constraint->disabled_element_set));

  if(!sys->selective_update_active) {
    make_constraint_active(sys, cnst);
  } else if(elem->value>0 || var->weight >0) {
    make_constraint_active(sys, cnst);
    lmm_update_modified_set(sys, cnst);
    //TODOLATER: Why do we need this second call?
    if (var->cnsts_number > 1)
      lmm_update_modified_set(sys, var->cnsts[0].constraint);
  }

  lmm_check_concurrency(sys);
}
Пример #3
0
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);
}
Пример #4
0
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);
}
Пример #5
0
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();
}
Пример #6
0
void lmm_elem_set_value(lmm_system_t sys, lmm_constraint_t cnst,
                        lmm_variable_t var, double value)
{
  int i;

  for (i = 0; i < var->cnsts_number; i++)
    if (var->cnsts[i].constraint == cnst)
      break;

  if (i < var->cnsts_number) {
    var->cnsts[i].value = value;
    sys->modified = 1;
    lmm_update_modified_set(sys, cnst);
  } else
    DIE_IMPOSSIBLE;
}
Пример #7
0
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();
}
Пример #8
0
void lmm_expand_add(lmm_system_t sys, lmm_constraint_t cnst,
                    lmm_variable_t var, double value)
{
  int i;
  sys->modified = 1;

  for (i = 0; i < var->cnsts_number; i++)
    if (var->cnsts[i].constraint == cnst)
      break;

  if (i < var->cnsts_number) {
    if (cnst->shared)
      var->cnsts[i].value += value;
    else
      var->cnsts[i].value = MAX(var->cnsts[i].value, value);
    lmm_update_modified_set(sys, cnst);
  } else
    lmm_expand(sys, cnst, var, value);
}
Пример #9
0
void lmm_expand_add(lmm_system_t sys, lmm_constraint_t cnst, lmm_variable_t var, double value)
{
  int i,j;
  double weight;
  sys->modified = 1;

  lmm_check_concurrency(sys);

  //BEWARE: In case you have multiple elements in one constraint, this will always add value to the first element.
  for (i = 0; i < var->cnsts_number; i++)
    if (var->cnsts[i].constraint == cnst)
      break;

  if (i < var->cnsts_number) {
    if (var->weight)
      lmm_decrease_concurrency(&var->cnsts[i]);

    if (cnst->sharing_policy)
      var->cnsts[i].value += value;
    else
      var->cnsts[i].value = MAX(var->cnsts[i].value, value);

    //We need to check that increasing value of the element does not cross the concurrency limit
    if (var->weight){
      if(lmm_concurrency_slack(cnst)<lmm_element_concurrency(&var->cnsts[i])){
        weight=var->weight;
        lmm_disable_var(sys,var);
        for (j = 0; j < var->cnsts_number; j++)
          lmm_on_disabled_var(sys,var->cnsts[j].constraint);
        var->staged_weight=weight;
        xbt_assert(!var->weight);
      }
      lmm_increase_concurrency(&var->cnsts[i]);
    }
    lmm_update_modified_set(sys, cnst);
  } else
    lmm_expand(sys, cnst, var, value);

  lmm_check_concurrency(sys);
}