constraint-programming - ワーカーが多すぎる IloCP の使用に関する問題

Question

変数の値がモジュロ演算と一致する必要があることを強制する単純な制約を作成しました。境界の一貫性とドメインの一貫性の 2 つの一貫性レベルを使用できます。この例では、境界の一貫性を使用して問題を解決すると、1 つまたは 2 つのワーカーでうまく機能しますが、3 つ以上のワーカーpropagate()では、ドメインの最大値を削除できないように見えるため、関数は無限にループします。私のコンピューターには 2 つの物理コアがあるため、物理コアよりも多くのワーカーを使用することが問題であると推測されます。Cplex Optimization Studio の最新バージョンを使用しています。コードは次のとおりです。

ファイルmain.cc:

#include <ilcp/cp.h>
#include "IloModulo.h"


int main() {
  IloEnv env;
  IloModel model(env);

  IloIntVar x(env, 1, 100000);
  model.add(IloModulo(env, x, 3, BOUNDS_CONSISTENCY));
  model.add(IloMinimize(env, x));

  IloCP solver(model);
  solver.setParameter(IloCP::Workers, 1); // Infinite loop with 3 or more workers
  solver.solve();

  return 0;
}

ファイルIloModulo.h:

#ifndef ILOMODULO_H_
#define ILOMODULO_H_


#include <ilcp/cpext.h>


#define BOUNDS_CONSISTENCY 1
#define DOMAIN_CONSISTENCY 2


class IlcModuloI : public IlcConstraintI {
private:
  IlcIntVar x_;
  IlcInt modulo_;
  IlcInt consistency_;

public:
  IlcModuloI(IloCPEngine cp,
         IlcIntVar x,
         IlcInt modulo,
         IlcInt consistency);
  ~IlcModuloI();

  virtual void propagate();
  virtual void post();
};

// The IloModulo constraint is used with the following function
IloConstraint IloModulo(IloEnv env,
            IloIntVar x,
            IloInt modulo,
            IloInt consistency);


#endif // ILOMODULO_H_

ファイルIloModulo.cc:

#include "IloModulo.h"


IlcModuloI::IlcModuloI(IloCPEngine solver,
               IlcIntVar x,
               IlcInt modulo,
               IlcInt consistency) :
  IlcConstraintI(solver),
  modulo_(modulo),
  x_(x),
  consistency_(consistency) {
  ;
}


IlcModuloI::~IlcModuloI() {
  ;
}


void IlcModuloI::propagate() {
  switch (consistency_) {
  case BOUNDS_CONSISTENCY: {
    while ((x_.getMin() % modulo_ != 0) ||
       (x_.getMax() % modulo_ != 0)) {
      if (x_.getMin() % modulo_ != 0) {
    x_.setMin(x_.getMin()+1);
    continue;
      }
      if (x_.getMax() % modulo_ != 0) {
    std::cout << "Min/max values: " << x_.getMin() << "/" << x_.getMax() << std::endl;
    std::cout << "Decreasing maximum value by 1." << std::endl;
    x_.setMax(x_.getMax()-1);
    std::cout << "Min/max values: " << x_.getMin() << "/" << x_.getMax() << std::endl;
    std::cout << "------------------------------" << std::endl;
    continue;
      }
    }
    break;
  }

  case DOMAIN_CONSISTENCY: {
    IlcInt threshold = x_.getMin();
    while (threshold <= x_.getMax()) {
      if (threshold % modulo_ != 0) {
    x_.removeValue(threshold);
      }
      if (threshold == x_.getMax()) {
    break;
      }
      threshold = x_.getNextHigher(threshold);
    }
    break;
  }
  }
}


void IlcModuloI::post() {
  switch (consistency_) {
  case BOUNDS_CONSISTENCY: {
    x_.whenRange(this);
    break;
  }

  case DOMAIN_CONSISTENCY: {
    x_.whenDomain(this);
    break;
  }
  }
}


ILOCPCONSTRAINTWRAPPER3(IloModuloWrapper, solver,
            IloIntVar, x_,
            IloInt, modulo_,
            IloInt, consistency_) {
  use(solver, x_);
  return new (solver.getHeap()) IlcModuloI(solver,
                       solver.getIntVar(x_),
                       modulo_,
                       consistency_);
}


IloConstraint IloModulo(IloEnv env,
            IloIntVar x,
            IloInt modulo,
            IloInt consistency) {
  return IloModuloWrapper(env, x, modulo, consistency);
}