ExternalSortRunLoader Class Reference

ExternalSortRunLoader manages the state of a run as it is being loaded and sorted in memory. More...

#include <ExternalSortRunLoader.h>

Inheritance diagram for ExternalSortRunLoader:

List of all members.

Public Member Functions
	ExternalSortRunLoader (ExternalSortInfo &info)
virtual	~ExternalSortRunLoader ()
void	startRun ()
	Prepares this loader to begin a new run.
bool	isStarted ()
	Returns: whether this loader has been started and not yet fetched
ExternalSortRC	loadRun (ExecStreamBufAccessor &bufAccessor)
	Loads data from buffer into a run.
void	sort ()
	Sorts loaded run.
uint	getLoadedTupleCount ()
	Returns: number of tuples loaded so far in current run
void	releaseResources ()
	Releases any resources acquired by this loader.
virtual ExternalSortFetchArray &	bindFetchArray ()
	Binds the fetch array which will be used implicitly by subsequent calls to fetch().
virtual ExternalSortRC	fetch (uint nTuplesRequested)
	Fetches tuples via the previously bound fetch array.
Public Attributes
bool	runningParallelTask
	Flag used only during parallel sort.
Private Member Functions
PBuffer	allocateBuffer ()
	Allocates one page buffer.
bool	allocateDataBuffer ()
	Allocates one data buffer.
bool	allocateIndexBuffer ()
	Allocates one index buffer.
PBuffer &	getPointerArrayEntry (uint iTuple)
	Dereferences a pointer array entry during quicksort.
void	quickSortSwap (uint l, uint r)
uint	quickSortPartition (uint i, uint j, PBuffer pivot)
PBuffer	quickSortFindPivot (uint l, uint r)
void	quickSort (uint l, uint r)
Private Attributes
ExternalSortInfo &	sortInfo
	Global information.
SegPageLock	bufferLock
	Cache page lock used to allocate pages of scratch memory.
uint	nMemPagesMax
	Maximum number of memory pages which can be allocated by this loader.
std::vector< PBuffer >	freeBuffers
	Array of allocated page buffers which have been recycled but not yet reused.
std::vector< PBuffer >	indexBuffers
	Array of page buffers which have been allocated as index buffers.
std::vector< PBuffer >	dataBuffers
	Array of page buffers which have been allocated as data buffers.
uint	indexToPageShift
	Precomputed bit rightshift count for converting a tuple index to a page number (0-based position within indexBuffers array).
uint	indexPageMask
	Precomputed bitmask for converting a tuple index to a 0-based position in pointer array on containing index page.
PBuffer	pDataBuffer
	Pointer to first free byte in current data buffer.
PBuffer	pDataBufferEnd
	Pointer to end of current data buffer.
PBuffer	pIndexBuffer
	Pointer to first free byte in current index buffer.
PBuffer	pIndexBufferEnd
	Pointer to end of current index buffer.
uint	nTuplesLoaded
	Number of tuples loaded so far.
uint	nTuplesFetched
	Number of tuples fetched so far.
ExternalSortFetchArray	fetchArray
	Array used to return fetch results.
TupleAccessor	tupleAccessor
TupleAccessor	tupleAccessor2
TupleProjectionAccessor	keyAccessor
TupleProjectionAccessor	keyAccessor2
TupleData	keyData
TupleData	keyData2

---

Detailed Description

ExternalSortRunLoader manages the state of a run as it is being loaded and sorted in memory.

As unsorted tuple data is loaded, it is saved in discontiguous memory pages (called data buffers). In addition, byte pointers to the loaded tuple images are recorded in separately allocated memory pages (called index buffers, and also discontiguous). When the loader's memory page quota is exhausted, the run is considered full. Before a run is stored or returned, it is sorted in memory using quicksort. The quicksort operates on the index buffers (moving pointers only, not data). Each pointer array access during the quicksort requires an indirection computation (first find the right page, and then find the tuple on that page).

Definition at line 52 of file ExternalSortRunLoader.h.

---

Constructor & Destructor Documentation

