clizSave.h

Go to the documentation of this file.

// clizSave.h   -   ClusterLizard header file - Save

// Copyright (C) 2013, 2014 Simeon Knieling, M.Sc.
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
//

//Save Class

#pragma once
#ifndef _INCLUDE_CLIZSAVE
#define _INCLUDE_CLIZSAVE

#include "clizFunctions.h"

namespace cliz
{
    extern int inputComplete;
    extern int numAccumulated;
    extern int numDetected;

    extern Mutex numAccumulatedMutex;
    extern Mutex numDetectedMutex;

    struct ChunkPtrStruct
    {
        void            **chunk;
        unsigned int    *cols;
        unsigned int    *rows;
        unsigned int    num;
        MemoryManager *memMan;

        ChunkPtrStruct()
        {
            num = 1;
            chunk = (void**)gMemMan.allocate(sizeof(void*)*num);
            cols = (unsigned int*)gMemMan.allocate(sizeof(unsigned int)*num);
            rows = (unsigned int*)gMemMan.allocate(sizeof(unsigned int)*num);
        };
        ChunkPtrStruct(unsigned int iNum)
        {
            num = iNum;
            chunk = (void**)gMemMan.allocate(sizeof(void*)*num);
            cols = (unsigned int*)gMemMan.allocate(sizeof(unsigned int)*num);
            rows = (unsigned int*)gMemMan.allocate(sizeof(unsigned int)*num);
        };
        ~ChunkPtrStruct()
        {
            gMemMan.free(chunk);
            gMemMan.free(cols);
            gMemMan.free(rows);
        };
        void setNum(unsigned int iNum)
        {
            num = iNum;
            gMemMan.free(chunk);
            gMemMan.free(cols);
            gMemMan.free(rows);
            chunk = (void**)gMemMan.allocate(sizeof(void*)*num);
            cols = (unsigned int*)gMemMan.allocate(sizeof(unsigned int)*num);
            rows = (unsigned int*)gMemMan.allocate(sizeof(unsigned int)*num);
            //chunk = (void**)realloc(chunk, sizeof(void*)*num);
            //cols = (unsigned int*)realloc(cols, sizeof(unsigned int)*num);
            //rows = (unsigned int*)realloc(rows, sizeof(unsigned int)*num);
        };
        ChunkPtrStruct&  operator= (const ChunkPtrStruct &CPS2)
        {
            if (num != CPS2.num)
            {
                num = CPS2.num;
                gMemMan.free(chunk);
                gMemMan.free(cols);
                gMemMan.free(rows);
                chunk = (void**)gMemMan.allocate(sizeof(void*)*num);
                cols = (unsigned int*)gMemMan.allocate(sizeof(unsigned int)*num);
                rows = (unsigned int*)gMemMan.allocate(sizeof(unsigned int)*num);
                //chunk = (void**)realloc(chunk, sizeof(void*)*num);
                //cols = (unsigned int*)realloc(cols, sizeof(unsigned int)*num);
                //rows = (unsigned int*)realloc(rows, sizeof(unsigned int)*num);
            }
            memcpy(chunk, CPS2.chunk, sizeof(void*)*num);
            memcpy(cols, CPS2.cols, sizeof(unsigned int)*num);
            memcpy(rows, CPS2.rows, sizeof(unsigned int)*num);
            return *this;
        };
        ChunkPtrStruct(const ChunkPtrStruct &CPS2)
        {
            num = CPS2.num;
            chunk = (void**)gMemMan.allocate(sizeof(void*)*num);
            cols = (unsigned int*)gMemMan.allocate(sizeof(unsigned int)*num);
            rows = (unsigned int*)gMemMan.allocate(sizeof(unsigned int)*num);
            memcpy(chunk, CPS2.chunk, sizeof(void*)*num);
            memcpy(cols, CPS2.cols, sizeof(unsigned int)*num);
            memcpy(rows, CPS2.rows, sizeof(unsigned int)*num);
        };
    };

    struct IndicesStruct
    {
        unsigned int *indices;
        unsigned int num;
        IndicesStruct()
        {
            num = 1;
            indices = (unsigned int*)gMemMan.allocate(sizeof(unsigned int)*num);
            indices[0] = 0;
        }
        IndicesStruct(unsigned int iNum)
        {
            num = iNum;
            indices = (unsigned int*)gMemMan.allocate(sizeof(unsigned int)*num);
            for (unsigned int i = 0; i < num; i++)
            {
                indices[i] = i;
            }
        }
        IndicesStruct(unsigned int iNum, unsigned int *iIndices)
        {
            num = iNum;
            indices = (unsigned int*)gMemMan.allocate(sizeof(unsigned int)*num);
            memcpy(indices, iIndices, sizeof(unsigned int)*num);
        }
        IndicesStruct&  operator= (const IndicesStruct &IS2)
        {
            if (num != IS2.num)
            {
                num = IS2.num;
                gMemMan.free(indices);
                indices = (unsigned int*)gMemMan.allocate(sizeof(unsigned int)*num);
                //indices = (unsigned int*)realloc(indices, sizeof(unsigned int)*num);
            }
            memcpy(indices, IS2.indices, sizeof(unsigned int)*num);
            return *this;
        }
        IndicesStruct(const IndicesStruct &IS2)
        {
            num = IS2.num;
            indices = (unsigned int*)gMemMan.allocate(sizeof(unsigned int)*num);
            memcpy(indices, IS2.indices, sizeof(unsigned int)*num);
        }
        ~IndicesStruct()
        {
            gMemMan.free(indices);
        };
    };

    class Save
    {
    private:
        std::vector<ChunkPtrStruct*>        stack;              //Should probably use a std::queue with std::deque
        Mutex                               stackMutex;
        ConVar                              stackConVar;
    public:
        Save()
        {
            stack.reserve(10);
        };
        void pushFront(ChunkPtrStruct *chunk)
        {
            Lock lockStack(stackMutex);
            if (stack.size() < 1)
            {
                stack.push_back(chunk);
            }
            else
            {
                stack.insert(stack.begin(), chunk);
            }
            lockStack.unlock();
            stackConVar.notify_one();
        };
        void popBack(ChunkPtrStruct &chunk)
        {
            Lock lockStack(stackMutex);
            while (stack.size() < 1)
            {
                this->stackConVar.wait(lockStack);
            }
            chunk = (*stack[stack.size() - 1]);
            delete stack[stack.size() - 1];
            stack.erase(stack.end() - 1);
        };
        //Don't block if Save is empty. Pop out everything inside
        void diarrhea(ChunkPtrStruct *&chunk, unsigned int &n)
        {
            Lock lockStack(stackMutex);
            n = stack.size();
            if (n > 0)
            {
                chunk = new ChunkPtrStruct[n];
                for (int i = 0; i < (signed) n; i++)
                {
                    chunk[i] = (*stack[stack.size() - 1]);
                    delete stack[stack.size() - 1];
                    stack.erase(stack.end() - 1);
                }
            }
        };
    };
}

#endif