// 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; }