ExternalSortRunLoader::ExternalSortRunLoader

(

ExternalSortInfo &

info

)

[explicit]

Definition at line 31 of file ExternalSortRunLoader.cpp.

References SegPageLock::accessSegment(), TupleProjectionAccessor::bind(), bufferLock, ExternalSortInfo::cbPage, TupleData::compute(), TupleAccessor::compute(), indexPageMask, indexToPageShift, keyAccessor, keyAccessor2, keyData, keyData2, ExternalSortInfo::keyDesc, ExternalSortInfo::keyProj, ExternalSortInfo::memSegmentAccessor, nMemPagesMax, nTuplesFetched, nTuplesLoaded, pDataBuffer, pIndexBuffer, runningParallelTask, sortInfo, tupleAccessor, tupleAccessor2, and ExternalSortInfo::tupleDesc.

    : sortInfo(sortInfoIn)
{
    nMemPagesMax = 0;
    pDataBuffer = NULL;
    pIndexBuffer = NULL;

    nTuplesLoaded = nTuplesFetched = 0;

    runningParallelTask = false;

    bufferLock.accessSegment(sortInfo.memSegmentAccessor);

    tupleAccessor.compute(sortInfo.tupleDesc);
    tupleAccessor2.compute(sortInfo.tupleDesc);

    keyData.compute(sortInfo.keyDesc);
    keyData2 = keyData;

    keyAccessor.bind(tupleAccessor,sortInfo.keyProj);
    keyAccessor2.bind(tupleAccessor2,sortInfo.keyProj);

    // TODO:  utility methods for calculations below, and assert block
    // size is power of 2
    uint nKeysPerPage = sortInfo.cbPage / sizeof(PBuffer);
    assert(nKeysPerPage > 1);
    nKeysPerPage >>= 1;
    indexToPageShift = 1;
    indexPageMask = 1;
    while ((nKeysPerPage & indexPageMask) == 0) {
        ++indexToPageShift;
        indexPageMask <<= 1;
        ++indexPageMask;
    }
}

ExternalSortRunLoader::~ExternalSortRunLoader

(

)

[virtual]

Definition at line 67 of file ExternalSortRunLoader.cpp.

References releaseResources().

{
    releaseResources();
}

---

Member Function Documentation

PBuffer ExternalSortRunLoader::allocateBuffer

(

)

[private]

Allocates one page buffer.

Returns:

the allocated buffer, or NULL if quota has been reached

Definition at line 110 of file ExternalSortRunLoader.cpp.

References SegPageLock::allocatePage(), bufferLock, dataBuffers, freeBuffers, SegPageLock::getPage(), CachePage::getWritableData(), indexBuffers, nMemPagesMax, and SegPageLock::unlock().

Referenced by allocateDataBuffer(), and allocateIndexBuffer().

{
    PBuffer pBuffer;

    if (!freeBuffers.empty()) {
        pBuffer = freeBuffers.back();
        freeBuffers.pop_back();
        return pBuffer;
    }

    if ((indexBuffers.size() + dataBuffers.size()) >= nMemPagesMax) {
        return NULL;
    }

    bufferLock.allocatePage();
    pBuffer = bufferLock.getPage().getWritableData();

    // REVIEW jvs 12-June-2004:  we rely on the fact that the underlying
    // ScratchSegment keeps the page pinned for us; need to make this
    // official.
    bufferLock.unlock();

    return pBuffer;
}

bool ExternalSortRunLoader::allocateDataBuffer

(

)

[private]

Allocates one data buffer.

Returns:

whether the buffer was allocated successfully

Definition at line 135 of file ExternalSortRunLoader.cpp.

References allocateBuffer(), ExternalSortInfo::cbPage, dataBuffers, pDataBuffer, pDataBufferEnd, and sortInfo.

Referenced by loadRun(), and startRun().

{
    pDataBuffer = allocateBuffer();
    if (pDataBuffer) {
        dataBuffers.push_back(pDataBuffer);
        pDataBufferEnd = pDataBuffer + sortInfo.cbPage;
        return true;
    } else {
        return false;
    }
}

