DistRedundantShare.h

Go to the documentation of this file.

/* 
 * File:   DistRedundantShare.h
 * Author: fermat
 *
 * Created on 20. Januar 2010, 17:39
 */

#ifndef _DISTREDUNDANTSHARE_H
#define _DISTREDUNDANTSHARE_H

#include"RSDisk.h"
#include"Distributor.h"
#include "RSCache.h"
#include<iostream>
#include<fstream>
#include<map>
#include<set>
#include<tr1/unordered_map>
#include<sys/time.h>

#ifndef USE_P_CACHE
//#define USE_P_CACHE
#endif

#ifndef USE_R_CACHE
//#define USE_R_CACHE
#endif

#ifndef USE_R2_CACHE
//#define USE_R2_CACHE
#endif

namespace VDRIVE {

    class DistRedundantShare : public Distributor {
    public:

        DistRedundantShare(xercesc::DOMElement* data);

        DistRedundantShare(int argc, char** argv);

        DistRedundantShare(const DistRedundantShare& orig);

        virtual ~DistRedundantShare();

        virtual std::list<Disk*>* placeExtent(int64_t virtualVolumeId, int64_t position) ;

        virtual void setConfiguration(std::list<Disk*>* disks, int64_t extentsize, int32_t copies);

        virtual void setDisks(std::list<Disk*>* disks);

        virtual xercesc::DOMElement* toXML(xercesc::DOMDocument* doc) const;

        static std::string getXMLRootType() {
            return std::string("RedundantShare");
        }

        virtual std::list<Disk*>* getDisks() const;

        virtual int64_t getExtentsize() const {
            return extentsize;
        }

        virtual int32_t getCopies() const {
            return copies;
        }

        RSDisk** getRSDisks() {
            return disks;
        }

        int32_t getNumDisks() {
            return numDisks;
        }

    private:

        int32_t copies;

        int64_t extentsize;

        int64_t capacity;

        bool revertIDOrder;

        RSDisk** disks;

        int32_t numDisks;

        std::ofstream debugfile;

        uint64_t** hashValues;

        uint64_t* errorValues;

        int64_t* errorDisks;

        void initValueCaches();

#ifdef USE_P_CACHE

        //std::tr1::unordered_map<int32_t,std::tr1::unordered_map<int32_t,std::tr1::unordered_map<int32_t,mpq_class*>*>*>* p_cache;
        std::map<int32_t, std::map<int32_t, std::map<int32_t, mpq_class*>*>*>* p_cache;

        mpq_class* getP(int32_t a, int32_t b, int32_t l);

        std::pair<const int32_t, mpq_class*>* getBestP(int32_t a, int32_t b, int32_t l);

        void setP(int32_t a, int32_t b, int32_t l, mpq_class* val);

        void clearP();
#endif

#ifdef USE_R_CACHE

        RSCache *r_cache;

        void initR() {
            r_cache = RSCache::createInstance((int32_t) 4);
        }

        mpq_class* getR(int32_t o, int32_t m, int32_t j, int32_t i) {
            int32_t* query = new int32_t[4];
            query[0] = o;
            query[1] = m;
            query[2] = j;
            query[3] = i;
            mpq_class* result = r_cache->getValue(query);
            delete[] query;
            return result;
        }

        void setR(int32_t o, int32_t m, int32_t j, int32_t i, mpq_class& val) {
            int32_t* query = new int32_t[4];
            query[0] = o;
            query[1] = m;
            query[2] = j;
            query[3] = i;
            r_cache->setValue(query, val);
            delete[] query;
        }

        void clearR() {
            delete r_cache;
        }
#endif

#ifdef USE_R2_CACHE

        RSCache *r2_cache;

        void initR2() {
            r2_cache = RSCache::createInstance((int32_t) 4);
        }

        mpq_class* getR2(int32_t o, int32_t m, int32_t j, int32_t i) {
            int32_t* query = new int32_t[4];
            query[0] = o;
            query[1] = m;
            query[2] = j;
            query[3] = i;
            mpq_class* result = r2_cache->getValue(query);
            delete[] query;
            return result;
        }

        void setR2(int32_t o, int32_t m, int32_t j, int32_t i, mpq_class& val) {
            int32_t* query = new int32_t[4];
            query[0] = o;
            query[1] = m;
            query[2] = j;
            query[3] = i;
            r2_cache->setValue(query, val);
            delete[] query;
        }

        void clearR2() {
            delete r2_cache;
        }
#endif

        int32_t placeCopy(int64_t position, int32_t copy, int32_t firstDisk) const;

        uint64_t alignDisks(std::set<RSDisk*, bool (*) (RSDisk*, RSDisk*)>* disks, int32_t copies);

        mpq_class P(int32_t a, int32_t b, int32_t l);

        mpq_class r_inner(int32_t o, int32_t m, int32_t j, int32_t i);

        mpq_class r(int32_t o, int32_t m, int32_t j, int32_t i);

        mpq_class r2_inner(int32_t o, int32_t m, int32_t j, int32_t i);

        mpq_class r2(int32_t o, int32_t m, int32_t j, int32_t i);

        mpq_class ki(int32_t i, int32_t l);

        mpq_class cStar(int32_t i, int32_t l);

        void printConfiguration();

        void clear();

        uint64_t getTimeMS() {
            struct timeval before;
            gettimeofday(&before, 0);
            return (before.tv_sec * 1000 + before.tv_usec / 1000);
        }
    };

    bool rsDiskCompare(RSDisk* ld, RSDisk* rd);

    bool rsDiskCompareRevertID(RSDisk* ld, RSDisk* rd);
}
#endif  /* _DISTREDUNDANTSHARE_H */