ExecStreamGenerator.h

Go to the documentation of this file.

/*
// $Id: //open/dev/fennel/test/ExecStreamGenerator.h#26 $
// Fennel is a library of data storage and processing components.
// Copyright (C) 2005-2009 The Eigenbase Project
// Copyright (C) 2005-2009 SQLstream, Inc.
// Copyright (C) 2005-2009 LucidEra, Inc.
// Portions Copyright (C) 2004-2009 John V. Sichi
//
// 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_ExecStreamGenerator_Included
#define Fennel_ExecStreamGenerator_Included

#include "fennel/exec/MockProducerExecStream.h"
#include "fennel/exec/DynamicParam.h"
#include <boost/shared_ptr.hpp>
#include <algorithm>
#include <numeric>

FENNEL_BEGIN_NAMESPACE

using boost::shared_ptr;
using std::vector;

class RampExecStreamGenerator : public MockProducerExecStreamGenerator
{
protected:
    int offset;
    int factor;
public:
    RampExecStreamGenerator(int offsetInit, int factorInit) {
        offset = offsetInit;
        factor = factorInit;
    }

    RampExecStreamGenerator(int offsetInit) {
        offset = offsetInit;
        factor = 1;
    }

    RampExecStreamGenerator() {
        offset = 0;
        factor = 1;
    }

    virtual int64_t generateValue(uint iRow, uint iCol)
    {
        return iRow * factor + offset;
    }
};

class PermutationGenerator : public MockProducerExecStreamGenerator
{
    std::vector<int64_t> values;

public:
    explicit PermutationGenerator(uint nRows)
    {
        values.resize(nRows);
        std::iota(values.begin(), values.end(), 0);
        std::random_shuffle(values.begin(), values.end());
    }

    virtual int64_t generateValue(uint iRow, uint iCol)
    {
        // iCol ignored
        return values[iRow];
    }
};

class StairCaseExecStreamGenerator : public MockProducerExecStreamGenerator
{
    int s;
    int h;
    int w;
public:
    StairCaseExecStreamGenerator(int height, uint width, int start = 0) :
        s(start),
        h(height),
        w(width)
    {
        // empty
    }

    virtual int64_t generateValue(uint iRow, uint iCol)
    {
        return s + h * (iRow / w);
    }
};

class DynamicParamExecStreamGenerator : public MockProducerExecStreamGenerator
{
    DynamicParamId dynamicParamId;
    SharedDynamicParamManager paramManager;

public:
    DynamicParamExecStreamGenerator(
        DynamicParamId dynamicParamId_,
        SharedDynamicParamManager paramManager_)
        : dynamicParamId(dynamicParamId_),
          paramManager(paramManager_)
    {
        // empty
    }

    virtual int64_t generateValue(uint iRow, uint iCol)
    {
        int64_t value = *reinterpret_cast<int64_t const *>(
            paramManager->getParam(dynamicParamId).getDatum().pData);
        return value;
    }
};

class RandomColumnGenerator : public ColumnGenerator<int64_t>
{
    std::subtractive_rng rng;
    int max;

public:
    RandomColumnGenerator(int max) : rng(42), max(max)
        {}

    int64_t next()
    {
        return rng(max);
    }
};

template <class T = int64_t>
class PoissonColumnGenerator : public ColumnGenerator<T>
{
    T currentValue;
    vector<T> nextValues;
    int ordinalInBatch;
    T batchUpper;
    std::subtractive_rng rng;
    double meanDistance;

public:
    explicit PoissonColumnGenerator(
        T startValue,
        double meanDistance,
        int batchSize,
        uint seed) : rng(seed)
    {
        assert(batchSize > 0);
        assert(meanDistance > 0);
        assert(meanDistance * batchSize >= 1);
        this->batchUpper = startValue;
        nextValues.resize(batchSize);
        this->ordinalInBatch = batchSize;
        this->meanDistance = meanDistance;
    }

    virtual ~PoissonColumnGenerator()
        {}

    T next()
    {
        if (ordinalInBatch >= nextValues.size()) {
            generateBatch();
        }
        return nextValues[ordinalInBatch++];
    }

private:
    void generateBatch() {
        // The next batch will contain nextValues.size() values with a mean
        // inter-value distance of meanDistance, hence its values will range
        // from batchLower to batchLower + nextValues.size() * meanDistance.
        T batchLower = this->batchUpper;
        int batchRange = (int) (meanDistance * nextValues.size());
        T batchUpper = batchLower + batchRange;
        assert(batchUpper > batchLower);
        for (int i = 0; i < nextValues.size(); i++) {
            nextValues[i] = batchLower + static_cast<T>(rng(batchRange));
        }
        std::sort(nextValues.begin(), nextValues.end());
        this->batchUpper = batchUpper;
        this->ordinalInBatch = 0;
    }
};


class CompositeExecStreamGenerator : public MockProducerExecStreamGenerator
{
    vector<boost::shared_ptr<ColumnGenerator<int64_t> > > generators;
    uint currentRow;
    uint currentCol;

public:
    explicit CompositeExecStreamGenerator(
        vector<shared_ptr<ColumnGenerator<int64_t> > > const &generatorsInit)
        : generators(generatorsInit)
    {
        currentRow = uint(-1);
        currentCol = columnCount() - 1;
    }

    virtual int64_t generateValue(uint iRow, uint iCol)
    {
        // Check that access is sequential.
        if (iCol == 0) {
            assert(iRow == currentRow + 1);
            assert(currentCol == columnCount() - 1);
        } else {
            assert(iRow == currentRow);
            assert(iCol == currentCol + 1);
        }
        currentRow = iRow;
        currentCol = iCol;

        return generators[iCol]->next();
    }

private:
    uint columnCount()
    {
        return generators.size();
    }
};

class RampDuplicateExecStreamGenerator : public MockProducerExecStreamGenerator
{

public:
    virtual int64_t generateValue(uint iRow, uint iCol)
    {
        return iRow / 2;
    }
};


class ConstExecStreamGenerator : public MockProducerExecStreamGenerator
{
    uint constVal;

public:
    ConstExecStreamGenerator (uint constValInit)
    {
        constVal = constValInit;
    }

    virtual int64_t generateValue(uint iRow, uint iCol)
    {
        return constVal;
    }
};

class SeqColumnGenerator : public ColumnGenerator<int64_t>
{
    int offset;
    int curr;

public:
    explicit SeqColumnGenerator()
    {
        offset = 1;
        curr = -1;
    }
    explicit SeqColumnGenerator(int startInit)
    {
        offset = 1;
        curr = startInit - 1;
    }

    explicit SeqColumnGenerator(int startInit, int offsetInit)
    {
        offset = offsetInit;
        curr = startInit - offset;
    }

    int64_t next()
    {
        curr += offset;
        return curr;
    }
};


class ConstColumnGenerator : public ColumnGenerator<int64_t>
{
    int64_t constvalue;

public:
    explicit ConstColumnGenerator(int constInit) {
        constvalue = constInit;
    }

    int64_t next()
    {
        return constvalue;
    }
};

class DupColumnGenerator : public ColumnGenerator<int64_t>
{
    int numDups;
    int64_t curValue;

public:
    explicit DupColumnGenerator(int numDupsInit, int startValue = 0) {
        assert(numDupsInit > 0);
        numDups = numDupsInit;
        curValue = startValue * numDups;
    }

    int64_t next()
    {
        return (curValue++ / numDups);
    }
};

class DupRepeatingSeqColumnGenerator : public ColumnGenerator<int64_t>
{
    int numDups;
    int numSequence;
    int64_t curValue;

public:
    explicit DupRepeatingSeqColumnGenerator(
        int numSequenceInit,
        int numDupsInit)
    {
        assert(numSequenceInit > 0);
        assert(numDupsInit > 0);
        numSequence = numSequenceInit;
        numDups = numDupsInit;
        curValue = 0;
    }

    int64_t next()
    {
        return (curValue++ % (numDups * numSequence)) / numDups;
    }
};

class RepeatingSeqColumnGenerator : public ColumnGenerator<int64_t>
{
    int nSequence;
    int64_t curValue;

public:
    explicit RepeatingSeqColumnGenerator(int nSequenceInit) {
        assert(nSequenceInit > 0);
        nSequence = nSequenceInit;
        curValue = 0;
    }

    int64_t next()
    {
        return curValue++ % nSequence;
    }
};

class MixedDupColumnGenerator : public ColumnGenerator<int64_t>
{
    int numDups;
    int64_t curValue;
    int width;
    int nextValue;
    int initialValue;

public:
    explicit MixedDupColumnGenerator(
        int numDupsInit,
        int startValue = 0,
        int wid = 1)
    {
        assert(numDupsInit > 0);
        numDups = numDupsInit;
        curValue = 0;
        width = wid;
        initialValue = nextValue = startValue;
    }

    int64_t next()
    {
        int res;

        if ((((nextValue - initialValue) / width) % 2)) {
            res = nextValue + curValue++ / numDups;
            if (curValue == numDups) {
                curValue = 0;
                nextValue++;
            }
        } else {
            res = nextValue++;
        }

        return res;
    }
};

class StairCaseColumnGenerator : public ColumnGenerator<int64_t>
{
    int s;
    int h;
    int w;
    uint iRow;

public:
    StairCaseColumnGenerator(int height, uint width, int start = 0) :
        s(start),
        h(height),
        w(width),
        iRow(0)
    {
        // empty
    }

    int64_t next()
    {
        return s + h * (iRow++ / w);
    }
};

FENNEL_END_NAMESPACE

#endif

// End ExecStreamGenerator.h

---