always-cautious/ortools-clone
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

cache expr * cst and thus cache normal scalprod

Browse Source
This commit is contained in:
lperron@google.com
2012-06-15 16:28:41 +00:00
parent 175fcd66bb
commit e008a8a488
3 changed files with 80 additions and 24 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
src/constraint_solver/constraint_solveri.h
View File

@@ -1428,13 +1428,7 @@ class ModelCache {
};
enum VarConstantExpressionType {
VAR_CONSTANT_DIFFERENCE = 0,
VAR_CONSTANT_DIVIDE,
VAR_CONSTANT_PROD,
VAR_CONSTANT_MAX,
VAR_CONSTANT_MIN,
VAR_CONSTANT_SUM,
VAR_CONSTANT_IS_EQUAL,
VAR_CONSTANT_IS_EQUAL = 0,
VAR_CONSTANT_IS_NOT_EQUAL,
VAR_CONSTANT_IS_GREATER_OR_EQUAL,
VAR_CONSTANT_IS_LESS_OR_EQUAL,
@@ -1458,6 +1452,15 @@ class ModelCache {
EXPR_EXPR_EXPRESSION_MAX,
};
enum ExprConstantExpressionType {
EXPR_CONSTANT_DIFFERENCE = 0,
EXPR_CONSTANT_DIVIDE,
EXPR_CONSTANT_PROD,
EXPR_CONSTANT_MAX,
EXPR_CONSTANT_MIN,
EXPR_CONSTANT_SUM,
EXPR_CONSTANT_EXPRESSION_MAX,
};
enum VarConstantConstantExpressionType {
VAR_CONSTANT_CONSTANT_SEMI_CONTINUOUS = 0,
VAR_CONSTANT_CONSTANT_EXPRESSION_MAX,
@@ -1565,6 +1568,19 @@ class ModelCache {
IntVar* const var2,
VarVarExpressionType type) = 0;
// Expr Constant Expressions.
virtual IntExpr* FindExprConstantExpression(
IntExpr* const expr,
int64 value,
ExprConstantExpressionType type) const = 0;
virtual void InsertExprConstantExpression(
IntExpr* const expression,
IntExpr* const var,
int64 value,
ExprConstantExpressionType type) = 0;
// Expr Expr Expressions.
virtual IntExpr* FindExprExprExpression(

42
src/constraint_solver/expressions.cc
View File

@@ -347,7 +347,6 @@ class DomainIntVar : public IntVar {
}
}
posted_.Switch(solver());
// LOG(INFO) << "Posted " << count << " watchers on " << variable_->DebugString() << (void*)variable_;
}
virtual void InitialPropagate() {
@@ -523,6 +522,8 @@ class DomainIntVar : public IntVar {
solver()->RevAlloc(new Watcher(solver(), this))));
}
IntVar* const boolvar = watcher_->GetOrMakeWatcher(value);
s->Cache()->InsertVarConstantExpression(
boolvar, this, value, ModelCache::VAR_CONSTANT_IS_EQUAL);
return boolvar;
}
}
@@ -5235,24 +5236,31 @@ IntExpr* Solver::MakeOpposite(IntExpr* const e) {
IntExpr* Solver::MakeProd(IntExpr* const e, int64 v) {
CHECK_EQ(this, e->solver());
IntExpr* result;
if (e->Bound()) {
return MakeIntConst(v * e->Min());
} else if (v == 1) {
return e;
} else if (v == -1) {
return MakeOpposite(e);
} else if (v > 0) {
result = RegisterIntExpr(RevAlloc(new TimesIntPosCstExpr(this, e, v)));
} else if (v == 0) {
result = MakeIntConst(0);
IntExpr* result = Cache()->FindExprConstantExpression(
e, v, ModelCache::EXPR_CONSTANT_PROD);
if (result != NULL) {
return result;
} else {
result = RegisterIntExpr(RevAlloc(new TimesIntNegCstExpr(this, e, v)));
if (e->Bound()) {
return MakeIntConst(v * e->Min());
} else if (v == 1) {
return e;
} else if (v == -1) {
return MakeOpposite(e);
} else if (v > 0) {
result = RegisterIntExpr(RevAlloc(new TimesIntPosCstExpr(this, e, v)));
} else if (v == 0) {
result = MakeIntConst(0);
} else {
result = RegisterIntExpr(RevAlloc(new TimesIntNegCstExpr(this, e, v)));
}
if (e->IsVar() && !FLAGS_cp_disable_expression_optimization) {
result = result->Var();
}
Cache()->InsertExprConstantExpression(
result, e, v, ModelCache::EXPR_CONSTANT_PROD);
return result;
}
if (e->IsVar() && !FLAGS_cp_disable_expression_optimization) {
result = result->Var();
}
return result;
}
IntExpr* Solver::MakeProd(IntExpr* const l, IntExpr* const r) {

32
src/constraint_solver/model_cache.cc
View File

@@ -359,6 +359,7 @@ class NonReversibleCache : public ModelCache {
typedef Cache2<Constraint, IntVar*, int64> VarConstantConstraintCache;
typedef Cache2<Constraint, IntVar*, IntVar*> VarVarConstraintCache;
typedef Cache2<IntExpr, IntVar*, int64> VarConstantIntExprCache;
typedef Cache2<IntExpr, IntExpr*, int64> ExprConstantIntExprCache;
typedef Cache2<IntExpr, IntVar*, IntVar*> VarVarIntExprCache;
typedef Cache2<IntExpr, IntExpr*, IntExpr*> ExprExprIntExprCache;
typedef Cache2<IntExpr, IntVar*, ConstIntArray*> VarConstantArrayIntExprCache;
@@ -388,6 +389,9 @@ class NonReversibleCache : public ModelCache {
for (int i = 0; i < VAR_CONSTANT_EXPRESSION_MAX; ++i) {
var_constant_expressions_.push_back(new VarConstantIntExprCache);
}
for (int i = 0; i < EXPR_CONSTANT_EXPRESSION_MAX; ++i) {
expr_constant_expressions_.push_back(new ExprConstantIntExprCache);
}
for (int i = 0; i < VAR_VAR_EXPRESSION_MAX; ++i) {
var_var_expressions_.push_back(new VarVarIntExprCache);
}
@@ -609,6 +613,33 @@ class NonReversibleCache : public ModelCache {
}
}
// Expr Constant Expressions.
virtual IntExpr* FindExprConstantExpression(
IntExpr* const expr,
int64 value,
ExprConstantExpressionType type) const {
DCHECK(expr != NULL);
DCHECK_GE(type, 0);
DCHECK_LT(type, EXPR_CONSTANT_EXPRESSION_MAX);
return expr_constant_expressions_[type]->Find(expr, value);
}
virtual void InsertExprConstantExpression(
IntExpr* const expression,
IntExpr* const expr,
int64 value,
ExprConstantExpressionType type) {
DCHECK(expression != NULL);
DCHECK(expr != NULL);
DCHECK_GE(type, 0);
DCHECK_LT(type, EXPR_CONSTANT_EXPRESSION_MAX);
if (solver()->state() != Solver::IN_SEARCH &&
expr_constant_expressions_[type]->Find(expr, value) == NULL) {
expr_constant_expressions_[type]->UnsafeInsert(expr, value, expression);
}
}
// Expr Expr Expression.
virtual IntExpr* FindExprExprExpression(
@@ -762,6 +793,7 @@ class NonReversibleCache : public ModelCache {
std::vector<VarIntExprCache*> var_expressions_;
std::vector<VarConstantIntExprCache*> var_constant_expressions_;
std::vector<VarVarIntExprCache*> var_var_expressions_;
std::vector<ExprConstantIntExprCache*> expr_constant_expressions_;
std::vector<ExprExprIntExprCache*> expr_expr_expressions_;
std::vector<VarConstantConstantIntExprCache*> var_constant_constant_expressions_;
std::vector<VarConstantArrayIntExprCache*> var_constant_array_expressions_;