src/main/Space.h

Go to the documentation of this file.

#ifndef _SPACE_H
#define _SPACE_H

#include <list>
#include <vector>
#include <sstream>
#include <pthread.h>

#include "Value.h"
#include "Cache.h"
#include "User.h"
#include "LightString.h"

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#if HAVE_TR1_UNORDERED_MAP // && GCC_VERSION >= 40300
#include <tr1/unordered_map>
#define USING_UNORDERED_MAP 1
#elif HAVE_EXT_HASH_MAP
#include <ext/hash_map>
#elif HAVE_HASH_MAP
#include <hash_map>
#elif HAVE_HASH_MAP_H
#include <hash_map.h>
#else
#error "hash_map is not available with this compiler"
#endif

struct Stats {

        unsigned long long hardQuota;

        unsigned long long softQuota;

        unsigned long long usedQuota;

        unsigned long long getsCount;

        unsigned long long setsCount;

        unsigned long long bytesWritten;

        unsigned long long bytesRead;

        unsigned long long missCount;

        unsigned long long hitCount;

        unsigned long long itemsCount;

        // unsigned long long totalItemsCount;

        //unsigned int softQuotaExpiryTime;

        unsigned int setTimeRecord;

        unsigned int getTimeRecord;

        Stats(unsigned long long hardQuota = 0, unsigned long long softQuota = 0) :
                hardQuota(hardQuota), softQuota(softQuota), usedQuota(0), getsCount(0), setsCount(0),
                                bytesWritten(0), bytesRead(0), missCount(0), hitCount(0), itemsCount(0),
                                setTimeRecord(0), getTimeRecord(0) {
        }
};

class Cache;
class User;

using namespace std;

inline size_t HASH(const LightString key) {
        // from: http://www.azillionmonkeys.com/qed/hash.html
#undef get16bits

#define get16bits(d) (*((const uint16_t *) (d)))

#if !defined (get16bits)
#define get16bits(d) ((((uint32_t)(((const uint8_t *)(d))[1])) << 8)\
                       +(uint32_t)(((const uint8_t *)(d))[0]) )
#endif

        char * data = key.memoryPointer;
        int len = key.size;

        uint32_t hash = len, tmp;
        int rem;

        if (len <= 0 || data == NULL)
                return (size_t) - 1;

        rem = len & 3;
        len >>= 2;

        /* Main loop */
        for (; len > 0; len--) {
                hash += get16bits (data);
                tmp = (get16bits (data+2) << 11) ^ hash;
                hash = (hash << 16) ^ tmp;
                data += 2 * sizeof(uint16_t);
                hash += hash >> 11;
        }

        /* Handle end cases */
        switch (rem) {
                case 3:
                        hash += get16bits (data);
                        hash ^= hash << 16;
                        hash ^= data[sizeof(uint16_t)] << 18;
                        hash += hash >> 11;
                        break;
                case 2:
                        hash += get16bits (data);
                        hash ^= hash << 11;
                        hash += hash >> 17;
                        break;
                case 1:
                        hash += *data;
                        hash ^= hash << 10;
                        hash += hash >> 1;
        }

        /* Force "avalanching" of final 127 bits */
        hash ^= hash << 3;
        hash += hash >> 5;
        hash ^= hash << 4;
        hash += hash >> 17;
        hash ^= hash << 25;
        hash += hash >> 6;

        return hash;
}

#if USING_UNORDERED_MAP
namespace std {
namespace tr1 {

template<>
struct hash<LightString> {
        inline size_t operator()(const LightString & str) const {
                return HASH(str);
        }
};

}
}

#else

namespace __gnu_cxx {
        template<> struct hash<LightString> {
                inline size_t operator()(const LightString & str) const {
                        return HASH(str);
                }
        };
}
#endif

enum SpaceResult {
        RESULT_SUCCESS, RESULT_MISS, RESULT_EXISTS, RESULT_CAS_FAIL, RESULT_ERROR, RESULT_BAD_SIZE
};

class Space {
public:
        class HashTabElement;
        class LRUListElement;

#if USING_UNORDERED_MAP

        typedef ::tr1::unordered_map<LightString, HashTabElement> SpaceHashTab;
#else

        typedef __gnu_cxx ::hash_map<LightString, HashTabElement> SpaceHashTab;
#endif /* GCC_VERSION  && HAVE_TR1_UNORDERED_MAP */

        typedef std::vector<SpaceHashTab> SpaceHashTabs;

        typedef std::list<LRUListElement> SpaceLRUList;

        typedef std::vector<SpaceLRUList> SpaceLRULists;

        typedef std::vector<pthread_rwlock_t *> Mutexes;

        typedef std::map<int, char> Indexes;

