Method allocate

src/jrd/sort.cpp:1448–1512

ULONG Sort::allocate(ULONG n, ULONG chunkSize, bool useFreeSpace)
{
/**************************************
 *
 * Allocate memory for first n runs
 *
 **************************************/
	const ULONG rec_size = m_longs << SHIFTLONG;
	ULONG allocated = 0, count;
	run_control* run;

	// if some run's already in memory cache - use this memory
	for (run = m_runs, count = 0; count < n; run = run->run_next, count++)
	{
		run->run_buffer = NULL;

		UCHAR* const mem = m_space->inMemory(run->run_seek, run->run_size);

		if (mem)
		{
			run->run_buffer = mem;
			run->run_record = reinterpret_cast<sort_record*>(mem);
			run->run_end_buffer = run->run_buffer + run->run_size;
			run->run_seek += run->run_size; // emulate read
			allocated++;
		}

		run->run_buff_cache = (mem != NULL);
	}

	if (allocated == n || !useFreeSpace)
		return allocated;

	// try to use free blocks from memory cache of work file

	fb_assert(n > allocated);
	TempSpace::Segments segments(m_owner->getPool(), n - allocated);
	allocated += m_space->allocateBatch(n - allocated, m_max_alloc_size, chunkSize, segments);

	if (segments.getCount())
	{
		TempSpace::SegmentInMemory *seg = segments.begin(), *lastSeg = segments.end();
		for (run = m_runs, count = 0; count < n; run = run->run_next, count++)
		{
			if (!run->run_buffer)
			{
				const size_t runSize = MIN(seg->size / rec_size, run->run_records) * rec_size;
				UCHAR* mem = seg->memory;

				run->run_mem_seek = seg->position;
				run->run_mem_size = (ULONG) seg->size;
				run->run_buffer = mem;
				mem += runSize;
				run->run_record = reinterpret_cast<sort_record*>(mem);
				run->run_end_buffer = mem;

				seg++;
				if (seg == lastSeg)