SegStreamAllocation Class Reference

SegStreamAllocation is a helper for managing the allocation state of storage created by SegOutputStream when it is used as temp workspace. More...

#include <SegStreamAllocation.h>

Inheritance diagram for SegStreamAllocation:

List of all members.

Public Member Functions
	SegStreamAllocation ()
	Initialize a SegStreamAllocation in the UNALLOCATED state.
void	beginWrite (SharedSegOutputStream pSegOutputStreamInit)
	Changes state from UNALLOCATED to WRITING.
void	endWrite ()
	Changes state from WRITING to READING, or directly to UNALLOCATED if no pages were allocated while in WRITING state.
SharedSegInputStream const &	getInputStream () const
	Returns: reader (only available while in state READING)
BlockNum	getWrittenPageCount () const
	Returns: count of pages which were allocated during WRITING phase (a smaller number may remain allocated since pages are deallocated during READING)
bool	isClosed () const
	Returns: whether the object has been closed
void	close ()
	Closes this object, releasing any unallocated resources.
Static Public Member Functions
static SharedSegStreamAllocation	newSegStreamAllocation ()
	Creates a shared pointer to a new SegStreamAllocation, initially in the UNALLOCATED state.
Protected Member Functions
virtual void	closeImpl ()
	Must be implemented by derived class to release any resources.
Protected Attributes
bool	needsClose
Private Attributes
BlockNum	nPagesWritten
	In state READING, a record of number of pages allocated while in state WRITING.
SharedSegOutputStream	pSegOutputStream
	Non-singular iff in state WRITING.
SharedSegInputStream	pSegInputStream
	Non-singular iff in state READING.

---

Detailed Description

SegStreamAllocation is a helper for managing the allocation state of storage created by SegOutputStream when it is used as temp workspace.

It supports three states:

1. UNALLOCATED: no segment pages are currently allocated

2. WRITING: a SegOutputStream is being used to allocate segment pages

3. READING: a SegInputStream is being used to read and simultaneously deallocate segment pages

Calling close() at any time safely returns it to the UNALLOCATED state.

Author:

John V. Sichi

Version:

Id

//open/dev/fennel/segment/SegStreamAllocation.h#6

Definition at line 51 of file SegStreamAllocation.h.

---

Constructor & Destructor Documentation

SegStreamAllocation::SegStreamAllocation

(

)

[explicit]

Initialize a SegStreamAllocation in the UNALLOCATED state.

Use this only if you want to use the allocation by value (e.g. on the stack or as a member variable); if you want to manipulate via shared pointers, call newSegStreamAllocation() instead.

Definition at line 37 of file SegStreamAllocation.cpp.

References nPagesWritten.

Referenced by newSegStreamAllocation().

{
    nPagesWritten = 0;
}

---

Member Function Documentation

void SegStreamAllocation::closeImpl

(

)

[protected, virtual]

Must be implemented by derived class to release any resources.

Implements ClosableObject.

Definition at line 81 of file SegStreamAllocation.cpp.

References endWrite(), nPagesWritten, pSegInputStream, and pSegOutputStream.

{
    if (pSegOutputStream) {
        // state WRITING
        assert(!pSegInputStream);
        // do a fake read; this won't really read the pages, it will just
        // deallocate them
        endWrite();
    }

    if (pSegInputStream) {
        // state READING
        assert(!pSegOutputStream);
        assert(pSegInputStream->isDeallocating());
        // this will deallocate all remaining pages as a side-effect
        pSegInputStream->close();
        pSegInputStream.reset();
    } else {
        // state UNALLOCATED:  nothing to do
    }

    nPagesWritten = 0;
}

SharedSegStreamAllocation SegStreamAllocation::newSegStreamAllocation

(

)

[static]

Creates a shared pointer to a new SegStreamAllocation, initially in the UNALLOCATED state.

Use this if you want to create a shared pointer, since it will correctly set up the allocation to close on reset.

Returns:

new allocation

Definition at line 30 of file SegStreamAllocation.cpp.

References SegStreamAllocation().

Referenced by LhxPartitionWriter::open(), and ExternalSortRunAccessor::storeRun().

{
    return SharedSegStreamAllocation(
        new SegStreamAllocation(),
        ClosableObjectDestructor());
}

void SegStreamAllocation::beginWrite

(

SharedSegOutputStream

pSegOutputStreamInit

)

Changes state from UNALLOCATED to WRITING.

Parameters:

pSegOutputStreamInit

writer

Definition at line 42 of file SegStreamAllocation.cpp.