bool ExternalSortRunLoader::allocateIndexBuffer

(

)

[private]

Allocates one index buffer.

Returns:

whether the buffer was allocated successfully

Definition at line 147 of file ExternalSortRunLoader.cpp.

References allocateBuffer(), ExternalSortInfo::cbPage, indexBuffers, pIndexBuffer, pIndexBufferEnd, and sortInfo.

Referenced by loadRun(), and startRun().

{
    pIndexBuffer = allocateBuffer();
    if (pIndexBuffer) {
        indexBuffers.push_back(pIndexBuffer);
        pIndexBufferEnd = pIndexBuffer + sortInfo.cbPage;
        return true;
    } else {
        return false;
    }
}

PBuffer & ExternalSortRunLoader::getPointerArrayEntry

(

uint

iTuple

)

[inline, private]

Dereferences a pointer array entry during quicksort.

Parameters:

iTuple

0-based index of tuple pointer to access

Returns:

read/write reference to pointer to tuple

Definition at line 72 of file ExternalSortRunLoader.cpp.

References indexBuffers, indexPageMask, and indexToPageShift.

Referenced by fetch(), quickSortFindPivot(), quickSortPartition(), and quickSortSwap().

{
    // REVIEW jvs 12-June-2004:  This is the price we pay for not using a big
    // linear array.  Is it too expensive?
    uint iPage = iTuple >> indexToPageShift;
    uint iSubKey = iTuple & indexPageMask;
    PBuffer *pPage = reinterpret_cast<PBuffer *>(indexBuffers[iPage]);
    return pPage[iSubKey];
}

void ExternalSortRunLoader::quickSortSwap	(	uint	l,
		uint	r
	)			[inline, private]

Definition at line 260 of file ExternalSortRunLoader.cpp.

References getPointerArrayEntry().

Referenced by quickSortPartition().

{
    std::swap(getPointerArrayEntry(l),getPointerArrayEntry(r));
}

uint ExternalSortRunLoader::quickSortPartition	(	uint	i,
		uint	j,
		PBuffer	pivot
	)			[private]

Definition at line 303 of file ExternalSortRunLoader.cpp.

References ExternalSortInfo::compareKeys(), getPointerArrayEntry(), keyAccessor, keyAccessor2, keyData, keyData2, quickSortSwap(), TupleAccessor::setCurrentTupleBuf(), sortInfo, tupleAccessor, tupleAccessor2, and TupleProjectionAccessor::unmarshal().

Referenced by quickSort().

{
    l--;
    r++;

    tupleAccessor.setCurrentTupleBuf(pivot);
    keyAccessor.unmarshal(keyData);
    for (;;) {
        for (;;) {
            ++l;
            tupleAccessor2.setCurrentTupleBuf(getPointerArrayEntry(l));
            keyAccessor2.unmarshal(keyData2);
            if (sortInfo.compareKeys(keyData2,keyData) >= 0) {
                break;
            }
        }
        for (;;) {
            --r;
            tupleAccessor2.setCurrentTupleBuf(getPointerArrayEntry(r));
            keyAccessor2.unmarshal(keyData2);
            if (sortInfo.compareKeys(keyData2,keyData) <= 0) {
                break;
            }
        }
        if (l < r) {
            quickSortSwap(l, r);
        } else {
            return l;
        }
    }
}

PBuffer ExternalSortRunLoader::quickSortFindPivot	(	uint	l,
		uint	r
	)			[private]

Definition at line 268 of file ExternalSortRunLoader.cpp.

References ExternalSortInfo::compareKeys(), getPointerArrayEntry(), keyAccessor, keyAccessor2, keyData, keyData2, TupleAccessor::setCurrentTupleBuf(), sortInfo, step_factor, tupleAccessor, tupleAccessor2, and TupleProjectionAccessor::unmarshal().

Referenced by quickSort().

