Add pointers tree to TempSpace class

XaBbl4 · XaBbl4 · commit 59ab8d5a9bdf · 2025-01-20T15:46:07.000+03:00
Necessary for faster search of a free segment of the required size. When using temporary blobs, there are situations when a large number of free segments of a small size accumulate during one transaction.
diff --git a/src/jrd/TempSpace.cpp b/src/jrd/TempSpace.cpp
@@ -140,7 +140,7 @@ TempSpace::TempSpace(MemoryPool& p, const PathName& prefix, bool dynamic)
 		  logicalSize(0), physicalSize(0), localCacheUsage(0),
 		  head(NULL), tail(NULL), tempFiles(p),
 		  initialBuffer(p), initiallyDynamic(dynamic),
-		  freeSegments(p)
+		  freeSegments(p), freeSegmentLastPointers(p)
 {
 	if (!tempDirs)
 	{
@@ -180,6 +180,9 @@ TempSpace::~TempSpace()
 		dbb->decTempCacheUsage(localCacheUsage);
 	}
 
+	for (bool found = freeSegments.getFirst(); found; found = freeSegments.getNext())
+		delete freeSegments.current();
+
 	while (tempFiles.getCount())
 		delete tempFiles.pop();
 }
@@ -476,13 +479,17 @@ offset_t TempSpace::allocateSpace(FB_SIZE_T size)
 	Segment* best = NULL;
 
 	// Search through the available space in the not used segments list
-	for (bool found = freeSegments.getFirst(); found; found = freeSegments.getNext())
+	if (freeSegmentLastPointers.locate(locGreatEqual, size))
 	{
-		Segment* const space = &freeSegments.current();
-		// If this is smaller than our previous best, use it
-		if (space->size >= size && (!best || (space->size < best->size))) {
-			best = space;
-		}
+		SegmentLastPointer* const cur = &freeSegmentLastPointers.current();
+		const offset_t position = cur->pop();
+		if (cur->isEmpty())
+			freeSegmentLastPointers.fastRemove();
+
+		if (!freeSegments.locate(position))
+			fb_assert(false);
+
+		best = freeSegments.current();
 	}
 
 	// If we didn't find any space, allocate it at the end of the file
@@ -503,8 +510,11 @@ offset_t TempSpace::allocateSpace(FB_SIZE_T size)
 		if (!freeSegments.locate(best->position))
 			fb_assert(false);
 
+		delete freeSegments.current();
 		freeSegments.fastRemove();
 	}
+	else
+		lastPointerAdd(best);
 
 	return position;
 }
@@ -526,37 +536,48 @@ void TempSpace::releaseSpace(offset_t position, FB_SIZE_T size)
 	if (freeSegments.locate(locEqual, end))
 	{
 		// The next segment is found to be adjacent
-		Segment* const next_seg = &freeSegments.current();
+		Segment* const next_seg = freeSegments.current();
+		lastPointerRemove(next_seg);
+
 		next_seg->position -= size;
 		next_seg->size += size;
 
 		if (freeSegments.getPrev())
 		{
 			// Check the prior segment for being adjacent
-			Segment* const prior_seg = &freeSegments.current();
+			Segment* const prior_seg = freeSegments.current();
 			if (position == prior_seg->position + prior_seg->size)
 			{
+				lastPointerRemove(prior_seg);
+
 				next_seg->position -= prior_seg->size;
 				next_seg->size += prior_seg->size;
+
+				delete prior_seg;
 				freeSegments.fastRemove();
 			}
 		}
 
+		lastPointerAdd(next_seg);
 		return;
 	}
 
 	if (freeSegments.locate(locLess, position))
 	{
 		// Check the prior segment for being adjacent
-		Segment* const prior_seg = &freeSegments.current();
+		Segment* const prior_seg = freeSegments.current();
 		if (position == prior_seg->position + prior_seg->size)
 		{
+			lastPointerRemove(prior_seg);
 			prior_seg->size += size;
+			lastPointerAdd(prior_seg);
 			return;
 		}
 	}
 
-	freeSegments.add(Segment(position, size));
+	Segment* new_seg = FB_NEW_POOL(pool) Segment(position, size);
+	freeSegments.add(new_seg);
+	lastPointerAdd(new_seg);
 }
 
 //
@@ -614,7 +635,7 @@ bool TempSpace::validate(offset_t& free) const
 	FreeSegmentTree::ConstAccessor accessor(&freeSegments);
 	for (bool found = accessor.getFirst(); found; found = accessor.getNext())
 	{
-		const offset_t size = accessor.current().size;
+		const offset_t size = accessor.current()->size;
 		fb_assert(size != 0);
 		free += size;
 	}
