Hi,
I think that the patches for scheduling.cc and taskintervals.cc are safe
enough to include in 1.3.2, too. They just change the type of some
intermediate-result variables from 'int' to 'long long' (reason for this
is that the ints overflow in some cases, causing the propagators to fail
when they shouldn't).
Cheers,
Filip
Index: platform/emulator/libfd/taskintervals.cc
===================================================================
RCS file: /services/mozart/CVS/mozart/platform/emulator/libfd/taskintervals.cc,v
retrieving revision 1.30
diff -u -r1.30 taskintervals.cc
--- platform/emulator/libfd/taskintervals.cc 4 Feb 2002 20:23:09 -0000
1.30
+++ platform/emulator/libfd/taskintervals.cc 15 Apr 2006 10:10:48 -0000
@@ -556,14 +556,15 @@
//-----------------------------------------------------------------------------
struct Interval {
- int left, right, use;
+ int left, right;
+ long long use;
};
class Order_StartDurUseTerms_By_CompareDursUse {
public:
Bool operator()(const StartDurUseTerms& a, const StartDurUseTerms& b) {
- return a.dur * a.use > b.dur * b.use;
+ return ((long long)a.dur) * a.use > ((long long)b.dur) * b.use;
}
};
@@ -687,7 +688,7 @@
int &ts = reg_sz;
int * dur = reg_offset;
int * use = reg_use;
- int capacity = reg_capacity;
+ long long capacity = reg_capacity;
// if we have no tasks the prop returns trivially true
if (ts == 0) return PROCEED;
@@ -722,7 +723,7 @@
}
int set0Size;
- int compSet0Size;
+ int compSet0Size;
int outSideSize;
int mysup = OZ_getFDSup();
@@ -733,7 +734,8 @@
struct TISet {
- int low, up, dur, size, min, max, empty, ect, lst, overlap;
+ int low, up, dur, min, max, empty, ect, lst;
+ long long size, overlap;
// extension for tasks inside task intervals
};
@@ -772,11 +774,11 @@
cset->min = MinMax[right].min;
int cdur = 0;
- int csize = 0;
+ long long csize = 0;
int empty = 1;
int clst = 0;
int cect = OZ_getFDSup();
- int overlap=0;
+ long long overlap=0;
if ( (cset->low <= MinMax[right].min)
&& (MinMax[left].max + dur[left] <= cset->up)
)
@@ -790,7 +792,7 @@
&& (dueL <= cset->up) ) {
empty = 0;
cdur += durL;
- csize += use[l]*durL;
+ csize += use[l]*((long long)durL);
clst = intMax(clst, dueL-durL);
cect = intMin(cect, releaseL+durL);
@@ -802,7 +804,7 @@
}
else {
// add the overlapping amount of tasks
- int overlapTmp = intMin(intMax(0,releaseL+durL-cset->low),
+ long long overlapTmp = intMin(intMax(0,releaseL+durL-cset->low),
intMin(intMax(0,cset->up-dueL+durL),
intMin(durL,cset->up-cset->low)));
overlap += overlapTmp*use[l];
@@ -842,13 +844,13 @@
int useI = use[i];
int releaseI = MinMax[i].min;
int dueI = maxI + durI;
- int sizeAll, tsizeTI, treleaseTI, tdueTI;
+ long long sizeAll, tsizeTI, treleaseTI, tdueTI;
int contained = 0;
if ( (releaseI >= releaseTI) && (dueI <= dueTI) ) {
// I is in TI
contained = 1;
sizeAll = sizeTI;
- tsizeTI = sizeTI - durI*useI;
+ tsizeTI = sizeTI - ((long long)durI)*useI;
if (i==left) {
treleaseTI = cset->min;
tdueTI = dueTI;
@@ -869,14 +871,14 @@
treleaseTI = releaseTI;
tdueTI = dueTI;
tsizeTI = sizeTI;
- sizeAll = durI*useI + sizeTI;
+ sizeAll = ((long long)durI)*useI + sizeTI;
}
int overlapI = intMin(intMax(0,releaseI+durI-treleaseTI),
intMin(intMax(0,tdueTI-dueI+durI),
intMin(durI,tdueTI-treleaseTI)))*use[i];
- int OS = sizeAll;
- int OT = tsizeTI;
+ long long OS = sizeAll;
+ long long OT = tsizeTI;
// if task i is contained, this does not work!
@@ -888,7 +890,7 @@
if ( ((tdueTI - treleaseTI) * capacity < sizeAll) &&
((dueI - treleaseTI) * capacity < sizeAll) ) {
- int delta = tsizeTI - (tdueTI - treleaseTI) * (capacity - useI);
+ long long delta = tsizeTI - (tdueTI - treleaseTI) * (capacity -
useI);
if (delta > 0) {
// l must be first
int val = tdueTI - (int) ceil((double) delta / (double) useI);
@@ -914,7 +916,7 @@
int delta = tsizeTI - (tdueTI - treleaseTI) * (capacity - useI);
if (delta > 0) {
// l must be last
- int val = treleaseTI + (int) ceil((double) delta / (double) useI);
+ long long val = treleaseTI + (int) ceil((double) delta / (double)
useI);
if (releaseI < val) {
tiFlag = 1;
FailOnEmpty(*x[i] >= val);
@@ -984,11 +986,11 @@
//////////
int min_left = mysup;
int max_right = 0;
- int sum = 0;
+ long long sum = 0;
for (i=0; i<ts; i++) {
int iMin = MinMax[i].min;
int iDue = MinMax[i].max + dur[i];
- sum = sum + use[i] * dur[i];
+ sum = sum + use[i] * ((long long)dur[i]);
if (iMin < min_left) min_left = iMin;
if (iDue > max_right) max_right = iDue;
}
@@ -1087,7 +1089,7 @@
int dur_i = dur[i];
for (j=0; j<exclusion_nb; j++) {
Interval Exclusion = ExclusionIntervals[j];
- int span = Exclusion.right - Exclusion.left;
+ long long span = Exclusion.right - Exclusion.left;
if (Exclusion.use + span * use_i > span * capacity) {
int left = Exclusion.left;
int right = Exclusion.right;
Index: platform/emulator/libfd/scheduling.cc
===================================================================
RCS file: /services/mozart/CVS/mozart/platform/emulator/libfd/scheduling.cc,v
retrieving revision 1.42.10.1
diff -u -r1.42.10.1 scheduling.cc
--- platform/emulator/libfd/scheduling.cc 30 Jan 2005 10:42:35 -0000
1.42.10.1
+++ platform/emulator/libfd/scheduling.cc 15 Apr 2006 10:10:44 -0000
@@ -148,13 +148,14 @@
//
struct Interval {
- int left, right, use;
+ int left, right;
+ long long use;
};
// for cpIterateCap
struct StartDurUseTerms {
OZ_Term start;
int dur;
- int use;
+ long long use;
};
//
@@ -1009,7 +1010,8 @@
struct Set2 {
- int dSi, sUp, sLow, extSize, overlap;
+ long long dSi, overlap;
+ int sUp, sLow, extSize;
int * ext;
};
@@ -1030,7 +1032,7 @@
int &ts = reg_sz;
int * dur = reg_offset;
int * use = reg_use;
- int capacity = reg_capacity;
+ long long capacity = reg_capacity;
// if we have no tasks the prop returns trivially true
if (ts == 0) return PROCEED;
@@ -1143,16 +1145,16 @@
kUp = MinMax[upTask].max + dur[upTask];
kDown = MinMax[upTask].min;
- int use0 = 0;
+ long long use0 = 0;
set0Size = 0;
compSet0Size = 0;
outSideSize = 0;
- int overlap=0;
+ long long overlap=0;
// compute set S0
int l;
for (l=0; l<ts; l++) {
- int dl = dur[l];
+ long long dl = dur[l];
int xlMin = MinMax[l].min;
int xlMaxDL = MinMax[l].max + dl;
if (( kDown <= xlMin) && ( xlMaxDL <= kUp)) {
@@ -1161,7 +1163,7 @@
}
else {
// overlaps for failure reasoning only
- int overlapTmp = intMin(intMax(0,xlMin+dl-kDown),
+ long long overlapTmp = intMin(intMax(0,xlMin+dl-kDown),
intMin(intMax(0,kUp-xlMaxDL+dl),
intMin(dl,kUp-kDown)));
overlap += overlapTmp*use[l];
@@ -1213,7 +1215,7 @@
if (MinMax[realL].max+dur[realL] <= kUp) {
struct Set2 *bset = &Sets[setSize];
setSize++;
- int dSi = bset->dSi + dur[realL]*use[realL];
+ long long dSi = bset->dSi + ((long long)dur[realL])*use[realL];
int minL = MinMax[realL].min;
if ( (kUp - minL)*capacity < dSi) {
goto failure;
@@ -1238,10 +1240,10 @@
struct Set2 *s = &Sets[setCount];
int minL = MinMax[l].min;
int maxL = MinMax[l].max;
- int durL = dur[l];
+ long long durL = dur[l];
int useL = use[l];
- int sizeAll = s->dSi + durL*useL;
+ long long sizeAll = s->dSi + durL*useL;
if (maxL+durL > s->sUp) {
if ( (s->sUp - s->sLow)*capacity >= sizeAll) {
@@ -1262,7 +1264,7 @@
lCount++;
}
else {
- int rest = s->dSi - (s->sUp - s->sLow)*(capacity - useL);
+ long long rest = s->dSi - (s->sUp - s->sLow)*(capacity - useL);
if (rest > 0) {
// l must be last
int val = s->sLow + (int) ceil((double) rest / (double) useL);
@@ -1309,18 +1311,18 @@
kUp = MinMax[downTask].max + dur[downTask];
kDown = MinMax[downTask].min;
- int use0 = 0;
+ long long use0 = 0;
set0Size = 0;
compSet0Size = 0;
outSideSize = 0;
- int overlap=0;
+ long long overlap=0;
//////////
// compute set S0
//////////
int l;
for (l=0; l<ts; l++) {
- int dl = dur[l];
+ long long dl = dur[l];
int xlMin = MinMax[l].min;
int xlMaxDL = MinMax[l].max + dl;
if (( kDown <= xlMin) && ( xlMaxDL <= kUp)) {
@@ -1328,7 +1330,7 @@
set0[set0Size++] = l;
}
else {
- int overlapTmp = intMin(intMax(0,xlMin+dl-kDown),
+ long long overlapTmp = intMin(intMax(0,xlMin+dl-kDown),
intMin(intMax(0,kUp-xlMaxDL+dl),
intMin(dl,kUp-kDown)));
overlap += overlapTmp*use[l];
@@ -1379,10 +1381,10 @@
if (MinMax[realL].min >= kDown) {
int setSizeBefore = setSize;
struct Set2 *bset = &Sets[setSizeBefore];
- int durL = dur[realL];
+ long long durL = dur[realL];
setSize++;
- int dSi = bset->dSi + durL*use[realL];
- int maxL = MinMax[realL].max+durL;
+ long long dSi = bset->dSi + durL*use[realL];
+ long long maxL = MinMax[realL].max+durL;
if ( (maxL - kDown)*capacity < dSi)
{
goto failure;
@@ -1408,9 +1410,9 @@
struct Set2 *s = &Sets[setCount];
int minL = MinMax[l].min;
int maxL = MinMax[l].max;
- int durL = dur[l];
+ long long durL = dur[l];
int useL = use[l];
- int sizeAll = s->dSi + durL*useL;
+ long long sizeAll = s->dSi + durL*useL;
if (minL < s->sLow) {
@@ -1432,7 +1434,7 @@
lCount++;
}
else {
- int rest = s->dSi - (s->sUp - s->sLow)*(capacity - useL);
+ long long rest = s->dSi - (s->sUp - s->sLow)*(capacity - useL);
if (rest > 0) {
int val = s->sUp - (int) ceil( (double) rest / (double) useL);
// l must be first
@@ -1542,11 +1544,11 @@
//////////
int min_left = mysup;
int max_right = 0;
- int sum = 0;
+ long long sum = 0;
for (i=0; i<ts; i++) {
int iMin = MinMax[i].min;
int iDue = MinMax[i].max + dur[i];
- sum = sum + use[i] * dur[i];
+ sum = sum + use[i] * ((long long)dur[i]);
if (iMin < min_left) min_left = iMin;
if (iDue > max_right) max_right = iDue;
}
@@ -1594,8 +1596,8 @@
while ((right_pt < double_nb) && (IntervalBounds[right_pt] == left_val))
right_pt++;
if (right_pt == double_nb) break;
- int right_val = IntervalBounds[right_pt];
- int cum = 0;
+ long long right_val = IntervalBounds[right_pt];
+ long long cum = 0;
for (i=low_counter; i<interval_nb; i++) {
@@ -1630,10 +1632,10 @@
int lst = MinMax[i].max;
int ect = MinMax[i].min + dur[i];
int use_i = use[i];
- int dur_i = dur[i];
+ long long dur_i = dur[i];
for (j=0; j<exclusion_nb; j++) {
Interval Exclusion = ExclusionIntervals[j];
- int span = Exclusion.right - Exclusion.left;
+ long long span = Exclusion.right - Exclusion.left;
if (Exclusion.use + span * use_i > span * capacity) {
int left = Exclusion.left;
int right = Exclusion.right;
@@ -1810,7 +1812,7 @@
int &ts = reg_sz;
int * dur = reg_offset;
int * use = reg_use;
- int capacity = reg_capacity;
+ long long capacity = reg_capacity;
// if we have no tasks the prop returns trivially true
if (ts == 0) return PROCEED;
@@ -1895,7 +1897,7 @@
if (right_pt == double_nb) break;
int right_val = IntervalBounds[right_pt];
// cum is the amount of possible usage
- int cum = 0;
+ long long cum = 0;
for (i=low_counter; i<interval_nb; i++) {
int leftInt = Intervals[i].left;
int rightInt = Intervals[i].right;
@@ -1923,7 +1925,7 @@
int dur_i = dur[i];
for (j=0; j<inclusion_nb; j++) {
Interval Inclusion = InclusionIntervals[j];
- int span = Inclusion.right - Inclusion.left;
+ long long span = Inclusion.right - Inclusion.left;
if (Inclusion.use - span * use_i < span * capacity) {
int left = Inclusion.left;
int right = Inclusion.right;
_________________________________________________________________________________
mozart-hackers mailing list
[email protected]
http://www.mozart-oz.org/mailman/listinfo/mozart-hackers
