test_simple_deadlock.c 2.75 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38
// T(A) gets W(L)
// T(B) gets W(M)
// T(A) tries W(M), gets blocked
// T(B) tries W(L), gets deadlock
// T(B) releases locks
// T(A) granted W(M)
// T(A) releases locks

#include "test.h"

int main(int argc, const char *argv[]) {
    int r;

    uint32_t max_locks = 2;
    uint64_t max_lock_memory = 4096;

    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-v") == 0 || strcmp(argv[i], "--verbose") == 0) {
            verbose++;
            continue;
        }
        if (strcmp(argv[i], "-q") == 0 || strcmp(argv[i], "--quiet") == 0) {
            if (verbose > 0) verbose--;
            continue;
        }
        if (strcmp(argv[i], "--max_locks") == 0 && i+1 < argc) {
            max_locks = atoi(argv[++i]);
            continue;
        }
        if (strcmp(argv[i], "--max_lock_memory") == 0 && i+1 < argc) {
            max_lock_memory = atoi(argv[++i]);
            continue;
        }        
        assert(0);
    }

    // setup
    toku_ltm *ltm = NULL;
39
    r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic);
40 41 42
    assert(r == 0 && ltm);

    toku_lock_tree *lt = NULL;
43
    r = toku_ltm_get_lt(ltm, &lt, (DICTIONARY_ID){1}, NULL, dbcmp);
44 45 46 47
    assert(r == 0 && lt);

    const TXNID txn_a = 1;
    DBT key_l; dbt_init(&key_l, "L", 1);
48
    toku_lock_request a_w_l; toku_lock_request_init(&a_w_l, txn_a, &key_l, &key_l, LOCK_REQUEST_WRITE);
49 50 51 52 53 54
    r = toku_lock_request_start(&a_w_l, lt, false); assert(r == 0); 
    assert(a_w_l.state == LOCK_REQUEST_COMPLETE && a_w_l.complete_r == 0);
    toku_lock_request_destroy(&a_w_l);

    const TXNID txn_b = 2;
    DBT key_m; dbt_init(&key_m, "M", 1);
55
    toku_lock_request b_w_m; toku_lock_request_init(&b_w_m, txn_b, &key_m, &key_m, LOCK_REQUEST_WRITE);
56 57 58 59
    r = toku_lock_request_start(&b_w_m, lt, false); assert(r == 0); 
    assert(b_w_m.state == LOCK_REQUEST_COMPLETE && b_w_m.complete_r == 0);
    toku_lock_request_destroy(&b_w_m);

60
    toku_lock_request a_w_m; toku_lock_request_init(&a_w_m, txn_a, &key_m, &key_m, LOCK_REQUEST_WRITE);
61 62 63
    r = toku_lock_request_start(&a_w_m, lt, false); assert(r == DB_LOCK_NOTGRANTED); 
    assert(a_w_m.state == LOCK_REQUEST_PENDING);

64
    toku_lock_request b_w_l; toku_lock_request_init(&b_w_l, txn_b, &key_l, &key_l, LOCK_REQUEST_WRITE);
65 66 67
    r = toku_lock_request_start(&b_w_l, lt, false); assert(r == DB_LOCK_DEADLOCK); 
    assert(b_w_l.state == LOCK_REQUEST_COMPLETE && b_w_l.complete_r == DB_LOCK_DEADLOCK);

68
    r = toku_lt_unlock_txn(lt, txn_b); assert(r == 0);
69 70 71 72 73 74
    toku_lock_request_destroy(&b_w_l);

    assert(a_w_m.state == LOCK_REQUEST_COMPLETE && a_w_m.complete_r == 0
);
    toku_lock_request_destroy(&a_w_m);

75
    r = toku_lt_unlock_txn(lt, txn_a);  assert(r == 0);
76 77

    // shutdown 
78
    toku_lt_remove_db_ref(lt);
79 80 81 82
    r = toku_ltm_close(ltm); assert(r == 0);

    return 0;
}