berkeley db中 dirty read的实现

dirty reader怎样 不被writor block住?

如数据库支持dirty read, 则 所有打开的dbhandle都配置 DB_READ_UNCOMMITTED;

在线程拿到 write锁并做完处理后(比如splite one page), 降为 was_write锁. WWRITE锁和dirty reader不会冲突;

对dirty read锁的请求会被优先处理;

dirty read锁在 读取完成后马上释放; why? 因为txn保留读锁是为了repeatable read.

若cursor 为read_uncommitted, 处理对读锁的请求时, lock_mode会改为 DB_LOCK_READ_UNCOMMITTED (db_meta.c, db_lget);

txn abort的时候 把 was_write锁 重新 升级为 write锁. 因为abort->undo时需要写page. (txn.c, txn_abort())

代码阅读:

db.h

typedef enum {
    DB_LOCK_NG=,            /* Not granted. */
    DB_LOCK_READ=,            /* Shared/read. */
    DB_LOCK_WRITE=,        /* Exclusive/write. */
    DB_LOCK_WAIT=,            /* Wait for event */ // 用于queue am
    DB_LOCK_IWRITE=,        /* Intent exclusive/write. */ // Intent锁用于hierarchy锁
    DB_LOCK_IREAD=,        /* Intent to share/read. */
    DB_LOCK_IWR=,            /* Intent to read and write. */
    DB_LOCK_READ_UNCOMMITTED=,    /* Degree 1 isolation. */
    DB_LOCK_WWRITE=        /* Was Written. */
} db_lockmode_t;

lock/lock_region.c:

#define    DB_LOCK_RIW_N    9
static const u_int8_t db_riw_conflicts[] = {
/*         N   R   W   WT  IW  IR  RIW DR  WW */
/*   N */  ,  ,  ,  ,  ,  ,  ,  ,  ,
/*   R */  ,  ,  ,  ,  ,  ,  ,  ,  ,
/*   W */  ,  ,  ,  ,  ,  ,  ,  ,  ,
/*  WT */  ,  ,  ,  ,  ,  ,  ,  ,  ,
/*  IW */  ,  ,  ,  ,  ,  ,  ,  ,  ,
/*  IR */  ,  ,  ,  ,  ,  ,  ,  ,  ,
/* RIW */  ,  ,  ,  ,  ,  ,  ,  ,  ,
/*  DR */  ,  ,  ,  ,  ,  ,  ,  ,  ,   // dirty read 和was_write不冲突
/*  WW */  ,  ,  ,  ,  ,  ,  ,  ,
};

lock.c,  __lock_get_internal():　dirty read锁优先处理

    lp = SH_TAILQ_FIRST(&sh_obj->holders, __db_lock);
    sh_off = R_OFFSET(&lt->reginfo, sh_locker);
　　// 遍历holder列表
    for (; lp != NULL; lp = SH_TAILQ_NEXT(lp, links, __db_lock)) {
        if (sh_off == lp->holder) { // 已经hold 锁了
            if (lp->mode == lock_mode && lp->status == DB_LSTAT_HELD) {
                lp->refcount++;
                lock->off = R_OFFSET(&lt->reginfo, lp);
                lock->gen = lp->gen;
                lock->mode = lp->mode;
                goto done;
            } else {
                ihold = ;
            }
        } else if (__lock_same_family(lt,
            R_ADDR(&lt->reginfo, lp->holder), sh_locker))
            ihold = ;
        else if (CONFLICTS(lt, region, lp->mode, lock_mode))
            break;
        else if (lp->mode == DB_LOCK_READ || lp->mode == DB_LOCK_WWRITE) {
            grant_dirty = ; // holder列表只有读锁; 或者有一个ww锁
            holder = lp->holder;
        }
    }

    if (lp != NULL) { // 有冲突的holder
        if (ihold || LF_ISSET(DB_LOCK_UPGRADE) || lock_mode == DB_LOCK_READ_UNCOMMITTED)
            action = HEAD; // dirty read请求 优先, 放入waiter队列头
        else
            action = TAIL;
    } else {
        if (LF_ISSET(DB_LOCK_UPGRADE))
            action = UPGRADE;
        else if (ihold)
            action = GRANT;
        else {
　　　　　　  // 无冲突的holder; 遍历waiter列表
            SH_TAILQ_FOREACH(lp, &sh_obj->waiters, links, __db_lock)
                if (lp->holder != sh_off && CONFLICTS(lt, region, lp->mode, lock_mode))
                    break;

            if (lp == NULL) // 无冲突的waiter
                action = GRANT;
            else if (grant_dirty && lock_mode == DB_LOCK_READ_UNCOMMITTED) {
                lp = SH_TAILQ_FIRST(&sh_obj->waiters, __db_lock);
                if (lp->mode == DB_LOCK_WRITE && lp->holder == holder)
                    action = SECOND; // waiter表头 为一个upgrade请求. 当前DR放入第二个
                else
                    action = GRANT; // 批准 DR锁请求.
            } else if (lock_mode == DB_LOCK_READ_UNCOMMITTED)
　　　　　　　　　　// 这里是DR请求, 但是!grant_dirty (没有read/ww holder). 这里有无冲突的holder;
　　　　　　　　　　// 有冲突的waiter. ??????
                action = SECOND;
            else
                action = TAIL;
        }
    }