        class HashTabElement {
        public:

                Value value;

                SpaceLRUList::iterator iteratorLRUList;

                HashTabElement(const Value &value, Space::SpaceLRUList::iterator iteratorLRUList) :
                        value(value), iteratorLRUList(iteratorLRUList) {
                }
        };

        class LRUListElement {
        public:

                int hashTabIndex;

                LightString key;

                time_t expiryTime;

                LRUListElement(int hashTabIndex, const LightString& key, time_t expiryTime) :
                        hashTabIndex(hashTabIndex), key(key), expiryTime(expiryTime) {
                }
        };

public:

        Mutexes mapMutexes;

        pthread_mutex_t globalMutex;

        std::string name;

        Stats stats;

        Stats * fragmentedStats;

        static unsigned int NUMERIC_OBJECT_SIZE;

        static unsigned int INCR_MAX_STORAGE_LEN;

        static const int MUTEXES_COUNT;

        SpaceHashTabs hashTab;

        SpaceLRULists LRUList;

private:

        Cache *memcache;
        User *user;

        // to know what was locked by GC
        Indexes lockedTableIndexes;
        Indexes sharedLockedTableIndexes;

        unsigned long long current_cas_id;

public:
        Space(const std::string & name, unsigned long long softQuota, unsigned long long hardQuota,
                        Cache *memcache, User *user);

        virtual ~Space();

        Value get(const LightString &key, unsigned timeout = 0);

        bool get(const LightString &key, Value& value, unsigned timeout = 0);

        SpaceResult set(const LightString &key, const Value &value, unsigned timeout,
                        uint64_t * new_cas_id = NULL);

        SpaceResult cas(const LightString &key, const Value &value, unsigned timeout, uint64_t cas_id,
                        uint64_t * new_cas_id = NULL);

        SpaceResult add(const LightString &key, const Value &value, unsigned timeout, uint64_t cas_id =
                        0, uint64_t * new_cas_id = NULL);

        SpaceResult replace(const LightString &key, const Value &value, unsigned timeout,
                        uint64_t cas_id = 0, uint64_t * new_cas_id = NULL);

        SpaceResult append(const LightString &key, const Value &value, uint64_t * new_cas_id = NULL);

        SpaceResult prepend(const LightString &key, const Value &value, uint64_t * new_cas_id = NULL);

        SpaceResult increment(const LightString &key, uint64_t step, uint64_t * out, unsigned timeout =
                        0, bool force = 0, uint64_t initial = 0);

        SpaceResult decrement(const LightString &key, uint64_t step, uint64_t * out, unsigned timeout =
                        0, bool force = 0, uint64_t initial = 0);

        bool saveSpace(const char *fileName, unsigned minTimeout = 0);

        void cleanSpace();

        void destroySpace();

        Stats getStats();

        void clearStats();

        void setStatus(unsigned nUsedQuota, unsigned nGetsCount, unsigned nSetsCount,
                        unsigned nBytesWritten, unsigned nBytesRead, unsigned nMissCount, unsigned nHitCount,
                        unsigned long long nItemsCount);

        std::string getStatsStr() {
                std::stringstream ss;

                ss << "hardQuota=" << stats.hardQuota << "\n";
                ss << "softQuota=" << stats.softQuota << "\n";
                ss << "usedQuota=" << stats.usedQuota << "\n";
                ss << "getsCount=" << stats.getsCount << "\n";
                ss << "setsCount=" << stats.setsCount << "\n";
                ss << "bytesWritten=" << stats.bytesWritten << "\n";
                ss << "bytesRead=" << stats.bytesRead << "\n";
                ss << "missCount=" << stats.missCount << "\n";
                ss << "hitCount=" << stats.hitCount << "\n";
                return ss.str();
        }

private:

        SpaceResult doSet(const LightString &key, const Value &value, unsigned timeout,
                        int tableCookie, SpaceHashTab::iterator found, uint64_t cas_id = 0,
                        uint64_t * new_cas_id = NULL);

        SpaceResult crement(const LightString &key, uint64_t step, uint64_t * out, unsigned timeout,
                        bool force, uint64_t initial);

        SpaceResult
                        pend(const LightString &key, const Value &value, uint64_t * new_cas_id, bool append);

        static unsigned computeExpiryTime(unsigned timeout);

        inline size_t hash(const LightString & key);

        //      inline size_t hash(const SpaceLRUList::iterator & it);

        ostream & print(Space::Indexes & mymap) {

                for (Indexes::iterator it = mymap.begin(); it != mymap.end(); it++) {
                        if (it->second) {
                                cout << " " << it->first << "->" << (int) it->second << " ";
                        }
                }

                return cout;
        }
};

#endif  /* _SPACE_H */

---