lock.h

Go to the documentation of this file.

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

#ifndef __LOCK_H
#define __LOCK_H

#include "w_defines.h"

#include "sm_base.h"
#include "w_okvl.h"
#include "w_okvl_inl.h"
#include "lock_s.h"

class xct_lock_info_t;
class lock_core_m;
class lil_global_table;
struct RawXct;
struct RawLock;
class sm_options;

class lock_m : public smlevel_0 {
public:
    // initialize/takedown functions for thread-local state
    static void on_thread_init();

    static void on_thread_destroy();

    lock_m(const sm_options& options);

    ~lock_m();

    void assert_empty() const;

    void dump(ostream& o);

    void stats(
            u_long& buckets_used,
            u_long& max_bucket_len,
            u_long& min_bucket_len,
            u_long& mode_bucket_len,
            float& avg_bucket_len,
            float& var_bucket_len,
            float& std_bucket_len
              ) const;

    lil_global_table* get_lil_global_table();

    okvl_mode get_granted_mode(uint32_t hash, xct_t* xd = nullptr);

    rc_t lock(uint32_t hash, const okvl_mode& m,
              bool check, bool wait, bool acquire,
              xct_t* = nullptr,
              int timeout = timeout_t::WAIT_SPECIFIED_BY_XCT,
              RawLock** out = nullptr);

    rc_t retry_lock(RawLock** lock, bool check_only,
                    int timeout = timeout_t::WAIT_SPECIFIED_BY_XCT);

    rc_t intent_store_lock(StoreID stid, okvl_mode::element_lock_mode m);

    void unlock(RawLock* lock, lsn_t commit_lsn = lsn_t::null);

    rc_t unlock_duration(bool read_lock_only = false, lsn_t commit_lsn = lsn_t::null);

    void give_permission_to_violate(lsn_t commit_lsn = lsn_t::null);

    static void lock_stats(
            u_long& locks,
            u_long& acquires,
            u_long& cache_hits,
            u_long& unlocks,
            bool reset);

    RawXct* allocate_xct();

    void deallocate_xct(RawXct* xct);

private:
    int _convert_timeout(int timeout);

    int _convert_timeout(int timeout, xct_t* xd);

    lock_core_m* core() const {
        return _core;
    }

    lock_core_m* _core;
};

#endif // __LOCK_H