References ClosableObject::needsClose, pSegInputStream, and pSegOutputStream.

{
    // go from state UNALLOCATED
    assert(!pSegOutputStream);
    assert(!pSegInputStream);

    // to state WRITING
    needsClose = true;
    pSegOutputStream = pSegOutputStreamInit;
}

void SegStreamAllocation::endWrite

(

)

Changes state from WRITING to READING, or directly to UNALLOCATED if no pages were allocated while in WRITING state.

Note that entering the READING state does not actually access any pages yet.

Returns:

reader, or a singular pointer if UNALLOCATED

Definition at line 53 of file SegStreamAllocation.cpp.

References SegInputStream::newSegInputStream(), nPagesWritten, NULL_PAGE_ID, pSegInputStream, pSegOutputStream, and SegStream::segmentAccessor.

Referenced by closeImpl().

{
    // from state WRITING
    assert(pSegOutputStream);

    nPagesWritten = pSegOutputStream->getPageCount();

    SegmentAccessor segmentAccessor = pSegOutputStream->getSegmentAccessor();
    PageId firstPageId = pSegOutputStream->getFirstPageId();
    pSegOutputStream->close();
    pSegOutputStream.reset();
    if (firstPageId == NULL_PAGE_ID) {
        // go directly to UNALLOCATED
        return;
    }

    // go to state READING
    pSegInputStream = SegInputStream::newSegInputStream(
        segmentAccessor,
        firstPageId);
    pSegInputStream->setDeallocate(true);
}

SharedSegInputStream const & SegStreamAllocation::getInputStream

(

)

const

Returns:

reader (only available while in state READING)

Definition at line 76 of file SegStreamAllocation.cpp.

References pSegInputStream.

{
    return pSegInputStream;
}

BlockNum SegStreamAllocation::getWrittenPageCount

(

)

const

Returns:

count of pages which were allocated during WRITING phase (a smaller number may remain allocated since pages are deallocated during READING)

Definition at line 105 of file SegStreamAllocation.cpp.

References nPagesWritten, and pSegOutputStream.

{
    if (pSegOutputStream) {
        return pSegOutputStream->getPageCount();
    } else {
        return nPagesWritten;
    }
}

bool ClosableObject::isClosed

(

)

const [inline, inherited]

Returns:

whether the object has been closed

Definition at line 58 of file ClosableObject.h.

    {
        return !needsClose;
    }

void ClosableObject::close

(

)

[inherited]

Closes this object, releasing any unallocated resources.

Reimplemented in CollectExecStream, CorrelationJoinExecStream, LcsClusterAppendExecStream, and LcsClusterReplaceExecStream.

Definition at line 39 of file ClosableObject.cpp.

References ClosableObject::closeImpl(), and ClosableObject::needsClose.

Referenced by CacheImpl< PageT, VictimPolicyT >::allocatePages(), LcsRowScanBaseExecStream::closeImpl(), ExecStreamGraphImpl::closeImpl(), FlatFileBuffer::open(), ClosableObjectDestructor::operator()(), and Segment::~Segment().

{
    if (!needsClose) {
        return;
    }
    needsClose = false;
    closeImpl();
}

---

Member Data Documentation

BlockNum SegStreamAllocation::nPagesWritten [private]

In state READING, a record of number of pages allocated while in state WRITING.

Definition at line 58 of file SegStreamAllocation.h.

Referenced by closeImpl(), endWrite(), getWrittenPageCount(), and SegStreamAllocation().

SharedSegOutputStream SegStreamAllocation::pSegOutputStream [private]

Non-singular iff in state WRITING.

Definition at line 63 of file SegStreamAllocation.h.

Referenced by beginWrite(), closeImpl(), endWrite(), and getWrittenPageCount().

SharedSegInputStream SegStreamAllocation::pSegInputStream [private]

Non-singular iff in state READING.

Definition at line 68 of file SegStreamAllocation.h.

Referenced by beginWrite(), closeImpl(), endWrite(), and getInputStream().

bool ClosableObject::needsClose [protected, inherited]

Definition at line 44 of file ClosableObject.h.

Referenced by beginWrite(), ExecStreamGraphImpl::clear(), ClosableObject::ClosableObject(), ClosableObject::close(), FlatFileBuffer::open(), ExecStreamGraphImpl::open(), ExecStream::open(), and ClosableObject::~ClosableObject().

---

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

• /home/pub/open/dev/fennel/segment/SegStreamAllocation.h
• /home/pub/open/dev/fennel/segment/SegStreamAllocation.cpp

---