{
    uint i, j, cnt, step;
    PBuffer vals[step_factor];

    if (r <= l) {
        return NULL;
    }

    cnt = 0;
    step = ((r - l) / step_factor) + 1;
    for (i = l; i <= r; i += step) {
        vals[cnt] = getPointerArrayEntry(i);
        j = cnt++;
        while (j > 0) {
            tupleAccessor.setCurrentTupleBuf(vals[j]);
            tupleAccessor2.setCurrentTupleBuf(vals[j - 1]);
            keyAccessor.unmarshal(keyData);
            keyAccessor2.unmarshal(keyData2);
            if (sortInfo.compareKeys(keyData,keyData2) >= 0) {
                break;
            }
            std::swap(vals[j],vals[j - 1]);
            j--;
        }
    }
    if (step == 1) {
        for (i = 0; i < cnt; ++i) {
            getPointerArrayEntry(l + i) = vals[i];
        }
        return NULL;
    }
    return vals[(cnt >> 1)];
}

void ExternalSortRunLoader::quickSort	(	uint	l,
		uint	r
	)			[private]

Definition at line 335 of file ExternalSortRunLoader.cpp.

References quickSortFindPivot(), and quickSortPartition().

Referenced by sort().

{
    PBuffer pPivotTuple;
    uint x;

    pPivotTuple = quickSortFindPivot(l,r);
    if (pPivotTuple) {
        x = quickSortPartition(l,r,pPivotTuple);
        if (x == l) {
            // pPivotTuple was lowest value in partition and was at position l
            // - move off of it and keep going
            x++;
        }
        quickSort(l,x - 1);
        quickSort(x,r);
    }
}

void ExternalSortRunLoader::startRun

(

)

Prepares this loader to begin a new run.

Definition at line 82 of file ExternalSortRunLoader.cpp.

References allocateDataBuffer(), allocateIndexBuffer(), dataBuffers, fetchArray, freeBuffers, indexBuffers, nMemPagesMax, ExternalSortInfo::nSortMemPagesPerRun, ExternalSortFetchArray::nTuples, nTuplesFetched, nTuplesLoaded, pDataBuffer, pIndexBuffer, and sortInfo.

Referenced by ExternalSortExecStreamImpl::computeFirstResult(), and ExternalSortExecStreamImpl::computeFirstResultParallel().

{
    if (!nMemPagesMax) {
        nMemPagesMax = sortInfo.nSortMemPagesPerRun;
    }

    freeBuffers.insert(
        freeBuffers.end(),indexBuffers.begin(),indexBuffers.end());
    freeBuffers.insert(
        freeBuffers.end(),dataBuffers.begin(),dataBuffers.end());
    indexBuffers.clear();
    dataBuffers.clear();
    pDataBuffer = NULL;
    pIndexBuffer = NULL;

    if (!allocateDataBuffer()) {
        permAssert(false);
    }

    if (!allocateIndexBuffer()) {
        permAssert(false);
    }

    nTuplesLoaded = nTuplesFetched = 0;

    fetchArray.nTuples = 0;
}

bool ExternalSortRunLoader::isStarted

(

)

Returns:

whether this loader has been started and not yet fetched

Definition at line 358 of file ExternalSortRunLoader.cpp.

References nTuplesFetched, and nTuplesLoaded.

Referenced by ExternalSortExecStreamImpl::computeFirstResult(), and ExternalSortExecStreamImpl::execute().

{
    return nTuplesLoaded > nTuplesFetched;
}

ExternalSortRC ExternalSortRunLoader::loadRun

(

ExecStreamBufAccessor &

bufAccessor

)

Loads data from buffer into a run.

Parameters:

bufAccessor

buffer from which to read run

Returns:

result of load

Definition at line 173 of file ExternalSortRunLoader.cpp.

References allocateDataBuffer(), allocateIndexBuffer(), ExecStreamBufAccessor::consumeData(), ExecStreamBufAccessor::demandData(), EXTSORT_OVERFLOW, EXTSORT_SUCCESS, TupleAccessor::getBufferByteCount(), ExecStreamBufAccessor::getConsumptionAvailable(), ExecStreamBufAccessor::getConsumptionStart(), TupleAccessor::getMaxByteCount(), nTuplesLoaded, pDataBuffer, pDataBufferEnd, pIndexBuffer, pIndexBufferEnd, and tupleAccessor.

