lock_x.h

Go to the documentation of this file.

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

#ifndef __LOCK_X_H
#define __LOCK_X_H

#include "w_defines.h"

class xct_lock_info_t; // forward
class lock_queue_entry_t;
class lock_queue_t;
class okvl_mode;
class lockid_t;

class xct_lock_entry_t {
public:
    xct_lock_entry_t() : prev(nullptr),
                         next(nullptr),
                         private_hashmap_prev(nullptr),
                         private_hashmap_next(nullptr),
                         queue(nullptr),
                         entry(nullptr) {}

    // doubly linked list
    xct_lock_entry_t* prev;

    xct_lock_entry_t* next;

    // another doubly linked list for XctLockHashMap
    xct_lock_entry_t* private_hashmap_prev;

    xct_lock_entry_t* private_hashmap_next;

    // Corresponding object in lock queue.
    lock_queue_t* queue;

    lock_queue_entry_t* entry;
};

const int XCT_LOCK_HASHMAP_SIZE = 1023;

class XctLockHashMap {
public:
    XctLockHashMap();

    ~XctLockHashMap();

    const okvl_mode& get_granted_mode(uint32_t lock_id) const;

    void reset();

    void push_front(xct_lock_entry_t* link);

    void remove(xct_lock_entry_t* link);

private:

    xct_lock_entry_t* _buckets[XCT_LOCK_HASHMAP_SIZE];

    static uint32_t _bucket_id(uint32_t lock_id) {
        return lock_id % XCT_LOCK_HASHMAP_SIZE;
    }
};

class xct_lock_info_t : private smlevel_0 {

public:
    xct_lock_info_t();

    ~xct_lock_info_t();

    xct_lock_info_t* reset_for_reuse();

    friend ostream& operator<<(ostream& o, const xct_lock_info_t& x);

    ostream& dump_locks(ostream& out) const;

    tid_t tid() const {
        return _tid;
    }

    void set_tid(const tid_t& t) {
        _tid = t;
    }

    // atomic_thread_map_t const &get_wait_map() const { return _wait_map; }
    // void              clear_wait_map() {
    //                         //_wait_map.lock_for_write();
    //                         _wait_map.clear();
    //                         //_wait_map.unlock_writer();
    //                     }
    // void              refresh_wait_map(atomic_thread_map_t const &new_map) {
    //     _wait_map.copy(new_map);
    // }
    // void              init_wait_map(smthread_t *thr) {
    //     //_wait_map.lock_for_write();
    //     _wait_map.copy(thr->get_fingerprint_map());
    //     //_wait_map.unlock_writer();
    //     DBGOUT5 (<< "initialized wait map!" << _wait_map);
    // }

    xct_lock_entry_t* link_to_new_request(lock_queue_t* queue, lock_queue_entry_t* entry);

    void remove_request(xct_lock_entry_t* entry);

    XctLockHashMap& get_private_hashmap() {
        return _hashmap;
    }

public:
    /*
     * List of locks acquired by this xct.
     */
    xct_lock_entry_t* _head;

    xct_lock_entry_t* _tail;

    XctLockHashMap _hashmap;

    srwlock_t _shared_latch;

    bool _permission_to_violate;

    lsn_t _commit_lsn;

private:
    // tid of the most recent transaction using this lock_info; monotonically
    // increasing.
    tid_t _tid;

    atomic_thread_map_t _wait_map; // for dreadlocks DLD
};

#endif // __LOCK_X_H /*</std-footer>*/