db_meta.c, - write锁 downgrade wwrite锁:

__db_lget()
    dbc->lock.pgno = pgno;
    ...

    switch (action) {
    default:
        if (has_timeout)
            goto do_couple;
        ret = __lock_get(env, dbc->locker, lkflags, &dbc->lock_dbt, mode, lockp); // 一般的处理
        break;

    case LCK_DOWNGRADE:
        couple[0].op = DB_LOCK_GET;
        couple[0].obj = NULL;
        couple[0].lock = *lockp;
        couple[0].mode = DB_LOCK_WWRITE; // 请求一个新的 wwrite锁
        UMRW_SET(couple[0].timeout);
        i++;
        /* FALLTHROUGH */
    case LCK_COUPLE:
do_couple:    couple[i].op = has_timeout? DB_LOCK_GET_TIMEOUT : DB_LOCK_GET;
        couple[i].obj = &dbc->lock_dbt;
        couple[i].mode = mode;  // 对传入的 pgno 请求 一个 新的 锁,
        UMRW_SET(couple[i].timeout);
        i++;
        if (has_timeout)
            couple[0].timeout = F_ISSET(dbc, DBC_RECOVER) ? 0 : txn->lock_timeout;
        if (action == LCK_COUPLE || action == LCK_DOWNGRADE) {
            couple[i].op = DB_LOCK_PUT; // 释放原来的锁 (downgrade的话, 就是原来的 write锁, 从而实现了 锁降级)
            couple[i].lock = *lockp;
            i++;
        }

        ret = __lock_vec(env, dbc->locker, lkflags, couple, i, &reqp);
        if (ret == 0 || reqp == &couple[i - 1])
            *lockp = i == 1 ? couple[0].lock : couple[i - 2].lock; // i != 1标识 LCK_DOWNGRADE, 返回新的 wwrite锁
        break;
    }

__db_lput()
    if (F_ISSET(dbc->dbp, DB_AM_READ_UNCOMMITTED) && !F_ISSET(dbc, DBC_ERROR) && lockp->mode == DB_LOCK_WRITE)
        action = LCK_DOWNGRADE;
    else if (dbc->txn == NULL)
        action = LCK_COUPLE; // 这里的couple是直接释放的意思. 非transaction情况
    else if (F_ISSET(dbc, DBC_READ_COMMITTED | DBC_WAS_READ_COMMITTED) && lockp->mode == DB_LOCK_READ)
        action = LCK_COUPLE; // read_commited, 且读锁
    else if (lockp->mode == DB_LOCK_READ_UNCOMMITTED)
        action = LCK_COUPLE; // read_uncommitted, 读锁, 直接释放
    else
        action = 0;

    env = dbc->env;
    switch (action) {
    case LCK_COUPLE:
        ret = __lock_put(env, lockp);
        break;
    case LCK_DOWNGRADE:
        couple[0].op = DB_LOCK_GET;
        couple[0].obj = NULL;
        couple[0].mode = DB_LOCK_WWRITE; // 获取 一个ww锁
        couple[0].lock = *lockp;
        UMRW_SET(couple[0].timeout);
        couple[1].op = DB_LOCK_PUT;
        couple[1].lock = *lockp; // 释放本来的锁 (写锁)
        ret = __lock_vec(env, dbc->locker, 0, couple, 2, &reqp);
        if (ret == 0 || reqp == &couple[1])
            *lockp = couple[0].lock;
        break;
    default:
        ret = 0; // 嗯, 这里. 如果default isolation level, 保留读锁; 写锁不降级的话, 也到这里.
        break;
    }

    return (ret);
}