Referenced by ExternalSortExecStreamImpl::computeFirstResult().

{
    for (;;) {
        if (!bufAccessor.demandData()) {
            break;
        }
        uint cbAvailable = bufAccessor.getConsumptionAvailable();
        assert(cbAvailable);
        PConstBuffer pSrc = bufAccessor.getConsumptionStart();
        bool overflow = false;
        uint cbCopy = 0;
        while (cbCopy < cbAvailable) {
            PConstBuffer pSrcTuple = pSrc + cbCopy;
            uint cbTuple = tupleAccessor.getBufferByteCount(pSrcTuple);
            assert(cbTuple);
            assert(cbTuple <= tupleAccessor.getMaxByteCount());

            // first make sure we have room for the key pointer
            if (pIndexBuffer >= pIndexBufferEnd) {
                if (!allocateIndexBuffer()) {
                    overflow = true;
                    break;
                }
            }

            // now make sure we have enough room for the data
            if (pDataBuffer + cbCopy + cbTuple > pDataBufferEnd) {
                if (!cbCopy) {
                    // first tuple:  try to allocate a new buffer
                    if (!allocateDataBuffer()) {
                        // since cbCopy is zero, we can return right now
                        return EXTSORT_OVERFLOW;
                    }
                }
                // copy whatever we've calculated so far;
                // next time through the for loop, we'll allocate a fresh buffer
                break;
            }

            *((PBuffer *) pIndexBuffer) = pDataBuffer + cbCopy;
            pIndexBuffer += sizeof(PBuffer);
            nTuplesLoaded++;
            cbCopy += cbTuple;
        }
        if (cbCopy) {
            memcpy(pDataBuffer,pSrc,cbCopy);
            pDataBuffer += cbCopy;
            bufAccessor.consumeData(pSrc + cbCopy);
        }
        if (overflow) {
            return EXTSORT_OVERFLOW;
        }
    }

    assert(nTuplesLoaded);
    return EXTSORT_SUCCESS;
}

void ExternalSortRunLoader::sort

(

)

Sorts loaded run.

Definition at line 232 of file ExternalSortRunLoader.cpp.

References nTuplesLoaded, and quickSort().

Referenced by ExternalSortExecStreamImpl::sortRun().

{
    assert (nTuplesLoaded);

    quickSort(0,nTuplesLoaded - 1);
}

uint ExternalSortRunLoader::getLoadedTupleCount

(

)

Returns:

number of tuples loaded so far in current run

Definition at line 353 of file ExternalSortRunLoader.cpp.

References nTuplesLoaded.

Referenced by ExternalSortExecStreamImpl::sortRun().

{
    return nTuplesLoaded;
}

void ExternalSortRunLoader::releaseResources

(

)

Releases any resources acquired by this loader.

Definition at line 159 of file ExternalSortRunLoader.cpp.

References dataBuffers, freeBuffers, indexBuffers, ExternalSortInfo::memSegmentAccessor, nMemPagesMax, NULL_PAGE_ID, SegmentAccessor::pSegment, and sortInfo.

Referenced by ~ExternalSortRunLoader().

{
    freeBuffers.clear();
    indexBuffers.clear();
    dataBuffers.clear();
    nMemPagesMax = 0;

    // REVIEW jvs 12-June-2004:  see corresponding comment above in
    // allocateBuffer()

    sortInfo.memSegmentAccessor.pSegment->deallocatePageRange(
        NULL_PAGE_ID,NULL_PAGE_ID);
}

ExternalSortFetchArray & ExternalSortRunLoader::bindFetchArray

(

)

[virtual]

Binds the fetch array which will be used implicitly by subsequent calls to fetch().

Returns:

bound fetch array

Implements ExternalSortSubStream.

Definition at line 239 of file ExternalSortRunLoader.cpp.

