// allocateSingle - Allocate a single element from this pool, returning -1 if
// there is no space.
int
PoolSlab::allocateSingle() {
// If the slab is a single array, go on to the next slab. Don't allocate
// single nodes in a SingleArray slab.
if (isSingleArray) return -1;
unsigned SlabSize = getSlabSize();
// Check to see if there are empty entries at the end of the slab...
if (UsedEnd < SlabSize) {
// Mark the returned entry used
unsigned short UE = UsedEnd;
markNodeAllocated(UE);
setStartBit(UE);
// If we are allocating out the first unused field, bump its index also
if (FirstUnused == UE) {
FirstUnused++;
}
// Updated the UsedBegin field if necessary
if (UsedBegin > UE) UsedBegin = UE;
// Return the entry, increment UsedEnd field.
++UsedEnd;
assertOkay();
allocated += 1;
return UE;
}
// If not, check to see if this node has a declared "FirstUnused" value that
// is less than the number of nodes allocated...
//
if (FirstUnused < SlabSize) {
// Successfully allocate out the first unused node
unsigned Idx = FirstUnused;
markNodeAllocated(Idx);
setStartBit(Idx);
// Increment FirstUnused to point to the new first unused value...
// FIXME: this should be optimized
unsigned short FU = FirstUnused;
do {
++FU;
} while ((FU != SlabSize) && (isNodeAllocated(FU)));
FirstUnused = FU;
// Updated the UsedBegin field if necessary
if (UsedBegin > Idx) UsedBegin = Idx;
assertOkay();
allocated += 1;
return Idx;
}
assertOkay();
return -1;
}
caBitnames::caBitnames(QWidget *parent) : EFlag(parent)
{
setNumColumns(1);
thisStartBit=0;
thisEndBit = 15;
setStartBit(0);
setEndBit(15);
thisString = "";
setTrueColor(Qt::blue);
setFalseColor(Qt::gray);
numRows = 16;
thisAlignment = EFlag::left;
setFontScaleMode(ESimpleLabel::WidthAndHeight);
setEnumStrings("1;2;3;4;5;6;7;8;9;10;11;12;13;14;15;16");
setValue(0);
}
//
// Method: allocateMultiple()
//
// Description:
// Allocate multiple contiguous elements from this pool.
//
// Inputs:
// Size - The number of *nodes* to allocate from this slab.
//
// Return value:
// -1 - There is no space for an allocation of this size in the slab.
// -1 - An attempt was made to use this method on a single array slab.
// Otherwise, the index number of the first free node in the slab is returned.
//
int
PoolSlab::allocateMultiple(unsigned Size) {
// Do not allocate small arrays in SingleArray slabs
if (isSingleArray) return -1;
// For small array allocation, check to see if there are empty entries at the
// end of the slab...
if (UsedEnd+Size <= getSlabSize()) {
// Mark the returned entry used and set the start bit
unsigned UE = UsedEnd;
setStartBit(UE);
for (unsigned i = UE; i != UE+Size; ++i)
markNodeAllocated(i);
// If we are allocating out the first unused field, bump its index also
if (FirstUnused == UE)
FirstUnused += Size;
// Updated the UsedBegin field if necessary
if (UsedBegin > UE) UsedBegin = UE;
// Increment UsedEnd
UsedEnd += Size;
// Return the entry
assertOkay();
allocated += Size;
return UE;
}
//
// If not, check to see if this node has a declared "FirstUnused" value
// starting which Size nodes can be allocated
//
unsigned Idx = FirstUnused;
while (Idx+Size <= getSlabSize()) {
assert(!isNodeAllocated(Idx) && "FirstUsed is not accurate!");
// Check if there is a continuous array of Size nodes starting FirstUnused
unsigned LastUnused = Idx+1;
for (; (LastUnused != Idx+Size) && (!isNodeAllocated(LastUnused)); ++LastUnused)
/*empty*/;
// If we found an unused section of this pool which is large enough, USE IT!
if (LastUnused == Idx+Size) {
setStartBit(Idx);
// FIXME: this loop can be made more efficient!
for (unsigned i = Idx; i != Idx + Size; ++i)
markNodeAllocated(i);
// This should not be allocating on the end of the pool, so we don't need
// to bump the UsedEnd pointer.
assert(Idx != UsedEnd && "Shouldn't allocate at end of pool!");
// If we are allocating out the first unused field, bump its index also.
if (Idx == FirstUnused) {
unsigned SlabSize = getSlabSize();
unsigned i;
for (i = FirstUnused+Size; i < UsedEnd; ++i) {
if (!isNodeAllocated(i)) {
break;
}
}
FirstUnused = i;
if (isNodeAllocated(i))
FirstUnused = SlabSize;
}
// Updated the UsedBegin field if necessary
if (UsedBegin > Idx) UsedBegin = Idx;
// Return the entry
assertOkay();
allocated += Size;
return Idx;
}
// Otherwise, try later in the pool. Find the next unused entry.
Idx = LastUnused;
while (Idx+Size <= getSlabSize() && isNodeAllocated(Idx))
++Idx;
}
assertOkay();
return -1;
}
