Calculator.h

Go to the documentation of this file.

/*
// $Id: //open/dev/fennel/calculator/Calculator.h#3 $
// Fennel is a library of data storage and processing components.
// Copyright (C) 2005-2009 The Eigenbase Project
// Copyright (C) 2004-2009 SQLstream, Inc.
// Copyright (C) 2009-2009 LucidEra, Inc.
//
// This program is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by the Free
// Software Foundation; either version 2 of the License, or (at your option)
// any later version approved by The Eigenbase Project.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
#ifndef Fennel_Calculator_Included
#define Fennel_Calculator_Included

#include "fennel/tuple/TupleDescriptor.h"
#include "fennel/tuple/TupleData.h"
#include "fennel/tuple/TupleAccessor.h"
#include "fennel/tuple/TuplePrinter.h"

#include <stdio.h>
#include <assert.h>

#include <algorithm>
#include <vector>
#include <string>
#include <deque>

FENNEL_BEGIN_NAMESPACE

class Instruction;
class TupleData;

FENNEL_END_NAMESPACE

#include "fennel/calculator/CalcTypedefs.h"
#include "fennel/calculator/CalcMessage.h"
#include "fennel/calculator/RegisterReference.h"
#include "fennel/exec/DynamicParam.h"
#include "fennel/common/TraceSource.h"

FENNEL_BEGIN_NAMESPACE

using namespace std;


class FENNEL_CALCULATOR_EXPORT Calculator
    : virtual public TraceSource
{
public:
    explicit
    Calculator(DynamicParamManager* dynamicParamManager);

    explicit
    Calculator(
        DynamicParamManager* dynamicParamManager,
        int codeSize, int literalSize, int inputSize,
        int outputSize, int localSize, int statusSize);

    ~Calculator();

    inline DynamicParamManager* getDynamicParamManager() const {
        return mPDynamicParamManager;
    }

    //
    // Pre-Execution Configuration
    //

    void outputRegisterByReference(bool flag);

    void appendInstruction(Instruction* newInst)
    {
        assert(mIsUsingAssembler ? mIsAssembling : true);
        mCode.push_back(newInst);
    }

    void appendRegRef(RegisterReference* newRef)
    {
        assert(mIsUsingAssembler ? mIsAssembling : true);
        assert(newRef->setIndex() < RegisterReference::ELastSet);

        // do not allow more RegisterReferences after bind()
        assert(!mRegisterSetBinding[RegisterReference::ELiteral]);
        assert(!mRegisterSetBinding[RegisterReference::EInput]);
        assert(!mRegisterSetBinding[RegisterReference::EOutput]);
        assert(!mRegisterSetBinding[RegisterReference::ELocal]);
        assert(!mRegisterSetBinding[RegisterReference::EStatus]);

        mRegisterRef[newRef->setIndex()].push_back(newRef);
        newRef->setCalc(this);
    }

    void assemble(const char *program);

    void bind(
        RegisterReference::ERegisterSet regset,
        TupleData* data,
        const TupleDescriptor& desc);

    TupleDescriptor getOutputRegisterDescriptor() const;

    TupleDescriptor getInputRegisterDescriptor() const;

    TupleDescriptor getStatusRegisterDescriptor() const;


    TupleData const * const getStatusRegister() const;

    void zeroStatusRegister();



    void bind(
        TupleData* input,
        TupleData* output,
        bool takeOwnership = false,
        const TupleData* outputWrite = 0);

    void continueOnException(bool c);

    //
    // Execution
    //

    void exec();

    //
    // Post Execution Information
    //

    string warnings();

    deque<CalcMessage> mWarnings;

protected:
    // Note the exact syntax to declare all versions of templated
    // class as friends
    template <typename TMPLT> friend class RegisterRef;
    friend class RegisterReference;
    friend class CalcAssembler;

    vector<Instruction *> mCode;

    RegisterSetBinding* mRegisterSetBinding[RegisterReference::ELastSet];

    vector<RegisterReference *> mRegisterRef[RegisterReference::ELastSet];

    vector<RegisterReference *> mRegisterReset;

    TupleDescriptor* mRegisterSetDescriptor[RegisterReference::ELastSet];

    const bool mIsUsingAssembler;
    bool mIsAssembling;
    bool mOutputRegisterByReference;
    bool mContinueOnException;

    vector<FixedBuffer*> mBuffers;

    DynamicParamManager* mPDynamicParamManager;

private:
    void init(
        int codeSize,
        int literalSize,
        int inputSize,
        int outputSize,
        int localSize,
        int statusSize);

    void unbind(
        RegisterReference::ERegisterSet regset,
        bool unbindDescriptor = true);
};

FENNEL_END_NAMESPACE

#endif

// End Calculator.h

---