References fetchArray.

{
    return fetchArray;
}

ExternalSortRC ExternalSortRunLoader::fetch

(

uint

nTuplesRequested

)

[virtual]

Fetches tuples via the previously bound fetch array.

Parameters:

nTuplesRequested

maximum number of tuples to be returned from fetch (actual count may be less at callee's discretion; this does not indicate end of stream)

Returns:

result of fetch (either EXTSORT_ENDOFDATA or EXTSORT_SUCCESS)

Implements ExternalSortSubStream.

Definition at line 244 of file ExternalSortRunLoader.cpp.

References EXTSORT_ENDOFDATA, EXTSORT_SUCCESS, fetchArray, getPointerArrayEntry(), indexPageMask, min(), ExternalSortFetchArray::nTuples, nTuplesFetched, nTuplesLoaded, and ExternalSortFetchArray::ppTupleBuffers.

{
    if (nTuplesFetched >= nTuplesLoaded) {
        return EXTSORT_ENDOFDATA;
    }

    fetchArray.ppTupleBuffers = (PBuffer *)
        &(getPointerArrayEntry(nTuplesFetched));
    uint pageEnd = (nTuplesFetched | indexPageMask) + 1;
    pageEnd = std::min(pageEnd,nTuplesLoaded);
    fetchArray.nTuples = std::min(nTuplesRequested,pageEnd - nTuplesFetched);
    nTuplesFetched += fetchArray.nTuples;

    return EXTSORT_SUCCESS;
}

---

Member Data Documentation

ExternalSortInfo& ExternalSortRunLoader::sortInfo [private]

Global information.

Definition at line 58 of file ExternalSortRunLoader.h.

Referenced by allocateDataBuffer(), allocateIndexBuffer(), ExternalSortRunLoader(), quickSortFindPivot(), quickSortPartition(), releaseResources(), and startRun().

SegPageLock ExternalSortRunLoader::bufferLock [private]

Cache page lock used to allocate pages of scratch memory.

Definition at line 63 of file ExternalSortRunLoader.h.

Referenced by allocateBuffer(), and ExternalSortRunLoader().

uint ExternalSortRunLoader::nMemPagesMax [private]

Maximum number of memory pages which can be allocated by this loader.

Definition at line 68 of file ExternalSortRunLoader.h.

Referenced by allocateBuffer(), ExternalSortRunLoader(), releaseResources(), and startRun().

std::vector<PBuffer> ExternalSortRunLoader::freeBuffers [private]

Array of allocated page buffers which have been recycled but not yet reused.

Definition at line 74 of file ExternalSortRunLoader.h.

Referenced by allocateBuffer(), releaseResources(), and startRun().

std::vector<PBuffer> ExternalSortRunLoader::indexBuffers [private]

Array of page buffers which have been allocated as index buffers.

These contain arrays of pointers to tuple data stored in separate data buffers. Order is significant, since an index entry is decomposed into a page and a position on that page.

Definition at line 82 of file ExternalSortRunLoader.h.

Referenced by allocateBuffer(), allocateIndexBuffer(), getPointerArrayEntry(), releaseResources(), and startRun().

std::vector<PBuffer> ExternalSortRunLoader::dataBuffers [private]

Array of page buffers which have been allocated as data buffers.

These store marshalled tuple data. Order is not significant.

Definition at line 88 of file ExternalSortRunLoader.h.

Referenced by allocateBuffer(), allocateDataBuffer(), releaseResources(), and startRun().

uint ExternalSortRunLoader::indexToPageShift [private]

Precomputed bit rightshift count for converting a tuple index to a page number (0-based position within indexBuffers array).

Definition at line 94 of file ExternalSortRunLoader.h.

Referenced by ExternalSortRunLoader(), and getPointerArrayEntry().

uint ExternalSortRunLoader::indexPageMask [private]

Precomputed bitmask for converting a tuple index to a 0-based position in pointer array on containing index page.

Definition at line 100 of file ExternalSortRunLoader.h.

Referenced by ExternalSortRunLoader(), fetch(), and getPointerArrayEntry().

PBuffer ExternalSortRunLoader::pDataBuffer [private]

Pointer to first free byte in current data buffer.

Definition at line 105 of file ExternalSortRunLoader.h.

Referenced by allocateDataBuffer(), ExternalSortRunLoader(), loadRun(), and startRun().

PBuffer ExternalSortRunLoader::pDataBufferEnd [private]

Pointer to end of current data buffer.

Definition at line 110 of file ExternalSortRunLoader.h.

Referenced by allocateDataBuffer(), and loadRun().

PBuffer ExternalSortRunLoader::pIndexBuffer [private]

Pointer to first free byte in current index buffer.

Definition at line 115 of file ExternalSortRunLoader.h.

Referenced by allocateIndexBuffer(), ExternalSortRunLoader(), loadRun(), and startRun().

PBuffer ExternalSortRunLoader::pIndexBufferEnd [private]

Pointer to end of current index buffer.

Definition at line 120 of file ExternalSortRunLoader.h.

Referenced by allocateIndexBuffer(), and loadRun().

uint ExternalSortRunLoader::nTuplesLoaded [private]

Number of tuples loaded so far.

Definition at line 125 of file ExternalSortRunLoader.h.

Referenced by ExternalSortRunLoader(), fetch(), getLoadedTupleCount(), isStarted(), loadRun(), sort(), and startRun().

uint ExternalSortRunLoader::nTuplesFetched [private]

Number of tuples fetched so far.

Definition at line 130 of file ExternalSortRunLoader.h.

Referenced by ExternalSortRunLoader(), fetch(), isStarted(), and startRun().

ExternalSortFetchArray ExternalSortRunLoader::fetchArray [private]

Array used to return fetch results.

This gets bound to successive index buffer contents during fetch.

Definition at line 136 of file ExternalSortRunLoader.h.

Referenced by bindFetchArray(), fetch(), and startRun().

TupleAccessor ExternalSortRunLoader::tupleAccessor [private]

Definition at line 139 of file ExternalSortRunLoader.h.

Referenced by ExternalSortRunLoader(), loadRun(), quickSortFindPivot(), and quickSortPartition().

TupleAccessor ExternalSortRunLoader::tupleAccessor2 [private]

Definition at line 140 of file ExternalSortRunLoader.h.

Referenced by ExternalSortRunLoader(), quickSortFindPivot(), and quickSortPartition().

TupleProjectionAccessor ExternalSortRunLoader::keyAccessor [private]

Definition at line 141 of file ExternalSortRunLoader.h.

Referenced by ExternalSortRunLoader(), quickSortFindPivot(), and quickSortPartition().

TupleProjectionAccessor ExternalSortRunLoader::keyAccessor2 [private]

Definition at line 142 of file ExternalSortRunLoader.h.

Referenced by ExternalSortRunLoader(), quickSortFindPivot(), and quickSortPartition().

TupleData ExternalSortRunLoader::keyData [private]

Definition at line 143 of file ExternalSortRunLoader.h.

Referenced by ExternalSortRunLoader(), quickSortFindPivot(), and quickSortPartition().

TupleData ExternalSortRunLoader::keyData2 [private]

Definition at line 144 of file ExternalSortRunLoader.h.

Referenced by ExternalSortRunLoader(), quickSortFindPivot(), and quickSortPartition().

bool ExternalSortRunLoader::runningParallelTask

Flag used only during parallel sort.

When set, this loader has been allocated to a particular thread. When clear, this loader is available for use by the next thread that needs one. Access to this flag is synchronized in ExternalSortStreamImpl.

Definition at line 192 of file ExternalSortRunLoader.h.

Referenced by ExternalSortRunLoader(), and ExternalSortExecStreamImpl::unreserveRunLoader().

---

The documentation for this class was generated from the following files:

• /home/pub/open/dev/fennel/sorter/ExternalSortRunLoader.h
• /home/pub/open/dev/fennel/sorter/ExternalSortRunLoader.cpp

---