|| || || || || ||

---

VirtualMatrixIOBufferWriter.h

Go to the documentation of this file.

#ifndef Impala_Core_Matrix_VirtualMatrixIOBufferWriter_h
#define Impala_Core_Matrix_VirtualMatrixIOBufferWriter_h

#include "Core/Matrix/VirtualMatrix.h"
#include "Util/IOBuffer.h"
#include "Core/Array/ReadRaw.h"

namespace Impala
{
namespace Core
{
namespace Matrix
{


class VirtualMatrixIOBufferWriter : public VirtualMatrix
{
public:

    VirtualMatrixIOBufferWriter(int nrRow, int nrCol, Util::IOBuffer* buffer,
                                bool ownBuffer, bool write32, bool preWrite)
    {
        Init(nrRow, nrCol, buffer, ownBuffer, write32, preWrite);
    }

    virtual
    ~VirtualMatrixIOBufferWriter()
    {
        if (mOwnBuffer)
        {
            delete mIOBuffer;
            mIOBuffer = 0;
        }
    }

    virtual int
    NrRow()
    {
        return mNrRow;
    }

    virtual int
    NrCol()
    {
        return mNrCol;
    }

private:

    virtual bool
    HasGetRowImplReal64()
    {
        return false;
    }

    virtual bool
    HasGetRowImplReal32()
    {
        return false;
    }

    virtual bool
    HasAddRowImplReal64()
    {
        // Actually, we can do both but we have a preference
        return !mWrite32;
    }

    virtual int
    AddRowImpl(int rowNr, Real64* buffer)
    {
        if (mWrite32)
            return AddRowConv<Real64,Real32>(rowNr, buffer);
        return AddRowDirect(rowNr, buffer);
    }

    virtual int
    AddRowPartImpl(int rowNr, int colNr, Real64* buffer, int bufSize)
    {
        if (mWrite32)
            return AddRowPartConv<Real64,Real32>(rowNr, colNr, buffer, bufSize);
        return AddRowPartDirect(rowNr, colNr, buffer, bufSize);
    }

    virtual bool
    HasAddRowImplReal32()
    {
        // Actually, we can do both but we have a preference
        return mWrite32;
    }

    virtual int
    AddRowImpl(int rowNr, Real32* buffer)
    {
        if (mWrite32)
            return AddRowDirect(rowNr, buffer);
        return AddRowConv<Real32,Real64>(rowNr, buffer);
    }

    virtual int
    AddRowPartImpl(int rowNr, int colNr, Real32* buffer, int bufSize)
    {
        if (mWrite32)
            return AddRowPartDirect(rowNr, colNr, buffer, bufSize);
        return AddRowPartConv<Real32,Real64>(rowNr, colNr, buffer, bufSize);
    }

    virtual int
    GetDiagonalImpl(Real64* buffer, int bufferSize)
    {
        ILOG_ERROR("[GetDiagonalImpl] Not implemented");
        return 0;
    }

    template<class SrcT, class DstT>
    int
    AddRowConv(int rowNr, SrcT* buffer)
    {
        int nr = NrCol();
        DstT* tmpBuf = new DstT[nr];
        for (int i=0 ; i<nr ; i++)
            tmpBuf[i] = static_cast<DstT>(buffer[i]);
        int res = AddRowDirect(rowNr, tmpBuf);
        delete tmpBuf;
        return res;
    }

    template<class SrcT, class DstT>
    int
    AddRowPartConv(int rowNr, int colNr, SrcT* buffer, int bufSize)
    {
        DstT* tmpBuf = new DstT[bufSize];
        for (int i=0 ; i<bufSize ; i++)
            tmpBuf[i] = static_cast<DstT>(buffer[i]);
        int res = AddRowPartDirect(rowNr, colNr, tmpBuf, bufSize);
        delete tmpBuf;
        return res;
    }

    template<class DstT>
    int
    AddRowDirect(int rowNr, DstT* buffer)
    {
        if (mPreWrite)
        {
            mIOBuffer->SetPosition(mBaseOffset + 200 + rowNr * mLineSize);
        }
        else
        {
            if (mExpectedRow != rowNr)
            {
                ILOG_ERROR("Cannot write: Unexpected row");
                return 0;
            }
            mExpectedRow++;
        }
        mIOBuffer->Write(buffer, mLineSize);
        return NrCol();
    }

    template<class DstT>
    int
    AddRowPartDirect(int rowNr, int colNr, DstT* buffer, int bufSize)
    {
        if (!mPreWrite)
        {
            ILOG_ERROR("AddRowPartDirect only works with preWrite");
            return 0;
        }

        Int64 offset = rowNr * mLineSize + colNr * mStorTypeSize;
        mIOBuffer->SetPosition(mBaseOffset + 200 + offset);
        Int64 bufWriteSize = bufSize * mStorTypeSize;
        mIOBuffer->Write(buffer, bufWriteSize);
        return bufWriteSize;
    }

    template<class DstT>
    void
    PreWriteRows()
    {
        DstT* buffer = new DstT[NrCol()];
        for (int i=0 ; i<NrCol() ; i++)
            buffer[i] = 0;
        for (int i=0 ; i<NrRow() ; i++)
            AddRowDirect(i, buffer);
        delete buffer;
    }

    void
    Init(int nrRow, int nrCol, Util::IOBuffer* buffer, bool ownBuffer,
         bool write32, bool preWrite)
    {
        mNrRow = nrRow;
        mNrCol = nrCol;
        mIOBuffer = buffer;
        mOwnBuffer = ownBuffer;
        mBaseOffset = mIOBuffer->GetPosition();
        mWrite32 = write32;
        mStorTypeSize = (write32) ? 4 : 8;
        mLineSize = mNrCol * mStorTypeSize;
        mPreWrite = preWrite;

        String typeStr = (mWrite32) ? "real32" : "real64";
        String formatStr = "version: 1, binary: 1, type: " + typeStr +
            ", elemSize: %lld, width: %lld, height: %lld, nr: %lld";
        Int64 elemSize = 1;
        Int64 nrA = 1;

        char buf[200];
        memset(buf, 0, 200);
        sprintf(buf, formatStr.c_str(), elemSize, mNrCol, mNrRow, nrA);
        buffer->Write(buf, 200);
        if (mPreWrite)
        {
            if (mWrite32)
                PreWriteRows<Real32>();
            else
                PreWriteRows<Real64>();
            mExpectedRow = -1;
        }
        else
        {
            mExpectedRow = 0;
        }
    }

    Int64           mNrRow;
    Int64           mNrCol;
    Util::IOBuffer* mIOBuffer;
    bool            mOwnBuffer;
    Int64           mBaseOffset;
    bool            mWrite32;
    Int64           mStorTypeSize;
    Int64           mLineSize;
    bool            mPreWrite;
    Int64           mExpectedRow;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(VirtualMatrixIOBufferWriter, Impala.Core.Matrix);

} // namespace Matrix
} // namespace Core
} // namespace Impala

#endif

---