@@ -643,7 +664,7 @@ ULONG TempSpace::allocateBatch(ULONG count, FB_SIZE_T minSize, FB_SIZE_T maxSize
 	offset_t freeMem = 0;
 
 	for (bool found = freeSegments.getFirst(); found; found = freeSegments.getNext())
-		freeMem += freeSegments.current().size;
+		freeMem += freeSegments.current()->size;
 
 	freeMem = MIN(freeMem / count, maxSize);
 	freeMem = MAX(freeMem, minSize);
@@ -653,7 +674,7 @@ ULONG TempSpace::allocateBatch(ULONG count, FB_SIZE_T minSize, FB_SIZE_T maxSize
 	bool is_positioned = freeSegments.getFirst();
 	while (segments.getCount() < count && is_positioned)
 	{
-		Segment* freeSpace = &freeSegments.current();
+		Segment* freeSpace = freeSegments.current();
 		offset_t freeSeek = freeSpace->position;
 		const offset_t freeEnd = freeSpace->position + freeSpace->size;
 
@@ -668,22 +689,25 @@ ULONG TempSpace::allocateBatch(ULONG count, FB_SIZE_T minSize, FB_SIZE_T maxSize
 			fb_assert(p == mem);
 			fb_assert(seek1 == freeSeek);
 #endif
+			lastPointerRemove(freeSpace);
+
 			if (freeSeek != freeSpace->position)
 			{
 				const offset_t skip_size = freeSeek - freeSpace->position;
-				const Segment skip_space(freeSpace->position, skip_size);
+				Segment* const skip_space = FB_NEW_POOL(pool) Segment(freeSpace->position, skip_size);
 
 				freeSpace->position += skip_size;
 				freeSpace->size -= skip_size;
 				fb_assert(freeSpace->size != 0);
 
 				if (!freeSegments.add(skip_space))
 					fb_assert(false);
+				lastPointerAdd(skip_space);
 
-				if (!freeSegments.locate(skip_space.position + skip_size))
+				if (!freeSegments.locate(freeSpace->position))
 					fb_assert(false);
 
-				freeSpace = &freeSegments.current();
+				freeSpace = freeSegments.current();
 			}
 
 			SegmentInMemory seg;
@@ -697,8 +721,11 @@ ULONG TempSpace::allocateBatch(ULONG count, FB_SIZE_T minSize, FB_SIZE_T maxSize
 
 			if (!freeSpace->size)
 			{
+				delete freeSegments.current();
 				is_positioned = freeSegments.fastRemove();
 			}
+			else
+				lastPointerAdd(freeSpace);
 		}
 		else
 		{
diff --git a/src/jrd/TempSpace.h b/src/jrd/TempSpace.h
@@ -182,19 +182,50 @@ class TempSpace : public Firebird::File
 	class Segment
 	{
 	public:
-		Segment() : position(0), size(0)
-		{}
-
 		Segment(offset_t aPosition, offset_t aSize) :
-			position(aPosition), size(aSize)
+			position(aPosition), size(aSize), prev(NULL), next(NULL)
 		{}
 
 		offset_t position;
 		offset_t size;
+		Segment* prev;
+		Segment* next;
+
+		static const offset_t& generate(const void* /*sender*/, const Segment* segment)
+		{
+			return segment->position;
+		}
+	};
+
+	class SegmentLastPointer
+	{
+	public:
+		SegmentLastPointer() : size(0), last(NULL)
+		{}
+
+		SegmentLastPointer(offset_t aSize, Segment* aSegment) :
+			size(aSize), last(aSegment)
+		{}
+
+		offset_t pop()
+		{
+			fb_assert(last);
+			offset_t last_position = last->position;
+			last = last->prev;
+			return last_position;
+		}
+
+		bool isEmpty()
+		{
+			return !last;
+		}
+
+		offset_t size;
+		Segment* last;
 
-		static const offset_t& generate(const void* /*sender*/, const Segment& segment)
+		static const offset_t& generate(const void* /*sender*/, const SegmentLastPointer& segment)
 		{
-			return segment.position;
+			return segment.size;
 		}
 	};
 
@@ -209,9 +240,55 @@ class TempSpace : public Firebird::File
 	Firebird::Array<UCHAR> initialBuffer;
 	bool initiallyDynamic;
 
-	typedef Firebird::BePlusTree<Segment, offset_t, MemoryPool, Segment> FreeSegmentTree;
+	typedef Firebird::BePlusTree<Segment*, offset_t, MemoryPool, Segment> FreeSegmentTree;
 	FreeSegmentTree freeSegments;
 
+	typedef Firebird::BePlusTree<SegmentLastPointer, offset_t, MemoryPool, SegmentLastPointer> FreeSegmentLastPointerTree;
+	FreeSegmentLastPointerTree freeSegmentLastPointers;
+
+	inline void lastPointerAdd(Segment* const segment)
+	{
+		if (freeSegmentLastPointers.locate(segment->size))
+		{
+			SegmentLastPointer* const pointer = &freeSegmentLastPointers.current();
+			segment->next = NULL;
+			segment->prev = pointer->last;
+			pointer->last->next = segment;
+			pointer->last = segment;
+		}
+		else
+		{
+			segment->prev = NULL;
+			segment->next = NULL;
+			freeSegmentLastPointers.add(SegmentLastPointer(segment->size, segment));
+		}
+	}
+
+	inline void lastPointerRemove(Segment* const segment)
+	{
+		if (segment->next == NULL)
+		{
+			if (!freeSegmentLastPointers.locate(segment->size))
+				fb_assert(false);
+
+			SegmentLastPointer* pointer = &freeSegmentLastPointers.current();
+			if (segment->prev)
+			{
+				segment->prev->next = NULL;
+				pointer->last = segment->prev;
+			}
+			else
+				freeSegmentLastPointers.fastRemove();
+		}
+		else
+		{
+			if (segment->prev)
+				segment->prev->next = segment->next;
+
+			segment->next->prev = segment->prev;
+		}
+	}
+
 	static Firebird::GlobalPtr<Firebird::Mutex> initMutex;
 	static Firebird::TempDirectoryList* tempDirs;
 	static FB_SIZE_T minBlockSize;
