lock_s.h

Go to the documentation of this file.

/*
 * (c) Copyright 2011-2013, Hewlett-Packard Development Company, LP
 */

#ifndef __LOCK_S_H
#define __LOCK_S_H

extern bool OKVL_EXPERIMENT;

extern uint32_t OKVL_INIT_STR_PREFIX_LEN;

extern uint32_t OKVL_INIT_STR_UNIQUEFIER_LEN;

#include "w_defines.h"
#include "w_key.h"
#include "w_okvl.h"
#include "basics.h"

// CS TODO: we could probably make lockid_t with size 64bits instead of 128,
// since
class lockid_t {
private:
    union {
        uint64_t l[2];
        uint32_t w[4];
    };

public:
    bool operator<(lockid_t const& p) const;

    bool operator==(const lockid_t& p) const;

    bool operator!=(const lockid_t& p) const;

    friend ostream& operator<<(ostream& o, const lockid_t& i);

public:
    uint32_t hash() const; // used by lock_cache
    void zero();

    StoreID store() const;

private:
    void set_store(StoreID s);

public:

    // construct vacuous lockid_t
    lockid_t();

    lockid_t(StoreID stid, const unsigned char* keystr, int16_t keylen);

    lockid_t(StoreID stid, const w_keystr_t& key);

    lockid_t(const lockid_t& i);

    lockid_t& operator=(const lockid_t& i);

private:
    void _init_for_str(StoreID stid, const unsigned char* keystr, int16_t keylen);

    // CS TODO replace with std::hash
    uint64_t hash64(uint32_t seed, const unsigned char* str, int16_t len);
};

inline StoreID lockid_t::store() const {
    w_assert9(sizeof(StoreID) == sizeof(w[1]));
    return w[1];
}

inline void lockid_t::set_store(StoreID _s) {
    w_assert9(sizeof(StoreID) == sizeof(w[1]));
    w[1] = (uint32_t)_s;
}

inline void lockid_t::zero() {
    l[0] = l[1] = 0;
}

inline lockid_t::lockid_t() {
    zero();
}

// use fixed seed for repeatability and easier debugging
const uint32_t LOCKID_T_HASH_SEED = 0xEE5C61DD;

// CS: copied from old w_hashing.h
inline uint64_t lockid_t::hash64(uint32_t seed, const unsigned char* str, int16_t len) {
    // simple iterative multiply-sum method on byte-by-byte (safe on every architecture)
    w_assert1(len >= 0);
    uint64_t ret = 0;
    for (int16_t i = 0; i < len; ++i) {
        ret = seed * ret + str[i];
    }
    return ret;
}

inline void
lockid_t::_init_for_str(StoreID stid, const unsigned char* keystr, int16_t keylen) {
    zero();
    set_store(stid);

    if (OKVL_EXPERIMENT) {
        // take only the prefix part (logical key)
        if (OKVL_INIT_STR_PREFIX_LEN > 0 && keylen > (int32_t)OKVL_INIT_STR_PREFIX_LEN) {
            keylen = OKVL_INIT_STR_PREFIX_LEN;
        }
    }
    l[1] = hash64(LOCKID_T_HASH_SEED, keystr, keylen);
}

inline
lockid_t::lockid_t(StoreID stid, const unsigned char* keystr, int16_t keylen) {
    _init_for_str(stid, keystr, keylen);
}

inline
lockid_t::lockid_t(StoreID stid, const w_keystr_t& key) {
    _init_for_str(stid, (const unsigned char*)key.buffer_as_keystr(), key.get_length_as_keystr());
}

inline lockid_t&
lockid_t::operator=(const lockid_t& i) {
    l[0] = i.l[0];
    l[1] = i.l[1];
    return *this;
}

inline bool
lockid_t::operator<(lockid_t const& i) const {
    if (l[0] < i.l[0]) {
        return true;
    }
    if (l[0] > i.l[0]) {
        return false;
    }
    return (l[1] < i.l[1]);
}

inline bool
lockid_t::operator==(const lockid_t& i) const {
    return (l[0] == i.l[0] && l[1] == i.l[1]);
}

inline lockid_t::lockid_t(const lockid_t& i) {
    (void)this->operator=(i);
}

inline bool
lockid_t::operator!=(const lockid_t& i) const {
    return !(l[0] == i.l[0] && l[1] == i.l[1]);
}

const uint32_t LOCKID_T_HASH_MULT = 0x35D0B891;

inline uint32_t lockid_t::hash() const {
    uint64_t h = w[0];
    h = h * LOCKID_T_HASH_MULT + w[1];
    h = h * LOCKID_T_HASH_MULT + w[2];
    h = h * LOCKID_T_HASH_MULT + w[3];
    return ((uint32_t)(h >> 32)) ^ ((uint32_t)(h & 0xFFFFFFFF));
}

#endif // __LOCK_S_H