Skip to content

M
mariadb
Commit 35a46f2e authored by Rich Prohaska's avatar Rich Prohaska Committed by Yoni Fogel
Browse files
Options

#3853 make the lock tree memory accounting more accurate refs[t:3853] 

git-svn-id: file:///svn/toku/tokudb@36278 c7de825b-a66e-492c-adef-691d508d4ae1
parent d69063c8
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 1250 additions and 1132 deletions
newbrt/tests/brt-serialize-test.c
View file @ 35a46f2e
...@@ -1262,8 +1262,6 @@ test_serialize_nonleaf(enum brtnode_verify_type bft) { ...@@ -1262,8 +1262,6 @@ test_serialize_nonleaf(enum brtnode_verify_type bft) {
int int
test_main (int argc __attribute__((__unused__)), const char *argv[] __attribute__((__unused__))) { test_main (int argc __attribute__((__unused__)), const char *argv[] __attribute__((__unused__))) {
toku_memory_check = 1;
test_serialize_leaf(read_none); test_serialize_leaf(read_none);
test_serialize_leaf(read_all); test_serialize_leaf(read_all);
test_serialize_leaf(read_compressed); test_serialize_leaf(read_compressed);
......
newbrt/tests/brt-test.c
View file @ 35a46f2e
...@@ -14,7 +14,7 @@ static void test_dump_empty_db (void) { ...@@ -14,7 +14,7 @@ static void test_dump_empty_db (void) {
BRT t; BRT t;
CACHETABLE ct; CACHETABLE ct;
int r; int r;
toku_memory_check=1;
r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER); r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER);
assert(r==0); assert(r==0);
unlink(fname); unlink(fname);
...@@ -1219,7 +1219,7 @@ static void test_new_brt_cursors(void) { ...@@ -1219,7 +1219,7 @@ static void test_new_brt_cursors(void) {
} }
static void brt_blackbox_test (void) { static void brt_blackbox_test (void) {
toku_memory_check = 1;
test_wrongendian_compare(0, 2); test_wrongendian_compare(0, 2);
test_wrongendian_compare(1, 2); test_wrongendian_compare(1, 2);
test_wrongendian_compare(1, 257); test_wrongendian_compare(1, 257);
...@@ -1236,8 +1236,6 @@ static void brt_blackbox_test (void) { ...@@ -1236,8 +1236,6 @@ static void brt_blackbox_test (void) {
if (verbose) printf("test_multiple_files\n"); if (verbose) printf("test_multiple_files\n");
test_multiple_files(); test_multiple_files();
toku_memory_check = 1;
test_brt_limits(); test_brt_limits();
test_brt_delete(); test_brt_delete();
......
newbrt/tests/brt-test0.c
View file @ 35a46f2e
...@@ -14,7 +14,6 @@ static void test0 (void) { ...@@ -14,7 +14,6 @@ static void test0 (void) {
CACHETABLE ct; CACHETABLE ct;
char fname[]= __FILE__ "0.brt"; char fname[]= __FILE__ "0.brt";
if (verbose) printf("%s:%d test0\n", __FILE__, __LINE__); if (verbose) printf("%s:%d test0\n", __FILE__, __LINE__);
toku_memory_check=1;
r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER); r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER);
assert(r==0); assert(r==0);
......
newbrt/tests/brt-test1.c
View file @ 35a46f2e
...@@ -14,7 +14,6 @@ static void test1 (void) { ...@@ -14,7 +14,6 @@ static void test1 (void) {
CACHETABLE ct; CACHETABLE ct;
char fname[]= __FILE__ "1.brt"; char fname[]= __FILE__ "1.brt";
DBT k,v; DBT k,v;
toku_memory_check=1;
r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER); r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER);
assert(r==0); assert(r==0);
......
newbrt/tests/brt-test2.c
View file @ 35a46f2e
...@@ -8,13 +8,12 @@ ...@@ -8,13 +8,12 @@
static TOKUTXN const null_txn = 0; static TOKUTXN const null_txn = 0;
static DB * const null_db = 0; static DB * const null_db = 0;
static void test2 (int memcheck, int limit) { static void test2 (int limit) {
BRT t; BRT t;
int r; int r;
int i; int i;
CACHETABLE ct; CACHETABLE ct;
char fname[]= __FILE__ "2.brt"; char fname[]= __FILE__ "2.brt";
toku_memory_check=memcheck;
if (verbose) printf("%s:%d checking\n", __FILE__, __LINE__); if (verbose) printf("%s:%d checking\n", __FILE__, __LINE__);
r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER); assert(r==0); r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER); assert(r==0);
...@@ -47,13 +46,11 @@ static void test2 (int memcheck, int limit) { ...@@ -47,13 +46,11 @@ static void test2 (int memcheck, int limit) {
int int
test_main (int argc , const char *argv[]) { test_main (int argc , const char *argv[]) {
default_parse_args(argc, argv); default_parse_args(argc, argv);
// if (verbose) printf("test2 checking memory\n");
// test2(1);
if (verbose) printf("test2 faster\n"); if (verbose) printf("test2 faster\n");
test2(0, 2); test2(2);
test2(0, 27); test2(27);
test2(0, 212); test2(212);
test2(0, 4096); test2(4096);
if (verbose) printf("test1 ok\n"); if (verbose) printf("test1 ok\n");
return 0; return 0;
......
newbrt/tests/brt-test3.c
View file @ 35a46f2e
...@@ -11,13 +11,12 @@ static const char fname[]= __FILE__ ".brt"; ...@@ -11,13 +11,12 @@ static const char fname[]= __FILE__ ".brt";
static TOKUTXN const null_txn = 0; static TOKUTXN const null_txn = 0;
static DB * const null_db = 0; static DB * const null_db = 0;
static void test3 (int nodesize, int basementnodesize, int count, int memcheck) { static void test3 (int nodesize, int basementnodesize, int count) {
BRT t; BRT t;
int r; int r;
struct timeval t0,t1; struct timeval t0,t1;
int i; int i;
CACHETABLE ct; CACHETABLE ct;
toku_memory_check=memcheck;
r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER); assert(r==0); r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER); assert(r==0);
gettimeofday(&t0, 0); gettimeofday(&t0, 0);
...@@ -45,26 +44,25 @@ static void test3 (int nodesize, int basementnodesize, int count, int memcheck) ...@@ -45,26 +44,25 @@ static void test3 (int nodesize, int basementnodesize, int count, int memcheck)
static void brt_blackbox_test (void) { static void brt_blackbox_test (void) {
if (verbose) printf("test3 slow\n"); if (verbose) printf("test3 slow\n");
toku_memory_check=0;
test3(2048, 512, 1<<15, 1); test3(2048, 512, 1<<15);
if (verbose) printf("test3 fast\n"); if (verbose) printf("test3 fast\n");
//if (verbose) toku_pma_show_stats(); //if (verbose) toku_pma_show_stats();
test3(1<<15, 1<<12, 1024, 1); test3(1<<15, 1<<12, 1024);
if (verbose) printf("test3 fast\n"); if (verbose) printf("test3 fast\n");
test3(1<<18, 1<<15, 1<<20, 0); test3(1<<18, 1<<15, 1<<20);
toku_memory_check = 1;
// test3(1<<19, 1<<16, 1<<20, 0); // test3(1<<19, 1<<16, 1<<20);
// test3(1<<20, 1<<17, 1<<20, 0); // test3(1<<20, 1<<17, 1<<20);
// test3(1<<20, 1<<17, 1<<21, 0); // test3(1<<20, 1<<17, 1<<21);
// test3(1<<20, 1<<17, 1<<22, 0); // test3(1<<20, 1<<17, 1<<22);
} }
......
newbrt/tests/brt-test4.c
View file @ 35a46f2e
...@@ -11,7 +11,7 @@ static const char fname[]= __FILE__ ".brt"; ...@@ -11,7 +11,7 @@ static const char fname[]= __FILE__ ".brt";
static TOKUTXN const null_txn = 0; static TOKUTXN const null_txn = 0;
static DB * const null_db = 0; static DB * const null_db = 0;
static void test4 (int nodesize, int count, int memcheck) { static void test4 (int nodesize, int count) {
BRT t; BRT t;
int r; int r;
struct timeval t0,t1; struct timeval t0,t1;
...@@ -19,7 +19,6 @@ static void test4 (int nodesize, int count, int memcheck) { ...@@ -19,7 +19,6 @@ static void test4 (int nodesize, int count, int memcheck) {
CACHETABLE ct; CACHETABLE ct;
gettimeofday(&t0, 0); gettimeofday(&t0, 0);
unlink(fname); unlink(fname);
toku_memory_check=memcheck;
r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER); assert(r==0); r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER); assert(r==0);
r = toku_open_brt(fname, 1, &t, nodesize, nodesize / 8, ct, null_txn, toku_builtin_compare_fun, null_db); assert(r==0); r = toku_open_brt(fname, 1, &t, nodesize, nodesize / 8, ct, null_txn, toku_builtin_compare_fun, null_db); assert(r==0);
...@@ -44,21 +43,21 @@ static void test4 (int nodesize, int count, int memcheck) { ...@@ -44,21 +43,21 @@ static void test4 (int nodesize, int count, int memcheck) {
} }
static void brt_blackbox_test (void) { static void brt_blackbox_test (void) {
test4(2048, 1<<14, 1); test4(2048, 1<<14);
if (0) { if (0) {
if (verbose) printf("test4 slow\n"); if (verbose) printf("test4 slow\n");
test4(2048, 1<<15, 1); test4(2048, 1<<15);
//if (verbose) toku_pma_show_stats(); //if (verbose) toku_pma_show_stats();
test4(1<<15, 1024, 1); test4(1<<15, 1024);
test4(1<<18, 1<<20, 0); test4(1<<18, 1<<20);
// Once upon a time srandom(8) caused this test to fail. // Once upon a time srandom(8) caused this test to fail.
srandom(8); test4(2048, 1<<15, 1); srandom(8); test4(2048, 1<<15);
} }
} }
......
newbrt/tests/orthopush-flush.c
View file @ 35a46f2e
...@@ -1069,7 +1069,6 @@ parse_args(int argc, const char *argv[]) { ...@@ -1069,7 +1069,6 @@ parse_args(int argc, const char *argv[]) {
int int
test_main (int argc, const char *argv[]) { test_main (int argc, const char *argv[]) {
toku_memory_check = 1;
parse_args(argc, argv); parse_args(argc, argv);
int r; int r;
......
newbrt/tests/test3856.c
View file @ 35a46f2e
...@@ -32,7 +32,6 @@ found(ITEMLEN UU(keylen), bytevec key, ITEMLEN UU(vallen), bytevec UU(val), void ...@@ -32,7 +32,6 @@ found(ITEMLEN UU(keylen), bytevec key, ITEMLEN UU(vallen), bytevec UU(val), void
int int
test_main (int argc __attribute__((__unused__)), const char *argv[] __attribute__((__unused__))) { test_main (int argc __attribute__((__unused__)), const char *argv[] __attribute__((__unused__))) {
toku_memory_check = 1;
CACHETABLE ct; CACHETABLE ct;
BRT t; BRT t;
......
newbrt/tests/test3884.c
View file @ 35a46f2e
...@@ -501,7 +501,6 @@ test_split_at_end(void) ...@@ -501,7 +501,6 @@ test_split_at_end(void)
int int
test_main (int argc __attribute__((__unused__)), const char *argv[] __attribute__((__unused__))) { test_main (int argc __attribute__((__unused__)), const char *argv[] __attribute__((__unused__))) {
toku_memory_check = 1;
test_split_on_boundary(); test_split_on_boundary();
test_split_with_everything_on_the_left(); test_split_with_everything_on_the_left();
......
src/lock_tree/idlth.c
View file @ 35a46f2e
...@@ -10,6 +10,7 @@ ...@@ -10,6 +10,7 @@
*/ */
#include <toku_portability.h> #include <toku_portability.h>
#include "memory.h"
#include <idlth.h> #include <idlth.h>
#include <toku_assert.h> #include <toku_assert.h>
#include <errno.h> #include <errno.h>
...@@ -28,23 +29,17 @@ static inline void toku__invalidate_scan(toku_idlth* idlth) { ...@@ -28,23 +29,17 @@ static inline void toku__invalidate_scan(toku_idlth* idlth) {
idlth->iter_is_valid = FALSE; idlth->iter_is_valid = FALSE;
} }
int toku_idlth_create(toku_idlth** pidlth, int toku_idlth_create(toku_idlth** pidlth) {
void* (*user_malloc) (size_t),
void (*user_free) (void*),
void* (*user_realloc)(void*, size_t)) {
int r = ENOSYS; int r = ENOSYS;
assert(pidlth && user_malloc && user_free && user_realloc); assert(pidlth);
toku_idlth* tmp = NULL; toku_idlth* tmp = NULL;
tmp = (toku_idlth*)user_malloc(sizeof(*tmp)); tmp = (toku_idlth*) toku_malloc(sizeof(*tmp));
if (!tmp) { r = ENOMEM; goto cleanup; } if (!tmp) { r = ENOMEM; goto cleanup; }
memset(tmp, 0, sizeof(*tmp)); memset(tmp, 0, sizeof(*tmp));
tmp->malloc = user_malloc;
tmp->free = user_free;
tmp->realloc = user_realloc;
tmp->num_buckets = __toku_idlth_init_size; tmp->num_buckets = __toku_idlth_init_size;
tmp->buckets = (toku_idlth_elt*) tmp->buckets = (toku_idlth_elt*)
tmp->malloc(tmp->num_buckets * sizeof(*tmp->buckets)); toku_malloc(tmp->num_buckets * sizeof(*tmp->buckets));
if (!tmp->buckets) { r = ENOMEM; goto cleanup; } if (!tmp->buckets) { r = ENOMEM; goto cleanup; }
memset(tmp->buckets, 0, tmp->num_buckets * sizeof(*tmp->buckets)); memset(tmp->buckets, 0, tmp->num_buckets * sizeof(*tmp->buckets));
toku__invalidate_scan(tmp); toku__invalidate_scan(tmp);
...@@ -56,8 +51,8 @@ int toku_idlth_create(toku_idlth** pidlth, ...@@ -56,8 +51,8 @@ int toku_idlth_create(toku_idlth** pidlth,
cleanup: cleanup:
if (r != 0) { if (r != 0) {
if (tmp) { if (tmp) {
if (tmp->buckets) { user_free(tmp->buckets); } if (tmp->buckets) { toku_free(tmp->buckets); }
user_free(tmp); toku_free(tmp);
} }
} }
return r; return r;
...@@ -87,7 +82,7 @@ static inline toku_idlth_elt* toku__idlth_next(toku_idlth* idlth) { ...@@ -87,7 +82,7 @@ static inline toku_idlth_elt* toku__idlth_next(toku_idlth* idlth) {
assert(idlth->iter_is_valid); assert(idlth->iter_is_valid);
idlth->iter_curr = idlth->iter_curr->next_in_iteration; idlth->iter_curr = idlth->iter_curr->next_in_iteration;
idlth->iter_is_valid = (BOOL)(idlth->iter_curr != &idlth->iter_head); idlth->iter_is_valid = (idlth->iter_curr != &idlth->iter_head);
return idlth->iter_curr; return idlth->iter_curr;
} }
...@@ -120,7 +115,7 @@ void toku_idlth_delete(toku_idlth* idlth, DICTIONARY_ID dict_id) { ...@@ -120,7 +115,7 @@ void toku_idlth_delete(toku_idlth* idlth, DICTIONARY_ID dict_id) {
current->prev_in_iteration->next_in_iteration = current->next_in_iteration; current->prev_in_iteration->next_in_iteration = current->next_in_iteration;
current->next_in_iteration->prev_in_iteration = current->prev_in_iteration; current->next_in_iteration->prev_in_iteration = current->prev_in_iteration;
prev->next_in_bucket = current->next_in_bucket; prev->next_in_bucket = current->next_in_bucket;
idlth->free(current); toku_free(current);
idlth->num_keys--; idlth->num_keys--;
return; return;
} }
...@@ -134,7 +129,7 @@ int toku_idlth_insert(toku_idlth* idlth, DICTIONARY_ID dict_id) { ...@@ -134,7 +129,7 @@ int toku_idlth_insert(toku_idlth* idlth, DICTIONARY_ID dict_id) {
uint32_t index = toku__idlth_hash(idlth, dict_id); uint32_t index = toku__idlth_hash(idlth, dict_id);
/* Allocate a new one. */ /* Allocate a new one. */
toku_idlth_elt* element = (toku_idlth_elt*)idlth->malloc(sizeof(*element)); toku_idlth_elt* element = (toku_idlth_elt*) toku_malloc(sizeof(*element));
if (!element) { r = ENOMEM; goto cleanup; } if (!element) { r = ENOMEM; goto cleanup; }
memset(element, 0, sizeof(*element)); memset(element, 0, sizeof(*element));
element->value.dict_id = dict_id; element->value.dict_id = dict_id;
...@@ -153,7 +148,7 @@ cleanup: ...@@ -153,7 +148,7 @@ cleanup:
return r; return r;
} }
static inline void toku__idlth_clear(toku_idlth* idlth, BOOL clean) { static inline void toku__idlth_clear(toku_idlth* idlth, bool clean) {
assert(idlth); assert(idlth);
toku_idlth_elt* element; toku_idlth_elt* element;
...@@ -164,7 +159,7 @@ static inline void toku__idlth_clear(toku_idlth* idlth, BOOL clean) { ...@@ -164,7 +159,7 @@ static inline void toku__idlth_clear(toku_idlth* idlth, BOOL clean) {
while (next != head) { while (next != head) {
element = next; element = next;
next = toku__idlth_next(idlth); next = toku__idlth_next(idlth);
idlth->free(element); toku_free(element);
} }
/* If clean is true, then we want to restore it to 'just created' status. /* If clean is true, then we want to restore it to 'just created' status.
If we are closing the tree, we don't need to do that restoration. */ If we are closing the tree, we don't need to do that restoration. */
...@@ -184,16 +179,16 @@ void toku_idlth_close(toku_idlth* idlth) { ...@@ -184,16 +179,16 @@ void toku_idlth_close(toku_idlth* idlth) {
assert(idlth); assert(idlth);
toku__idlth_clear(idlth, FALSE); toku__idlth_clear(idlth, FALSE);
idlth->free(idlth->buckets); toku_free(idlth->buckets);
idlth->free(idlth); toku_free(idlth);
} }
BOOL toku_idlth_is_empty(toku_idlth* idlth) { bool toku_idlth_is_empty(toku_idlth* idlth) {
assert(idlth); assert(idlth);
/* Verify consistency. */ /* Verify consistency. */
assert((idlth->num_keys == 0) == assert((idlth->num_keys == 0) ==
(idlth->iter_head.next_in_iteration == &idlth->iter_head)); (idlth->iter_head.next_in_iteration == &idlth->iter_head));
assert((idlth->num_keys == 0) == assert((idlth->num_keys == 0) ==
(idlth->iter_head.prev_in_iteration == &idlth->iter_head)); (idlth->iter_head.prev_in_iteration == &idlth->iter_head));
return (BOOL)(idlth->num_keys == 0); return (idlth->num_keys == 0);
} }
src/lock_tree/idlth.h
View file @ 35a46f2e
...@@ -11,7 +11,7 @@ ...@@ -11,7 +11,7 @@
*/ */
//Defines BOOL data type. //Defines bool data type.
#include <db.h> #include <db.h>
#include <brttypes.h> #include <brttypes.h>
#include <rangetree.h> #include <rangetree.h>
...@@ -46,19 +46,10 @@ struct __toku_idlth { ...@@ -46,19 +46,10 @@ struct __toku_idlth {
uint32_t num_keys; uint32_t num_keys;
toku_idlth_elt iter_head; toku_idlth_elt iter_head;
toku_idlth_elt* iter_curr; toku_idlth_elt* iter_curr;
BOOL iter_is_valid; bool iter_is_valid;
/** The user malloc function */
void* (*malloc) (size_t);
/** The user free function */
void (*free) (void*);
/** The user realloc function */
void* (*realloc)(void*, size_t);
}; };
int toku_idlth_create(toku_idlth** ptable, int toku_idlth_create(toku_idlth** ptable);
void* (*user_malloc) (size_t),
void (*user_free) (void*),
void* (*user_realloc)(void*, size_t));
toku_lt_map* toku_idlth_find (toku_idlth* table, DICTIONARY_ID dict_id); toku_lt_map* toku_idlth_find (toku_idlth* table, DICTIONARY_ID dict_id);
...@@ -74,7 +65,7 @@ int toku_idlth_insert (toku_idlth* table, DICTIONARY_ID dict_id) ...@@ -74,7 +65,7 @@ int toku_idlth_insert (toku_idlth* table, DICTIONARY_ID dict_id)
void toku_idlth_clear (toku_idlth* idlth); void toku_idlth_clear (toku_idlth* idlth);
BOOL toku_idlth_is_empty (toku_idlth* idlth); bool toku_idlth_is_empty (toku_idlth* idlth);
#if defined(__cplusplus) #if defined(__cplusplus)
} }
......
src/lock_tree/locktree.c
View file @ 35a46f2e
This diff is collapsed.
src/lock_tree/locktree.h
View file @ 35a46f2e
...@@ -97,7 +97,7 @@ struct __toku_lock_tree { ...@@ -97,7 +97,7 @@ struct __toku_lock_tree {
toku_range* bw_buf; toku_range* bw_buf;
uint32_t bw_buflen; uint32_t bw_buflen;
/** Whether lock escalation is allowed. */ /** Whether lock escalation is allowed. */
BOOL lock_escalation_allowed; bool lock_escalation_allowed;
/** Lock tree manager */ /** Lock tree manager */
toku_ltm* mgr; toku_ltm* mgr;
/** Function to retrieve the key compare function from the database. */ /** Function to retrieve the key compare function from the database. */
...@@ -106,12 +106,6 @@ struct __toku_lock_tree { ...@@ -106,12 +106,6 @@ struct __toku_lock_tree {
int (*compare_fun)(DB*,const DBT*,const DBT*); int (*compare_fun)(DB*,const DBT*,const DBT*);
/** The panic function */ /** The panic function */
int (*panic)(DB*, int); int (*panic)(DB*, int);
/** The user malloc function */
void* (*malloc) (size_t);
/** The user free function */
void (*free) (void*);
/** The user realloc function */
void* (*realloc)(void*, size_t);
/** The number of references held by DB instances and transactions to this lock tree*/ /** The number of references held by DB instances and transactions to this lock tree*/
uint32_t ref_count; uint32_t ref_count;
/** DICTIONARY_ID associated with the lock tree */ /** DICTIONARY_ID associated with the lock tree */
...@@ -158,12 +152,6 @@ struct __toku_ltm { ...@@ -158,12 +152,6 @@ struct __toku_ltm {
toku_dbt_cmp (*get_compare_fun_from_db)(DB*); toku_dbt_cmp (*get_compare_fun_from_db)(DB*);
/** The panic function */ /** The panic function */
int (*panic)(DB*, int); int (*panic)(DB*, int);
/** The user malloc function */
void* (*malloc) (size_t);
/** The user free function */
void (*free) (void*);
/** The user realloc function */
void* (*realloc)(void*, size_t);
toku_pthread_mutex_t lock; toku_pthread_mutex_t lock;
toku_pthread_mutex_t *use_lock; toku_pthread_mutex_t *use_lock;
...@@ -205,9 +193,6 @@ typedef struct __toku_point toku_point; ...@@ -205,9 +193,6 @@ typedef struct __toku_point toku_point;
\param panic The function to cause the db to panic. \param panic The function to cause the db to panic.
i.e., godzilla_rampage() i.e., godzilla_rampage()
\param payload_capacity The maximum amount of memory to use for dbt payloads. \param payload_capacity The maximum amount of memory to use for dbt payloads.
\param user_malloc A user provided malloc(3) function.
\param user_free A user provided free(3) function.
\param user_realloc A user provided realloc(3) function.
\return \return
- 0 Success - 0 Success
...@@ -225,10 +210,7 @@ typedef struct __toku_point toku_point; ...@@ -225,10 +210,7 @@ typedef struct __toku_point toku_point;
int toku_lt_create(toku_lock_tree** ptree, int toku_lt_create(toku_lock_tree** ptree,
int (*panic)(DB*, int), int (*panic)(DB*, int),
toku_ltm* mgr, toku_ltm* mgr,
toku_dbt_cmp (*get_compare_fun_from_db)(DB*), toku_dbt_cmp (*get_compare_fun_from_db)(DB*));
void* (*user_malloc) (size_t),
void (*user_free) (void*),
void* (*user_realloc)(void*, size_t));
/** /**
Gets a lock tree for a given DB with id dict_id Gets a lock tree for a given DB with id dict_id
...@@ -410,9 +392,6 @@ int toku_lt_unlock(toku_lock_tree* tree, TXNID txn); ...@@ -410,9 +392,6 @@ int toku_lt_unlock(toku_lock_tree* tree, TXNID txn);
\param pmgr A buffer for the new lock tree manager. \param pmgr A buffer for the new lock tree manager.
\param max_locks The maximum number of locks. \param max_locks The maximum number of locks.
\param user_malloc A user provided malloc(3) function.
\param user_free A user provided free(3) function.
\param user_realloc A user provided realloc(3) function.
\return \return
- 0 on success. - 0 on success.
...@@ -423,10 +402,7 @@ int toku_ltm_create(toku_ltm** pmgr, ...@@ -423,10 +402,7 @@ int toku_ltm_create(toku_ltm** pmgr,
uint32_t max_locks, uint32_t max_locks,
uint64_t max_lock_memory, uint64_t max_lock_memory,
int (*panic)(DB*, int), int (*panic)(DB*, int),
toku_dbt_cmp (*get_compare_fun_from_db)(DB*), toku_dbt_cmp (*get_compare_fun_from_db)(DB*));
void* (*user_malloc) (size_t),
void (*user_free) (void*),
void* (*user_realloc)(void*, size_t));
/** /**
Closes and frees a lock tree manager.. Closes and frees a lock tree manager..
...@@ -464,6 +440,9 @@ void toku_ltm_get_status(toku_ltm* mgr, uint32_t * max_locks, uint32_t * curr_lo ...@@ -464,6 +440,9 @@ void toku_ltm_get_status(toku_ltm* mgr, uint32_t * max_locks, uint32_t * curr_lo
int toku_ltm_get_max_locks(toku_ltm* mgr, uint32_t* max_locks); int toku_ltm_get_max_locks(toku_ltm* mgr, uint32_t* max_locks);
void toku_ltm_incr_lock_memory(void *extra, size_t s);
void toku_ltm_decr_lock_memory(void *extra, size_t s);
void toku_lt_add_ref(toku_lock_tree* tree); void toku_lt_add_ref(toku_lock_tree* tree);
int toku_lt_remove_ref(toku_lock_tree* tree); int toku_lt_remove_ref(toku_lock_tree* tree);
......
src/lock_tree/lth.c
View file @ 35a46f2e
...@@ -10,6 +10,7 @@ ...@@ -10,6 +10,7 @@
*/ */
#include <toku_portability.h> #include <toku_portability.h>
#include "memory.h"
#include "lth.h" #include "lth.h"
#include <toku_assert.h> #include <toku_assert.h>
#include <errno.h> #include <errno.h>
...@@ -27,23 +28,17 @@ static inline void toku__invalidate_scan(toku_lth* lth) { ...@@ -27,23 +28,17 @@ static inline void toku__invalidate_scan(toku_lth* lth) {
lth->iter_is_valid = FALSE; lth->iter_is_valid = FALSE;
} }
int toku_lth_create(toku_lth** plth, int toku_lth_create(toku_lth** plth) {
void* (*user_malloc) (size_t),
void (*user_free) (void*),
void* (*user_realloc)(void*, size_t)) {
int r = ENOSYS; int r = ENOSYS;
assert(plth && user_malloc && user_free && user_realloc); assert(plth);
toku_lth* tmp = NULL; toku_lth* tmp = NULL;
tmp = (toku_lth*)user_malloc(sizeof(*tmp)); tmp = (toku_lth*) toku_malloc(sizeof(*tmp));
if (!tmp) { r = ENOMEM; goto cleanup; } if (!tmp) { r = ENOMEM; goto cleanup; }
memset(tmp, 0, sizeof(*tmp)); memset(tmp, 0, sizeof(*tmp));
tmp->malloc = user_malloc;
tmp->free = user_free;
tmp->realloc = user_realloc;
tmp->num_buckets = __toku_lth_init_size; tmp->num_buckets = __toku_lth_init_size;
tmp->buckets = (toku_lth_elt*) tmp->buckets = (toku_lth_elt*)
tmp->malloc(tmp->num_buckets * sizeof(*tmp->buckets)); toku_malloc(tmp->num_buckets * sizeof(*tmp->buckets));
if (!tmp->buckets) { r = ENOMEM; goto cleanup; } if (!tmp->buckets) { r = ENOMEM; goto cleanup; }
memset(tmp->buckets, 0, tmp->num_buckets * sizeof(*tmp->buckets)); memset(tmp->buckets, 0, tmp->num_buckets * sizeof(*tmp->buckets));
toku__invalidate_scan(tmp); toku__invalidate_scan(tmp);
...@@ -55,8 +50,8 @@ int toku_lth_create(toku_lth** plth, ...@@ -55,8 +50,8 @@ int toku_lth_create(toku_lth** plth,
cleanup: cleanup:
if (r != 0) { if (r != 0) {
if (tmp) { if (tmp) {
if (tmp->buckets) { user_free(tmp->buckets); } if (tmp->buckets) { toku_free(tmp->buckets); }
user_free(tmp); toku_free(tmp);
} }
} }
return r; return r;
...@@ -86,7 +81,7 @@ static inline toku_lth_elt* toku__lth_next(toku_lth* lth) { ...@@ -86,7 +81,7 @@ static inline toku_lth_elt* toku__lth_next(toku_lth* lth) {
assert(lth->iter_is_valid); assert(lth->iter_is_valid);
lth->iter_curr = lth->iter_curr->next_in_iteration; lth->iter_curr = lth->iter_curr->next_in_iteration;
lth->iter_is_valid = (BOOL)(lth->iter_curr != &lth->iter_head); lth->iter_is_valid = (bool)(lth->iter_curr != &lth->iter_head);
return lth->iter_curr; return lth->iter_curr;
} }
...@@ -119,7 +114,7 @@ void toku_lth_delete(toku_lth* lth, toku_lock_tree* key) { ...@@ -119,7 +114,7 @@ void toku_lth_delete(toku_lth* lth, toku_lock_tree* key) {
current->prev_in_iteration->next_in_iteration = current->next_in_iteration; current->prev_in_iteration->next_in_iteration = current->next_in_iteration;
current->next_in_iteration->prev_in_iteration = current->prev_in_iteration; current->next_in_iteration->prev_in_iteration = current->prev_in_iteration;
prev->next_in_bucket = current->next_in_bucket; prev->next_in_bucket = current->next_in_bucket;
lth->free(current); toku_free(current);
lth->num_keys--; lth->num_keys--;
return; return;
} }
...@@ -133,7 +128,7 @@ int toku_lth_insert(toku_lth* lth, toku_lock_tree* key) { ...@@ -133,7 +128,7 @@ int toku_lth_insert(toku_lth* lth, toku_lock_tree* key) {
uint32_t index = toku__lth_hash(lth, key); uint32_t index = toku__lth_hash(lth, key);
/* Allocate a new one. */ /* Allocate a new one. */
toku_lth_elt* element = (toku_lth_elt*)lth->malloc(sizeof(*element)); toku_lth_elt* element = (toku_lth_elt*) toku_malloc(sizeof(*element));
if (!element) { r = ENOMEM; goto cleanup; } if (!element) { r = ENOMEM; goto cleanup; }
memset(element, 0, sizeof(*element)); memset(element, 0, sizeof(*element));
element->value.hash_key = key; element->value.hash_key = key;
...@@ -162,9 +157,9 @@ void toku_lth_close(toku_lth* lth) { ...@@ -162,9 +157,9 @@ void toku_lth_close(toku_lth* lth) {
while (next != head) { while (next != head) {
element = next; element = next;
next = toku__lth_next(lth); next = toku__lth_next(lth);
lth->free(element); toku_free(element);
} }
lth->free(lth->buckets); toku_free(lth->buckets);
lth->free(lth); toku_free(lth);
} }
src/lock_tree/lth.h
View file @ 35a46f2e
...@@ -12,7 +12,7 @@ ...@@ -12,7 +12,7 @@
*/ */
//Defines BOOL data type. //Defines bool data type.
#include <db.h> #include <db.h>
#include <brttypes.h> #include <brttypes.h>
#include <locktree.h> #include <locktree.h>
...@@ -51,20 +51,11 @@ struct __toku_lth { ...@@ -51,20 +51,11 @@ struct __toku_lth {
uint32_t num_keys; uint32_t num_keys;
toku_lth_elt iter_head; toku_lth_elt iter_head;
toku_lth_elt* iter_curr; toku_lth_elt* iter_curr;
BOOL iter_is_valid; bool iter_is_valid;
/** The user malloc function */
void* (*malloc) (size_t);
/** The user free function */
void (*free) (void*);
/** The user realloc function */
void* (*realloc)(void*, size_t);
}; };
int toku_lth_create(toku_lth** ptable, int toku_lth_create(toku_lth** ptable);
void* (*user_malloc) (size_t),
void (*user_free) (void*),
void* (*user_realloc)(void*, size_t));
toku_lock_tree* toku_lth_find (toku_lth* table, toku_lock_tree* key); toku_lock_tree* toku_lth_find (toku_lth* table, toku_lock_tree* key);
......
src/lock_tree/rth.c
View file @ 35a46f2e
...@@ -10,6 +10,7 @@ ...@@ -10,6 +10,7 @@
*/ */
#include <toku_portability.h> #include <toku_portability.h>
#include "memory.h"
#include "rth.h" #include "rth.h"
#include <toku_assert.h> #include <toku_assert.h>
#include <errno.h> #include <errno.h>
...@@ -27,23 +28,17 @@ static inline void toku__invalidate_scan(toku_rth* rth) { ...@@ -27,23 +28,17 @@ static inline void toku__invalidate_scan(toku_rth* rth) {
rth->iter_is_valid = FALSE; rth->iter_is_valid = FALSE;
} }
int toku_rth_create(toku_rth** prth, int toku_rth_create(toku_rth** prth) {
void* (*user_malloc) (size_t),
void (*user_free) (void*),
void* (*user_realloc)(void*, size_t)) {
int r = ENOSYS; int r = ENOSYS;
assert(prth && user_malloc && user_free && user_realloc); assert(prth);
toku_rth* tmp = NULL; toku_rth* tmp = NULL;
tmp = (toku_rth*)user_malloc(sizeof(*tmp)); tmp = (toku_rth*) toku_malloc(sizeof(*tmp));
if (!tmp) { r = ENOMEM; goto cleanup; } if (!tmp) { r = ENOMEM; goto cleanup; }
memset(tmp, 0, sizeof(*tmp)); memset(tmp, 0, sizeof(*tmp));
tmp->malloc = user_malloc;
tmp->free = user_free;
tmp->realloc = user_realloc;
tmp->num_buckets = __toku_rth_init_size; tmp->num_buckets = __toku_rth_init_size;
tmp->buckets = (toku_rth_elt*) tmp->buckets = (toku_rth_elt*)
tmp->malloc(tmp->num_buckets * sizeof(*tmp->buckets)); toku_malloc(tmp->num_buckets * sizeof(*tmp->buckets));
if (!tmp->buckets) { r = ENOMEM; goto cleanup; } if (!tmp->buckets) { r = ENOMEM; goto cleanup; }
memset(tmp->buckets, 0, tmp->num_buckets * sizeof(*tmp->buckets)); memset(tmp->buckets, 0, tmp->num_buckets * sizeof(*tmp->buckets));
toku__invalidate_scan(tmp); toku__invalidate_scan(tmp);
...@@ -55,8 +50,8 @@ int toku_rth_create(toku_rth** prth, ...@@ -55,8 +50,8 @@ int toku_rth_create(toku_rth** prth,
cleanup: cleanup:
if (r != 0) { if (r != 0) {
if (tmp) { if (tmp) {
if (tmp->buckets) { user_free(tmp->buckets); } if (tmp->buckets) { toku_free(tmp->buckets); }
user_free(tmp); toku_free(tmp);
} }
} }
return r; return r;
...@@ -86,7 +81,7 @@ static inline toku_rth_elt* toku__rth_next(toku_rth* rth) { ...@@ -86,7 +81,7 @@ static inline toku_rth_elt* toku__rth_next(toku_rth* rth) {
assert(rth->iter_is_valid); assert(rth->iter_is_valid);
rth->iter_curr = rth->iter_curr->next_in_iteration; rth->iter_curr = rth->iter_curr->next_in_iteration;
rth->iter_is_valid = (BOOL)(rth->iter_curr != &rth->iter_head); rth->iter_is_valid = (rth->iter_curr != &rth->iter_head);
return rth->iter_curr; return rth->iter_curr;
} }
...@@ -119,7 +114,7 @@ void toku_rth_delete(toku_rth* rth, TXNID key) { ...@@ -119,7 +114,7 @@ void toku_rth_delete(toku_rth* rth, TXNID key) {
current->prev_in_iteration->next_in_iteration = current->next_in_iteration; current->prev_in_iteration->next_in_iteration = current->next_in_iteration;
current->next_in_iteration->prev_in_iteration = current->prev_in_iteration; current->next_in_iteration->prev_in_iteration = current->prev_in_iteration;
prev->next_in_bucket = current->next_in_bucket; prev->next_in_bucket = current->next_in_bucket;
rth->free(current); toku_free(current);
rth->num_keys--; rth->num_keys--;
return; return;
} }
...@@ -133,7 +128,7 @@ int toku_rth_insert(toku_rth* rth, TXNID key) { ...@@ -133,7 +128,7 @@ int toku_rth_insert(toku_rth* rth, TXNID key) {
uint32_t index = toku__rth_hash(rth, key); uint32_t index = toku__rth_hash(rth, key);
/* Allocate a new one. */ /* Allocate a new one. */
toku_rth_elt* element = (toku_rth_elt*)rth->malloc(sizeof(*element)); toku_rth_elt* element = (toku_rth_elt*) toku_malloc(sizeof(*element));
if (!element) { r = ENOMEM; goto cleanup; } if (!element) { r = ENOMEM; goto cleanup; }
memset(element, 0, sizeof(*element)); memset(element, 0, sizeof(*element));
element->value.hash_key = key; element->value.hash_key = key;
...@@ -151,7 +146,7 @@ cleanup: ...@@ -151,7 +146,7 @@ cleanup:
return r; return r;
} }
static inline void toku__rth_clear(toku_rth* rth, BOOL clean) { static inline void toku__rth_clear(toku_rth* rth, bool clean) {
assert(rth); assert(rth);
toku_rth_elt* element; toku_rth_elt* element;
...@@ -162,7 +157,7 @@ static inline void toku__rth_clear(toku_rth* rth, BOOL clean) { ...@@ -162,7 +157,7 @@ static inline void toku__rth_clear(toku_rth* rth, BOOL clean) {
while (next != head) { while (next != head) {
element = next; element = next;
next = toku__rth_next(rth); next = toku__rth_next(rth);
rth->free(element); toku_free(element);
} }
/* If clean is true, then we want to restore it to 'just created' status. /* If clean is true, then we want to restore it to 'just created' status.
If we are closing the tree, we don't need to do that restoration. */ If we are closing the tree, we don't need to do that restoration. */
...@@ -182,16 +177,16 @@ void toku_rth_close(toku_rth* rth) { ...@@ -182,16 +177,16 @@ void toku_rth_close(toku_rth* rth) {
assert(rth); assert(rth);
toku__rth_clear(rth, FALSE); toku__rth_clear(rth, FALSE);
rth->free(rth->buckets); toku_free(rth->buckets);
rth->free(rth); toku_free(rth);
} }
BOOL toku_rth_is_empty(toku_rth* rth) { bool toku_rth_is_empty(toku_rth* rth) {
assert(rth); assert(rth);
/* Verify consistency. */ /* Verify consistency. */
assert((rth->num_keys == 0) == assert((rth->num_keys == 0) ==
(rth->iter_head.next_in_iteration == &rth->iter_head)); (rth->iter_head.next_in_iteration == &rth->iter_head));
assert((rth->num_keys == 0) == assert((rth->num_keys == 0) ==
(rth->iter_head.prev_in_iteration == &rth->iter_head)); (rth->iter_head.prev_in_iteration == &rth->iter_head));
return (BOOL)(rth->num_keys == 0); return (rth->num_keys == 0);
} }
src/lock_tree/rth.h
View file @ 35a46f2e
...@@ -11,7 +11,6 @@ ...@@ -11,7 +11,6 @@
*/ */
//Defines BOOL data type.
#include <db.h> #include <db.h>
#include <brttypes.h> #include <brttypes.h>
#include <rangetree.h> #include <rangetree.h>
...@@ -42,19 +41,10 @@ struct __toku_rth { ...@@ -42,19 +41,10 @@ struct __toku_rth {
uint32_t num_keys; uint32_t num_keys;
toku_rth_elt iter_head; toku_rth_elt iter_head;
toku_rth_elt* iter_curr; toku_rth_elt* iter_curr;
BOOL iter_is_valid; bool iter_is_valid;
/** The user malloc function */
void* (*malloc) (size_t);
/** The user free function */
void (*free) (void*);
/** The user realloc function */
void* (*realloc)(void*, size_t);
}; };
int toku_rth_create(toku_rth** ptable, int toku_rth_create(toku_rth** ptable);
void* (*user_malloc) (size_t),
void (*user_free) (void*),
void* (*user_realloc)(void*, size_t));
rt_forest* toku_rth_find (toku_rth* table, TXNID key); rt_forest* toku_rth_find (toku_rth* table, TXNID key);
...@@ -70,7 +60,7 @@ int toku_rth_insert (toku_rth* table, TXNID key); ...@@ -70,7 +60,7 @@ int toku_rth_insert (toku_rth* table, TXNID key);
void toku_rth_clear (toku_rth* rth); void toku_rth_clear (toku_rth* rth);
BOOL toku_rth_is_empty (toku_rth* rth); bool toku_rth_is_empty (toku_rth* rth);
#if defined(__cplusplus) #if defined(__cplusplus)
} }
......
src/lock_tree/tests/Makefile
View file @ 35a46f2e
...@@ -75,3 +75,37 @@ clean: ...@@ -75,3 +75,37 @@ clean:
rm -f $(ALL_TESTS) rm -f $(ALL_TESTS)
rm -rf dir.*.lin dir.*.tlog dir.*.log rm -rf dir.*.lin dir.*.tlog dir.*.log
check_footprint.linrun: check_footprint_point.linrun check_footprint_range.linrun
true
check_footprint_point.linrun: test_footprint_point_write.lin
$(VGRIND) ./$< -v --nrows 1 && \
$(VGRIND) ./$< -v --nrows 2 && \
$(VGRIND) ./$< -v --nrows 10 --max_locks 1000 && \
$(VGRIND) ./$< -v --nrows 100 --max_locks 1000 && \
$(VGRIND) ./$< -v --nrows 1000 --max_locks 1000
check_footprint_range.linrun: test_footprint_range_write.lin
$(VGRIND) ./$< -v --nrows 1 && \
$(VGRIND) ./$< -v --nrows 2 && \
$(VGRIND) ./$< -v --nrows 10 --max_locks 1000 && \
$(VGRIND) ./$< -v --nrows 100 --max_locks 1000 && \
$(VGRIND) ./$< -v --nrows 1000 --max_locks 1000
check_footprint.tlogrun: check_footprint_point.tlogrun check_footprint_range.tlogrun
true
check_footprint_point.tlogrun: test_footprint_point_write.tlog
$(VGRIND) ./$< -v --nrows 1 && \
$(VGRIND) ./$< -v --nrows 2 && \
$(VGRIND) ./$< -v --nrows 10 --max_locks 1000 && \
$(VGRIND) ./$< -v --nrows 100 --max_locks 1000 && \
$(VGRIND) ./$< -v --nrows 1000 --max_locks 1000
check_footprint_range.tlogrun: test_footprint_range_write.tlog
$(VGRIND) ./$< -v --nrows 1 && \
$(VGRIND) ./$< -v --nrows 2 && \
$(VGRIND) ./$< -v --nrows 10 --max_locks 1000 && \
$(VGRIND) ./$< -v --nrows 100 --max_locks 1000 && \
$(VGRIND) ./$< -v --nrows 1000 --max_locks 1000
src/lock_tree/tests/bench_point_write_locks.c
View file @ 35a46f2e
...@@ -38,11 +38,11 @@ int main(int argc, const char *argv[]) { ...@@ -38,11 +38,11 @@ int main(int argc, const char *argv[]) {
// setup // setup
toku_ltm *ltm = NULL; toku_ltm *ltm = NULL;
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
assert(r == 0 && ltm); assert(r == 0 && ltm);
toku_lock_tree *lt = NULL; toku_lock_tree *lt = NULL;
r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
assert(r == 0 && lt); assert(r == 0 && lt);
DB *db_a = (DB *) 2; DB *db_a = (DB *) 2;
......
src/lock_tree/tests/test.h
View file @ 35a46f2e
...@@ -17,7 +17,7 @@ int verbose=0; ...@@ -17,7 +17,7 @@ int verbose=0;
#include <key.h> #include <key.h>
BOOL want_panic = FALSE; bool want_panic = false;
static inline int intcmp(DB *db __attribute__((__unused__)), const DBT* a, const DBT* b) { static inline int intcmp(DB *db __attribute__((__unused__)), const DBT* a, const DBT* b) {
int x = *(int*)a->data; int x = *(int*)a->data;
...@@ -39,11 +39,11 @@ static inline toku_dbt_cmp get_compare_fun_from_db(__attribute__((unused)) DB* d ...@@ -39,11 +39,11 @@ static inline toku_dbt_cmp get_compare_fun_from_db(__attribute__((unused)) DB* d
return compare_fun; return compare_fun;
} }
BOOL panicked = FALSE; bool panicked = false;
static inline int dbpanic(DB* db, int r) { static inline int dbpanic(DB* db, int r) {
if (verbose) printf("AHH!!!! %d is rampaging! Run away %p!!!\n", r, db); if (verbose) printf("AHH!!!! %d is rampaging! Run away %p!!!\n", r, db);
panicked = TRUE; panicked = true;
assert(want_panic); assert(want_panic);
return EINVAL; return EINVAL;
} }
...@@ -107,13 +107,3 @@ static inline void init_point(toku_point* point, toku_lock_tree* tree) { ...@@ -107,13 +107,3 @@ static inline void init_point(toku_point* point, toku_lock_tree* tree) {
point->lt = tree; point->lt = tree;
} }
int mallocced = 0;
int failon = -1;
static inline void* fail_malloc(size_t size) {
if (++mallocced == failon) {
errno = ENOMEM;
return NULL;
}
return toku_malloc(size);
}
src/lock_tree/tests/test_00000_createclose.c
View file @ 35a46f2e
...@@ -8,14 +8,12 @@ int main(void) { ...@@ -8,14 +8,12 @@ int main(void) {
uint64_t max_lock_memory = max_locks*64; uint64_t max_lock_memory = max_locks*64;
r = toku_ltm_create(&mgr, max_locks, max_lock_memory, dbpanic, r = toku_ltm_create(&mgr, max_locks, max_lock_memory, dbpanic,
get_compare_fun_from_db, get_compare_fun_from_db);
toku_malloc, toku_free, toku_realloc);
CKERR(r); CKERR(r);
{ {
r = toku_lt_create(&lt, dbpanic, mgr, r = toku_lt_create(&lt, dbpanic, mgr,
get_compare_fun_from_db, get_compare_fun_from_db);
toku_malloc, toku_free, toku_realloc);
CKERR(r); CKERR(r);
assert(lt); assert(lt);
r = toku_lt_close(lt); r = toku_lt_close(lt);
......
src/lock_tree/tests/test_00010_parameter_errors.c
View file @ 35a46f2e
...@@ -22,9 +22,8 @@ static void do_range_test(int (*acquire)(toku_lock_tree*, DB*, TXNID, ...@@ -22,9 +22,8 @@ static void do_range_test(int (*acquire)(toku_lock_tree*, DB*, TXNID,
DBT* key_l = &_key_l; DBT* key_l = &_key_l;
DBT* key_r = &_key_r; DBT* key_r = &_key_r;
{ {
r = toku_lt_create(&lt, dbpanic, ltm, r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
get_compare_fun_from_db,
toku_malloc, toku_free, toku_realloc);
CKERR(r); CKERR(r);
assert(lt); assert(lt);
...@@ -65,9 +64,7 @@ static void do_point_test(int (*acquire)(toku_lock_tree*, DB*, TXNID, ...@@ -65,9 +64,7 @@ static void do_point_test(int (*acquire)(toku_lock_tree*, DB*, TXNID,
/* Point read tests. */ /* Point read tests. */
key = &_key; key = &_key;
{ {
r = toku_lt_create(&lt, dbpanic, ltm, r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
get_compare_fun_from_db,
toku_malloc, toku_free, toku_realloc);
CKERR(r); CKERR(r);
assert(lt); assert(lt);
...@@ -94,113 +91,69 @@ int main(int argc, const char *argv[]) { ...@@ -94,113 +91,69 @@ int main(int argc, const char *argv[]) {
int r; int r;
toku_lock_tree* lt = NULL; toku_lock_tree* lt = NULL;
r = toku_ltm_create(NULL, max_locks, max_lock_memory, dbpanic, r = toku_ltm_create(NULL, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
get_compare_fun_from_db, CKERR2(r, EINVAL);
toku_malloc, toku_free, toku_realloc); assert(ltm == NULL);
CKERR2(r, EINVAL); r = toku_ltm_create(&ltm, 0, max_lock_memory, dbpanic, get_compare_fun_from_db);
assert(ltm == NULL); CKERR2(r, EINVAL);
r = toku_ltm_create(&ltm, 0, max_lock_memory, dbpanic, assert(ltm == NULL);
get_compare_fun_from_db, r = toku_ltm_create(&ltm, max_locks, 0, dbpanic, get_compare_fun_from_db);
toku_malloc, toku_free, toku_realloc); CKERR2(r, EINVAL);
CKERR2(r, EINVAL); assert(ltm == NULL);
assert(ltm == NULL);
r = toku_ltm_create(&ltm, max_locks, 0, dbpanic,
get_compare_fun_from_db,
toku_malloc, toku_free, toku_realloc);
CKERR2(r, EINVAL);
assert(ltm == NULL);
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic,
get_compare_fun_from_db,
NULL, toku_free, toku_realloc);
CKERR2(r, EINVAL);
assert(ltm == NULL);
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic,
get_compare_fun_from_db,
toku_malloc, NULL, toku_realloc);
CKERR2(r, EINVAL);
assert(ltm == NULL);
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic,
get_compare_fun_from_db,
toku_malloc, toku_free, NULL);
CKERR2(r, EINVAL);
assert(ltm == NULL);
/* Actually create it. */ /* Actually create it. */
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
get_compare_fun_from_db,
toku_malloc, toku_free, toku_realloc);
CKERR(r); CKERR(r);
assert(ltm); assert(ltm);
r = toku_ltm_set_max_locks(NULL, max_locks); r = toku_ltm_set_max_locks(NULL, max_locks);
CKERR2(r, EINVAL); CKERR2(r, EINVAL);
r = toku_ltm_set_max_locks(ltm, 0); r = toku_ltm_set_max_locks(ltm, 0);
CKERR2(r, EINVAL); CKERR2(r, EINVAL);
r = toku_ltm_set_max_locks(ltm, max_locks); r = toku_ltm_set_max_locks(ltm, max_locks);
CKERR(r); CKERR(r);
uint32_t get_max = 73; //Some random number that isn't 0. uint32_t get_max = 73; //Some random number that isn't 0.
r = toku_ltm_get_max_locks(NULL, &get_max); r = toku_ltm_get_max_locks(NULL, &get_max);
CKERR2(r, EINVAL); CKERR2(r, EINVAL);
assert(get_max == 73); assert(get_max == 73);
r = toku_ltm_get_max_locks(ltm, NULL); r = toku_ltm_get_max_locks(ltm, NULL);
CKERR2(r, EINVAL); CKERR2(r, EINVAL);
assert(get_max == 73); assert(get_max == 73);
r = toku_ltm_get_max_locks(ltm, &get_max); r = toku_ltm_get_max_locks(ltm, &get_max);
CKERR(r); CKERR(r);
assert(get_max == max_locks); assert(get_max == max_locks);
r = toku_ltm_set_max_lock_memory(NULL, max_lock_memory); r = toku_ltm_set_max_lock_memory(NULL, max_lock_memory);
CKERR2(r, EINVAL); CKERR2(r, EINVAL);
r = toku_ltm_set_max_lock_memory(ltm, 0); r = toku_ltm_set_max_lock_memory(ltm, 0);
CKERR2(r, EINVAL); CKERR2(r, EINVAL);
r = toku_ltm_set_max_lock_memory(ltm, max_lock_memory); r = toku_ltm_set_max_lock_memory(ltm, max_lock_memory);
CKERR(r); CKERR(r);
uint64_t get_max_memory = 73; //Some random number that isn't 0. uint64_t get_max_memory = 73; //Some random number that isn't 0.
r = toku_ltm_get_max_lock_memory(NULL, &get_max_memory); r = toku_ltm_get_max_lock_memory(NULL, &get_max_memory);
CKERR2(r, EINVAL); CKERR2(r, EINVAL);
assert(get_max_memory == 73); assert(get_max_memory == 73);
r = toku_ltm_get_max_lock_memory(ltm, NULL); r = toku_ltm_get_max_lock_memory(ltm, NULL);
CKERR2(r, EINVAL); CKERR2(r, EINVAL);
assert(get_max_memory == 73); assert(get_max_memory == 73);
r = toku_ltm_get_max_lock_memory(ltm, &get_max_memory); r = toku_ltm_get_max_lock_memory(ltm, &get_max_memory);
CKERR(r); CKERR(r);
assert(get_max_memory == max_lock_memory); assert(get_max_memory == max_lock_memory);
/* create tests. */ /* create tests. */
{ {
r = toku_lt_create(NULL, dbpanic, ltm, r = toku_lt_create(NULL, dbpanic, ltm, get_compare_fun_from_db);
get_compare_fun_from_db,
toku_malloc, toku_free, toku_realloc);
CKERR2(r, EINVAL); CKERR2(r, EINVAL);
r = toku_lt_create(&lt, NULL, ltm, r = toku_lt_create(&lt, NULL, ltm, get_compare_fun_from_db);
get_compare_fun_from_db,
toku_malloc, toku_free, toku_realloc);
CKERR2(r, EINVAL); CKERR2(r, EINVAL);
r = toku_lt_create(&lt, dbpanic, NULL, r = toku_lt_create(&lt, dbpanic, NULL, get_compare_fun_from_db);
get_compare_fun_from_db,
toku_malloc, toku_free, toku_realloc);
CKERR2(r, EINVAL); CKERR2(r, EINVAL);
r = toku_lt_create(&lt, dbpanic, ltm, r = toku_lt_create(&lt, dbpanic, ltm, NULL);
NULL,
toku_malloc, toku_free, toku_realloc);
CKERR2(r, EINVAL);
r = toku_lt_create(&lt, dbpanic, ltm,
get_compare_fun_from_db,
NULL, toku_free, toku_realloc);
CKERR2(r, EINVAL);
r = toku_lt_create(&lt, dbpanic, ltm,
get_compare_fun_from_db,
toku_malloc, NULL, toku_realloc);
CKERR2(r, EINVAL);
r = toku_lt_create(&lt, dbpanic, ltm,
get_compare_fun_from_db,
toku_malloc, toku_free, NULL);
CKERR2(r, EINVAL); CKERR2(r, EINVAL);
} }
......
src/lock_tree/tests/test_00020_read.c
View file @ 35a46f2e
...@@ -10,7 +10,7 @@ TXNID txn = (TXNID)1; ...@@ -10,7 +10,7 @@ TXNID txn = (TXNID)1;
enum { MAX_LT_LOCKS = 1000 }; enum { MAX_LT_LOCKS = 1000 };
uint32_t max_locks = MAX_LT_LOCKS; uint32_t max_locks = MAX_LT_LOCKS;
uint64_t max_lock_memory = MAX_LT_LOCKS*64; uint64_t max_lock_memory = MAX_LT_LOCKS*64;
BOOL duplicates = FALSE; bool duplicates = false;
int nums[100]; int nums[100];
DBT _keys_left[2]; DBT _keys_left[2];
...@@ -42,25 +42,20 @@ static void init_query(void) { ...@@ -42,25 +42,20 @@ static void init_query(void) {
static void setup_tree(void) { static void setup_tree(void) {
assert(!lt && !ltm); assert(!lt && !ltm);
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
get_compare_fun_from_db,
toku_malloc, toku_free, toku_realloc);
CKERR(r); CKERR(r);
assert(ltm); assert(ltm);
r = toku_lt_create(&lt, dbpanic, ltm, r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
get_compare_fun_from_db,
toku_malloc, toku_free, toku_realloc);
CKERR(r); CKERR(r);
assert(lt); assert(lt);
init_query(); init_query();
} }
static void close_tree(void) { static void close_tree(void) {
r = toku_lt_unlock(lt, txn); CKERR(r);
assert(lt && ltm); assert(lt && ltm);
r = toku_lt_close(lt); r = toku_lt_close(lt); CKERR(r);
CKERR(r); r = toku_ltm_close(ltm); CKERR(r);
r = toku_ltm_close(ltm);
CKERR(r);
lt = NULL; lt = NULL;
ltm = NULL; ltm = NULL;
} }
...@@ -139,7 +134,7 @@ temporarily_fake_comparison_functions(); ...@@ -139,7 +134,7 @@ temporarily_fake_comparison_functions();
toku_lt_point_cmp(buf[i].ends.right, &right) == 0 && toku_lt_point_cmp(buf[i].ends.right, &right) == 0 &&
buf[i].data == find_txn) { goto cleanup; } buf[i].data == find_txn) { goto cleanup; }
} }
assert(FALSE); //Crash since we didn't find it. assert(false); //Crash since we didn't find it.
cleanup: cleanup:
stop_fake_comparison_functions(); stop_fake_comparison_functions();
} }
...@@ -159,13 +154,11 @@ static void insert_1(int key_l, int key_r, ...@@ -159,13 +154,11 @@ static void insert_1(int key_l, int key_r,
setup_tree(); setup_tree();
r = toku_lt_acquire_range_read_lock(lt, db, txn, key_left, key_right); r = toku_lt_acquire_range_read_lock(lt, db, txn, key_left, key_right); CKERR(r);
CKERR(r);
close_tree(); close_tree();
setup_tree(); setup_tree();
r = toku_lt_acquire_read_lock(lt, db, txn, key_left); r = toku_lt_acquire_read_lock(lt, db, txn, key_left); CKERR(r);
CKERR(r);
close_tree(); close_tree();
} }
......
src/lock_tree/tests/test_00030_rth.c
View file @ 35a46f2e
...@@ -8,27 +8,11 @@ int main(int argc, const char *argv[]) { ...@@ -8,27 +8,11 @@ int main(int argc, const char *argv[]) {
int r; int r;
parse_args(argc, argv); parse_args(argc, argv);
/* ********************************************************************** */
rth = NULL;
for (failon = 1; failon <= 2; failon++) {
mallocced = 0;
r = toku_rth_create(&rth, fail_malloc, toku_free, toku_realloc);
CKERR2(r, ENOMEM);
assert(rth==NULL);
}
r = toku_rth_create(&rth, toku_malloc, toku_free, toku_realloc);
CKERR(r);
assert(rth);
toku_rth_close(rth);
rth = NULL;
/* ********************************************************************** */
size_t i; size_t i;
size_t iterations = 512 << 2; size_t iterations = 512 << 2;
r = toku_rth_create(&rth, toku_malloc, toku_free, toku_realloc); r = toku_rth_create(&rth);
CKERR(r); CKERR(r);
assert(rth); assert(rth);
for (i = 1; i < iterations; i++) { for (i = 1; i < iterations; i++) {
...@@ -50,7 +34,7 @@ int main(int argc, const char *argv[]) { ...@@ -50,7 +34,7 @@ int main(int argc, const char *argv[]) {
/* ********************************************************************** */ /* ********************************************************************** */
r = toku_rth_create(&rth, toku_malloc, toku_free, toku_realloc); r = toku_rth_create(&rth);
CKERR(r); CKERR(r);
assert(rth); assert(rth);
for (i = 1; i < iterations; i++) { for (i = 1; i < iterations; i++) {
...@@ -65,7 +49,7 @@ int main(int argc, const char *argv[]) { ...@@ -65,7 +49,7 @@ int main(int argc, const char *argv[]) {
/* ********************************************************************** */ /* ********************************************************************** */
r = toku_rth_create(&rth, toku_malloc, toku_free, toku_realloc); r = toku_rth_create(&rth);
CKERR(r); CKERR(r);
assert(rth); assert(rth);
for (i = iterations - 1; i >= 1; i--) { for (i = iterations - 1; i >= 1; i--) {
...@@ -75,19 +59,9 @@ int main(int argc, const char *argv[]) { ...@@ -75,19 +59,9 @@ int main(int argc, const char *argv[]) {
toku_rth_close(rth); toku_rth_close(rth);
rth = NULL; rth = NULL;
failon = 3;
mallocced = 0;
r = toku_rth_create(&rth, fail_malloc, toku_free, toku_realloc);
CKERR(r);
assert(rth);
r = toku_rth_insert(rth, (TXNID)1);
CKERR2(r, ENOMEM);
toku_rth_close(rth);
rth = NULL;
/* ********************************************************************** */ /* ********************************************************************** */
r = toku_rth_create(&rth, toku_malloc, toku_free, toku_realloc); r = toku_rth_create(&rth);
CKERR(r); CKERR(r);
assert(rth); assert(rth);
for (i = iterations - 1; i >= 1; i--) { for (i = iterations - 1; i >= 1; i--) {
......
src/lock_tree/tests/test_00040_write.c
View file @ 35a46f2e
...@@ -36,14 +36,10 @@ static void init_query(void) { ...@@ -36,14 +36,10 @@ static void init_query(void) {
static void setup_tree(void) { static void setup_tree(void) {
assert(!lt && !ltm); assert(!lt && !ltm);
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
get_compare_fun_from_db,
toku_malloc, toku_free, toku_realloc);
CKERR(r); CKERR(r);
assert(ltm); assert(ltm);
r = toku_lt_create(&lt, dbpanic, ltm, r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
get_compare_fun_from_db,
toku_malloc, toku_free, toku_realloc);
CKERR(r); CKERR(r);
assert(lt); assert(lt);
init_query(); init_query();
...@@ -71,7 +67,7 @@ static DBT* set_to_infty(DBT *dbt, int value) { ...@@ -71,7 +67,7 @@ static DBT* set_to_infty(DBT *dbt, int value) {
static void lt_insert(int r_expect, char txn, int key_l, static void lt_insert(int r_expect, char txn, int key_l,
int key_r, BOOL read_flag) { int key_r, bool read_flag) {
DBT _key_left; DBT _key_left;
DBT _key_right; DBT _key_right;
DBT* key_left = &_key_left; DBT* key_left = &_key_left;
...@@ -96,11 +92,11 @@ static void lt_insert(int r_expect, char txn, int key_l, ...@@ -96,11 +92,11 @@ static void lt_insert(int r_expect, char txn, int key_l,
} }
static void lt_insert_read(int r_expect, char txn, int key_l, int key_r) { static void lt_insert_read(int r_expect, char txn, int key_l, int key_r) {
lt_insert(r_expect, txn, key_l, key_r, TRUE); lt_insert(r_expect, txn, key_l, key_r, true);
} }
static void lt_insert_write(int r_expect, char txn, int key_l) { static void lt_insert_write(int r_expect, char txn, int key_l) {
lt_insert(r_expect, txn, key_l, 0, FALSE); lt_insert(r_expect, txn, key_l, 0, false);
} }
...@@ -120,37 +116,45 @@ static void runtest(void) { ...@@ -120,37 +116,45 @@ static void runtest(void) {
toku_lt_verify(lt, NULL); toku_lt_verify(lt, NULL);
lt_insert_write(0, 'b', 10); lt_insert_write(0, 'b', 10);
toku_lt_verify(lt, NULL); toku_lt_verify(lt, NULL);
lt_unlock('a');
lt_unlock('b');
close_tree(); close_tree();
/* ********************* */ /* ********************* */
setup_tree(); setup_tree();
lt_insert_write(0, 'a', 1); lt_insert_write(0, 'a', 1);
lt_unlock('a');
close_tree(); close_tree();
/* ********************* */ /* ********************* */
setup_tree(); setup_tree();
lt_insert_write(0, 'a', 2); lt_insert_write(0, 'a', 2);
lt_insert_write(0, 'a', 1); lt_insert_write(0, 'a', 1);
lt_unlock('a');
close_tree(); close_tree();
/* ********************* */ /* ********************* */
setup_tree(); setup_tree();
lt_insert_write(0, 'a', 1); lt_insert_write(0, 'a', 1);
lt_insert_write(0, 'a', 2); lt_insert_write(0, 'a', 2);
lt_insert_write(0, 'a', 1); lt_insert_write(0, 'a', 1);
lt_unlock('a');
close_tree(); close_tree();
/* ********************* */ /* ********************* */
setup_tree(); setup_tree();
lt_insert_write(0, 'a', 1); lt_insert_write(0, 'a', 1);
lt_insert_read (0, 'a', 1, 1); lt_insert_read (0, 'a', 1, 1);
lt_unlock('a');
close_tree(); close_tree();
/* ********************* */ /* ********************* */
setup_tree(); setup_tree();
lt_insert_write(0, 'a', 1); lt_insert_write(0, 'a', 1);
lt_insert_read (DB_LOCK_NOTGRANTED, 'b', 1, 1); lt_insert_read (DB_LOCK_NOTGRANTED, 'b', 1, 1);
lt_unlock('a');
close_tree(); close_tree();
/* ********************* */ /* ********************* */
setup_tree(); setup_tree();
lt_insert_read (0, 'b', 1, 1); lt_insert_read (0, 'b', 1, 1);
lt_insert_write(DB_LOCK_NOTGRANTED, 'a', 1); lt_insert_write(DB_LOCK_NOTGRANTED, 'a', 1);
lt_unlock('b');
close_tree(); close_tree();
/* ********************* */ /* ********************* */
setup_tree(); setup_tree();
...@@ -160,6 +164,7 @@ static void runtest(void) { ...@@ -160,6 +164,7 @@ static void runtest(void) {
lt_insert_write(0, 'a', 4); lt_insert_write(0, 'a', 4);
lt_insert_write(0, 'a', 5); lt_insert_write(0, 'a', 5);
lt_insert_read (DB_LOCK_NOTGRANTED, 'b', 2, 4); lt_insert_read (DB_LOCK_NOTGRANTED, 'b', 2, 4);
lt_unlock('a');
close_tree(); close_tree();
/* ********************* */ /* ********************* */
setup_tree(); setup_tree();
...@@ -169,6 +174,7 @@ static void runtest(void) { ...@@ -169,6 +174,7 @@ static void runtest(void) {
lt_insert_write(0, 'a', 4); lt_insert_write(0, 'a', 4);
lt_insert_write(0, 'a', 5); lt_insert_write(0, 'a', 5);
lt_insert_write (DB_LOCK_NOTGRANTED, 'b', 2); lt_insert_write (DB_LOCK_NOTGRANTED, 'b', 2);
lt_unlock('a');
close_tree(); close_tree();
/* ********************* */ /* ********************* */
setup_tree(); setup_tree();
...@@ -177,6 +183,8 @@ static void runtest(void) { ...@@ -177,6 +183,8 @@ static void runtest(void) {
lt_insert_write(0, 'a', 4); lt_insert_write(0, 'a', 4);
lt_insert_write(0, 'a', 5); lt_insert_write(0, 'a', 5);
lt_insert_read (0, 'b', 3, 3); lt_insert_read (0, 'b', 3, 3);
lt_unlock('a');
lt_unlock('b');
close_tree(); close_tree();
/* ********************* */ /* ********************* */
setup_tree(); setup_tree();
...@@ -185,6 +193,8 @@ static void runtest(void) { ...@@ -185,6 +193,8 @@ static void runtest(void) {
lt_insert_write(0, 'a', 4); lt_insert_write(0, 'a', 4);
lt_insert_write(0, 'a', 5); lt_insert_write(0, 'a', 5);
lt_insert_read (0, 'b', 3, 3); lt_insert_read (0, 'b', 3, 3);
lt_unlock('a');
lt_unlock('b');
close_tree(); close_tree();
/* ********************* */ /* ********************* */
setup_tree(); setup_tree();
...@@ -198,6 +208,8 @@ static void runtest(void) { ...@@ -198,6 +208,8 @@ static void runtest(void) {
lt_insert_write(0, 'a', 8); lt_insert_write(0, 'a', 8);
lt_insert_write(0, 'a', 9); lt_insert_write(0, 'a', 9);
lt_insert_read (DB_LOCK_NOTGRANTED, 'a', 3, 7); lt_insert_read (DB_LOCK_NOTGRANTED, 'a', 3, 7);
lt_unlock('a');
lt_unlock('b');
close_tree(); close_tree();
/* ********************* */ /* ********************* */
setup_tree(); setup_tree();
...@@ -211,6 +223,7 @@ static void runtest(void) { ...@@ -211,6 +223,7 @@ static void runtest(void) {
lt_insert_write(0, 'b', 8); lt_insert_write(0, 'b', 8);
lt_insert_write(0, 'b', 9); lt_insert_write(0, 'b', 9);
lt_insert_read (DB_LOCK_NOTGRANTED, 'a', 3, 7); lt_insert_read (DB_LOCK_NOTGRANTED, 'a', 3, 7);
lt_unlock('b');
close_tree(); close_tree();
/* ********************* */ /* ********************* */
setup_tree(); setup_tree();
...@@ -219,6 +232,7 @@ static void runtest(void) { ...@@ -219,6 +232,7 @@ static void runtest(void) {
lt_insert_write(0, 'a', 3); lt_insert_write(0, 'a', 3);
lt_insert_write(0, 'a', 4); lt_insert_write(0, 'a', 4);
lt_insert_read (0, 'a', 3, 7); lt_insert_read (0, 'a', 3, 7);
lt_unlock('a');
close_tree(); close_tree();
/* ********************* */ /* ********************* */
setup_tree(); setup_tree();
...@@ -227,6 +241,7 @@ static void runtest(void) { ...@@ -227,6 +241,7 @@ static void runtest(void) {
lt_insert_write(0, 'b', 3); lt_insert_write(0, 'b', 3);
lt_insert_write(0, 'b', 4); lt_insert_write(0, 'b', 4);
lt_insert_read (DB_LOCK_NOTGRANTED, 'a', 3, 7); lt_insert_read (DB_LOCK_NOTGRANTED, 'a', 3, 7);
lt_unlock('b');
close_tree(); close_tree();
/* ********************* */ /* ********************* */
setup_tree(); setup_tree();
...@@ -235,6 +250,7 @@ static void runtest(void) { ...@@ -235,6 +250,7 @@ static void runtest(void) {
lt_insert_write(0, 'a', 4); lt_insert_write(0, 'a', 4);
lt_insert_write(0, 'a', 5); lt_insert_write(0, 'a', 5);
lt_insert_write(0, 'a', 3); lt_insert_write(0, 'a', 3);
lt_unlock('a');
close_tree(); close_tree();
/* ********************* */ /* ********************* */
setup_tree(); setup_tree();
...@@ -243,6 +259,8 @@ static void runtest(void) { ...@@ -243,6 +259,8 @@ static void runtest(void) {
lt_insert_write(0, 'b', 4); lt_insert_write(0, 'b', 4);
lt_insert_write(0, 'b', 5); lt_insert_write(0, 'b', 5);
lt_insert_write(0, 'a', 3); lt_insert_write(0, 'a', 3);
lt_unlock('a');
lt_unlock('b');
close_tree(); close_tree();
/* ********************* */ /* ********************* */
setup_tree(); setup_tree();
...@@ -256,6 +274,7 @@ static void runtest(void) { ...@@ -256,6 +274,7 @@ static void runtest(void) {
lt_insert_read (DB_LOCK_NOTGRANTED, 'a', 3, 3); lt_insert_read (DB_LOCK_NOTGRANTED, 'a', 3, 3);
lt_unlock('b'); lt_unlock('b');
lt_insert_read (0, 'a', 3, 3); lt_insert_read (0, 'a', 3, 3);
lt_unlock('a');
close_tree(); close_tree();
/* ********************* */ /* ********************* */
setup_tree(); setup_tree();
...@@ -263,6 +282,7 @@ static void runtest(void) { ...@@ -263,6 +282,7 @@ static void runtest(void) {
lt_insert_write(0, 'a', 3); lt_insert_write(0, 'a', 3);
lt_insert_write(0, 'b', 2); lt_insert_write(0, 'b', 2);
lt_unlock('b'); lt_unlock('b');
lt_unlock('a');
close_tree(); close_tree();
/* ********************* */ /* ********************* */
} }
......
src/lock_tree/tests/test_00050_lth.c
View file @ 35a46f2e
...@@ -8,15 +8,8 @@ int main(int argc, const char *argv[]) { ...@@ -8,15 +8,8 @@ int main(int argc, const char *argv[]) {
int r; int r;
parse_args(argc, argv); parse_args(argc, argv);
lth = NULL; lth = NULL;
for (failon = 1; failon <= 2; failon++) { r = toku_lth_create(&lth);
mallocced = 0;
r = toku_lth_create(&lth, fail_malloc, toku_free, toku_realloc);
CKERR2(r, ENOMEM);
assert(lth==NULL);
}
r = toku_lth_create(&lth, toku_malloc, toku_free, toku_realloc);
CKERR(r); CKERR(r);
assert(lth); assert(lth);
toku_lth_close(lth); toku_lth_close(lth);
...@@ -25,7 +18,7 @@ int main(int argc, const char *argv[]) { ...@@ -25,7 +18,7 @@ int main(int argc, const char *argv[]) {
size_t i; size_t i;
size_t iterations = 512 << 2; size_t iterations = 512 << 2;
r = toku_lth_create(&lth, toku_malloc, toku_free, toku_realloc); r = toku_lth_create(&lth);
CKERR(r); CKERR(r);
assert(lth); assert(lth);
for (i = 1; i < iterations; i++) { for (i = 1; i < iterations; i++) {
...@@ -54,7 +47,7 @@ int main(int argc, const char *argv[]) { ...@@ -54,7 +47,7 @@ int main(int argc, const char *argv[]) {
toku_lth_close(lth); toku_lth_close(lth);
lth = NULL; lth = NULL;
r = toku_lth_create(&lth, toku_malloc, toku_free, toku_realloc); r = toku_lth_create(&lth);
CKERR(r); CKERR(r);
assert(lth); assert(lth);
for (i = 1; i < iterations; i++) { for (i = 1; i < iterations; i++) {
...@@ -68,7 +61,7 @@ int main(int argc, const char *argv[]) { ...@@ -68,7 +61,7 @@ int main(int argc, const char *argv[]) {
lth = NULL; lth = NULL;
r = toku_lth_create(&lth, toku_malloc, toku_free, toku_realloc); r = toku_lth_create(&lth);
CKERR(r); CKERR(r);
assert(lth); assert(lth);
for (i = iterations - 1; i >= 1; i--) { for (i = iterations - 1; i >= 1; i--) {
...@@ -78,14 +71,5 @@ int main(int argc, const char *argv[]) { ...@@ -78,14 +71,5 @@ int main(int argc, const char *argv[]) {
toku_lth_close(lth); toku_lth_close(lth);
lth = NULL; lth = NULL;
failon = 3;
mallocced = 0;
r = toku_lth_create(&lth, fail_malloc, toku_free, toku_realloc);
CKERR(r);
assert(lth);
r = toku_lth_insert(lth, (toku_lock_tree*)1);
CKERR2(r, ENOMEM);
toku_lth_close(lth);
lth = NULL;
return 0; return 0;
} }
src/lock_tree/tests/test_00060_lock_escalation.c
View file @ 35a46f2e
...@@ -8,8 +8,8 @@ toku_ltm* ltm = NULL; ...@@ -8,8 +8,8 @@ toku_ltm* ltm = NULL;
DB* db = (DB*)1; DB* db = (DB*)1;
enum { MAX_LT_LOCKS = 10 }; enum { MAX_LT_LOCKS = 10 };
uint32_t max_locks = MAX_LT_LOCKS; uint32_t max_locks = MAX_LT_LOCKS;
uint64_t max_lock_memory = MAX_LT_LOCKS*64; uint64_t max_lock_memory = MAX_LT_LOCKS*256;
BOOL duplicates = FALSE; bool duplicates = false;
int nums[10000]; int nums[10000];
DBT _keys_left[2]; DBT _keys_left[2];
...@@ -37,9 +37,7 @@ static void init_query(void) { ...@@ -37,9 +37,7 @@ static void init_query(void) {
static void setup_tree(void) { static void setup_tree(void) {
assert(!lt && !ltm); assert(!lt && !ltm);
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
get_compare_fun_from_db,
toku_malloc, toku_free, toku_realloc);
CKERR(r); CKERR(r);
assert(ltm); assert(ltm);
//ask ltm for lock tree //ask ltm for lock tree
...@@ -67,12 +65,12 @@ static DBT* set_to_infty(DBT *dbt, int value) { ...@@ -67,12 +65,12 @@ static DBT* set_to_infty(DBT *dbt, int value) {
if (value == infinite) return (DBT*)toku_lt_infinity; if (value == infinite) return (DBT*)toku_lt_infinity;
if (value == neg_infinite) return (DBT*)toku_lt_neg_infinity; if (value == neg_infinite) return (DBT*)toku_lt_neg_infinity;
if (value == null) return dbt_init(dbt, NULL, 0); if (value == null) return dbt_init(dbt, NULL, 0);
assert(value >= 0); assert(0 <= value && (unsigned) value < sizeof nums / sizeof nums[0]);
return dbt_init(dbt, &nums[value], sizeof(nums[0])); return dbt_init(dbt, &nums[value], sizeof(nums[0]));
} }
static void lt_insert(int r_expect, char txn, int key_l, int key_r, BOOL read_flag) { static void lt_insert(int r_expect, char txn, int key_l, int key_r, bool read_flag) {
DBT _key_left; DBT _key_left;
DBT _key_right; DBT _key_right;
DBT* key_left = &_key_left; DBT* key_left = &_key_left;
...@@ -88,26 +86,29 @@ static void lt_insert(int r_expect, char txn, int key_l, int key_r, BOOL read_fl ...@@ -88,26 +86,29 @@ static void lt_insert(int r_expect, char txn, int key_l, int key_r, BOOL read_fl
TXNID local_txn = (TXNID) (size_t) txn; TXNID local_txn = (TXNID) (size_t) txn;
if (read_flag) if (read_flag)
r = toku_lt_acquire_range_read_lock(lt, db, local_txn, r = toku_lt_acquire_range_read_lock(lt, db, local_txn, key_left, key_right);
key_left,
key_right);
else else
r = toku_lt_acquire_write_lock(lt, db, local_txn, key_left); r = toku_lt_acquire_write_lock(lt, db, local_txn, key_left);
CKERR2(r, r_expect); CKERR2(r, r_expect);
} }
static int lt_insert_write_no_check(char txn, int key_p) {
DBT key;
TXNID local_txn = (TXNID) (size_t) txn;
r = toku_lt_acquire_write_lock(lt, db, local_txn, dbt_init(&key, &nums[key_p], sizeof(nums[0])));
return r;
}
static void lt_insert_read(int r_expect, char txn, int key_l, int key_r) { static void lt_insert_read(int r_expect, char txn, int key_l, int key_r) {
lt_insert(r_expect, txn, key_l, key_r, TRUE); lt_insert(r_expect, txn, key_l, key_r, true);
} }
static void lt_insert_write(int r_expect, char txn, int key_l) { static void lt_insert_write(int r_expect, char txn, int key_l) {
lt_insert(r_expect, txn, key_l, 0, FALSE); lt_insert(r_expect, txn, key_l, 0, false);
} }
static void lt_unlock(char ctxn) { static void lt_unlock(char ctxn) {
int retval; int retval = toku_lt_unlock(lt, (TXNID) (size_t) ctxn); CKERR(retval);
retval = toku_lt_unlock(lt, (TXNID) (size_t) ctxn);
CKERR(retval);
} }
static void run_escalation_test(void) { static void run_escalation_test(void) {
...@@ -120,6 +121,7 @@ static void run_escalation_test(void) { ...@@ -120,6 +121,7 @@ static void run_escalation_test(void) {
lt_insert_write(0, 'a', i); lt_insert_write(0, 'a', i);
assert(lt->lock_escalation_allowed); assert(lt->lock_escalation_allowed);
} }
lt_unlock('a');
close_tree(); close_tree();
/* ******************** */ /* ******************** */
/* interleaving transactions, /* interleaving transactions,
...@@ -128,17 +130,19 @@ static void run_escalation_test(void) { ...@@ -128,17 +130,19 @@ static void run_escalation_test(void) {
make sure lock escalation fails, and that we run out of locks */ make sure lock escalation fails, and that we run out of locks */
setup_tree(); setup_tree();
// this should grab ten locks successfully // this should grab ten locks successfully
for (i = 1; i < 10; i+=2) { for (i = 1; i < 20; i++) {
lt_insert_write(0, 'a', i); r = lt_insert_write_no_check(i&1 ? 'a' : 'b', i);
lt_insert_write(0, 'b', i+1); if (r != 0)
break;
} }
lt_insert_write(TOKUDB_OUT_OF_LOCKS, 'a', 100); lt_insert_write(TOKUDB_OUT_OF_LOCKS, 'a', 100);
lt_insert_write(TOKUDB_OUT_OF_LOCKS, 'b', 100); lt_insert_write(TOKUDB_OUT_OF_LOCKS, 'b', 100);
lt_insert_write(TOKUDB_OUT_OF_LOCKS, 'c', 100); lt_insert_write(TOKUDB_OUT_OF_LOCKS, 'c', 100);
lt_unlock('a'); lt_unlock('b');
close_tree(); close_tree();
/* ******************** */ /* ******************** */
/* /*
test that escalation allowed flag goes from FALSE->TRUE->FALSE test that escalation allowed flag goes from false->true->FALSE
TXN A grabs 1 3 5 7 9 TXN A grabs 1 3 5 7 9
TXN B grabs 2 4 6 8 10 TXN B grabs 2 4 6 8 10
try to grab another lock, fail, lock escalation should be disabled try to grab another lock, fail, lock escalation should be disabled
...@@ -150,9 +154,10 @@ static void run_escalation_test(void) { ...@@ -150,9 +154,10 @@ static void run_escalation_test(void) {
setup_tree(); setup_tree();
assert(lt->lock_escalation_allowed); assert(lt->lock_escalation_allowed);
// this should grab ten locks successfully // this should grab ten locks successfully
for (i = 1; i < 10; i+=2) { for (i = 1; i < 20; i++) {
lt_insert_write(0, 'a', i); r = lt_insert_write_no_check(i&1 ? 'a' : 'b', i);
lt_insert_write(0, 'b', i+1); if (r != 0)
break;
} }
assert(lt->lock_escalation_allowed); assert(lt->lock_escalation_allowed);
lt_insert_write(TOKUDB_OUT_OF_LOCKS, 'a', 100); lt_insert_write(TOKUDB_OUT_OF_LOCKS, 'a', 100);
...@@ -167,6 +172,7 @@ static void run_escalation_test(void) { ...@@ -167,6 +172,7 @@ static void run_escalation_test(void) {
lt_insert_write(0, 'c', i); lt_insert_write(0, 'c', i);
assert(lt->lock_escalation_allowed); assert(lt->lock_escalation_allowed);
} }
lt_unlock('a'); lt_unlock('c');
close_tree(); close_tree();
/* ******************** */ /* ******************** */
/* /*
...@@ -196,6 +202,7 @@ static void run_escalation_test(void) { ...@@ -196,6 +202,7 @@ static void run_escalation_test(void) {
lt_insert_write(0, 'c', i); lt_insert_write(0, 'c', i);
assert(lt->lock_escalation_allowed); assert(lt->lock_escalation_allowed);
} }
lt_unlock('a'); lt_unlock('c');
close_tree(); close_tree();
/* ******************** */ /* ******************** */
#if 0 //Only use when messy transactions are enabled. #if 0 //Only use when messy transactions are enabled.
...@@ -234,6 +241,7 @@ static void run_escalation_test(void) { ...@@ -234,6 +241,7 @@ static void run_escalation_test(void) {
lt_insert_write(0, 'a', i); lt_insert_write(0, 'a', i);
} }
lt_insert_read(0, 'a', 10, 10); lt_insert_read(0, 'a', 10, 10);
lt_unlock('a');
close_tree(); close_tree();
/* ******************** */ /* ******************** */
/* escalate on read lock of different transaction. */ /* escalate on read lock of different transaction. */
...@@ -242,6 +250,7 @@ static void run_escalation_test(void) { ...@@ -242,6 +250,7 @@ static void run_escalation_test(void) {
lt_insert_write(0, 'a', i); lt_insert_write(0, 'a', i);
} }
lt_insert_read(0, 'b', 10, 10); lt_insert_read(0, 'b', 10, 10);
lt_unlock('a'); lt_unlock('b');
close_tree(); close_tree();
/* ******************** */ /* ******************** */
/* txn A grabs write lock 0,9 /* txn A grabs write lock 0,9
...@@ -257,6 +266,7 @@ static void run_escalation_test(void) { ...@@ -257,6 +266,7 @@ static void run_escalation_test(void) {
lt_insert_write(0, 'b', i); lt_insert_write(0, 'b', i);
assert(lt->lock_escalation_allowed); assert(lt->lock_escalation_allowed);
} }
lt_unlock('a'); lt_unlock('b');
close_tree(); close_tree();
/* ******************** */ /* ******************** */
/* [1-A-5] [10-B-15] [20-A-25] BORDER WRITE /* [1-A-5] [10-B-15] [20-A-25] BORDER WRITE
...@@ -280,6 +290,7 @@ static void run_escalation_test(void) { ...@@ -280,6 +290,7 @@ static void run_escalation_test(void) {
lt_insert_write(DB_LOCK_NOTGRANTED, 'b', 24); lt_insert_write(DB_LOCK_NOTGRANTED, 'b', 24);
lt_insert_write(0, 'a', 14); lt_insert_write(0, 'a', 14);
lt_insert_write(0, 'b', 4); lt_insert_write(0, 'b', 4);
lt_unlock('a'); lt_unlock('b');
close_tree(); close_tree();
/* ******************** */ /* ******************** */
/* Test read lock escalation, no writes. */ /* Test read lock escalation, no writes. */
...@@ -288,6 +299,7 @@ static void run_escalation_test(void) { ...@@ -288,6 +299,7 @@ static void run_escalation_test(void) {
for (i = 0; i < 1000; i ++) { for (i = 0; i < 1000; i ++) {
lt_insert_read (0, 'b', i, i); lt_insert_read (0, 'b', i, i);
} }
lt_unlock('b');
close_tree(); close_tree();
/* ******************** */ /* ******************** */
/* Test read lock escalation, writes of same kind. */ /* Test read lock escalation, writes of same kind. */
...@@ -298,6 +310,7 @@ static void run_escalation_test(void) { ...@@ -298,6 +310,7 @@ static void run_escalation_test(void) {
for (i = 0; i < 1000; i ++) { for (i = 0; i < 1000; i ++) {
lt_insert_read (0, 'b', i, i); lt_insert_read (0, 'b', i, i);
} }
lt_unlock('b');
close_tree(); close_tree();
/* ******************** */ /* ******************** */
/* Test read lock escalation, writes of other kind. */ /* Test read lock escalation, writes of other kind. */
...@@ -312,6 +325,7 @@ static void run_escalation_test(void) { ...@@ -312,6 +325,7 @@ static void run_escalation_test(void) {
if (i % 5 == 0) { continue; } if (i % 5 == 0) { continue; }
lt_insert_read (0, 'a', i, i); lt_insert_read (0, 'a', i, i);
} }
lt_unlock('a'); lt_unlock('b'); lt_unlock('c');
close_tree(); close_tree();
/* ******************** */ /* ******************** */
/* /*
...@@ -320,7 +334,7 @@ static void run_escalation_test(void) { ...@@ -320,7 +334,7 @@ static void run_escalation_test(void) {
txn C attempts to grab lock, escalation, and lock grab, should fail txn C attempts to grab lock, escalation, and lock grab, should fail
lock lock
*/ */
/* #if 0
setup_tree(); setup_tree();
assert(lt->lock_escalation_allowed); assert(lt->lock_escalation_allowed);
// this should grab ten locks successfully // this should grab ten locks successfully
...@@ -346,7 +360,7 @@ static void run_escalation_test(void) { ...@@ -346,7 +360,7 @@ static void run_escalation_test(void) {
assert(lt->lock_escalation_allowed); assert(lt->lock_escalation_allowed);
} }
close_tree(); close_tree();
*/ #endif
/* ******************** */ /* ******************** */
} }
......
src/lock_tree/tests/test_00070_ltm.c
View file @ 35a46f2e
...@@ -17,9 +17,7 @@ int nums[10000]; ...@@ -17,9 +17,7 @@ int nums[10000];
static void setup_ltm(void) { static void setup_ltm(void) {
assert(!ltm); assert(!ltm);
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
get_compare_fun_from_db,
toku_malloc, toku_free, toku_realloc);
CKERR(r); CKERR(r);
assert(ltm); assert(ltm);
} }
......
src/lock_tree/tests/test_00080_lt_refcount.c
View file @ 35a46f2e
...@@ -20,9 +20,7 @@ int nums[10000]; ...@@ -20,9 +20,7 @@ int nums[10000];
static void setup_ltm(void) { static void setup_ltm(void) {
assert(!ltm); assert(!ltm);
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
get_compare_fun_from_db,
toku_malloc, toku_free, toku_realloc);
CKERR(r); CKERR(r);
assert(ltm); assert(ltm);
} }
......
src/lock_tree/tests/test_borderwrite_merge.c
View file @ 35a46f2e
...@@ -36,14 +36,10 @@ static void init_query(void) { ...@@ -36,14 +36,10 @@ static void init_query(void) {
static void setup_tree(void) { static void setup_tree(void) {
assert(!lt && !ltm); assert(!lt && !ltm);
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
get_compare_fun_from_db,
toku_malloc, toku_free, toku_realloc);
CKERR(r); CKERR(r);
assert(ltm); assert(ltm);
r = toku_lt_create(&lt, dbpanic, ltm, r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
get_compare_fun_from_db,
toku_malloc, toku_free, toku_realloc);
CKERR(r); CKERR(r);
assert(lt); assert(lt);
init_query(); init_query();
...@@ -90,6 +86,10 @@ static void lt_insert_write_range(int r_expect, char txn, int key_l, int key_r) ...@@ -90,6 +86,10 @@ static void lt_insert_write_range(int r_expect, char txn, int key_l, int key_r)
lt_verify(); lt_verify();
} }
static void lt_unlock(TXNID txnid) {
r= toku_lt_unlock(lt, txnid); CKERR(r);
}
static void runtest(void) { static void runtest(void) {
setup_tree(); setup_tree();
lt_insert_write_range(0, 'a', 5, 15); lt_insert_write_range(0, 'a', 5, 15);
...@@ -98,6 +98,7 @@ static void runtest(void) { ...@@ -98,6 +98,7 @@ static void runtest(void) {
lt_insert_write_range(DB_LOCK_NOTGRANTED, 'b', k, k); lt_insert_write_range(DB_LOCK_NOTGRANTED, 'b', k, k);
for (int k = 5; k <= 20; k++) for (int k = 5; k <= 20; k++)
lt_insert_write_range(0, 'a', k, k); lt_insert_write_range(0, 'a', k, k);
lt_unlock('a');
close_tree(); close_tree();
setup_tree(); setup_tree();
...@@ -107,6 +108,7 @@ static void runtest(void) { ...@@ -107,6 +108,7 @@ static void runtest(void) {
lt_insert_write_range(DB_LOCK_NOTGRANTED, 'b', k, k); lt_insert_write_range(DB_LOCK_NOTGRANTED, 'b', k, k);
for (int k = 5; k <= 20; k++) for (int k = 5; k <= 20; k++)
lt_insert_write_range(0, 'a', k, k); lt_insert_write_range(0, 'a', k, k);
lt_unlock('a');
close_tree(); close_tree();
setup_tree(); setup_tree();
...@@ -115,18 +117,21 @@ static void runtest(void) { ...@@ -115,18 +117,21 @@ static void runtest(void) {
lt_insert_write_range(0, 'a', k, k); lt_insert_write_range(0, 'a', k, k);
for (int k = 10; k <= 20; k++) for (int k = 10; k <= 20; k++)
lt_insert_write_range(DB_LOCK_NOTGRANTED, 'b', k, k); lt_insert_write_range(DB_LOCK_NOTGRANTED, 'b', k, k);
lt_unlock('a');
close_tree(); close_tree();
setup_tree(); setup_tree();
lt_insert_write_range(0, 'a', 5, 10); lt_insert_write_range(0, 'a', 5, 10);
lt_insert_write_range(0, 'a', 20, 30); lt_insert_write_range(0, 'a', 20, 30);
lt_insert_write_range(0, 'a', 1, 8); lt_insert_write_range(0, 'a', 1, 8);
lt_unlock('a');
close_tree(); close_tree();
setup_tree(); setup_tree();
lt_insert_write_range(0, 'a', 5, 10); lt_insert_write_range(0, 'a', 5, 10);
lt_insert_write_range(0, 'a', 20, 30); lt_insert_write_range(0, 'a', 20, 30);
lt_insert_write_range(0, 'a', 25, 35); lt_insert_write_range(0, 'a', 25, 35);
lt_unlock('a');
close_tree(); close_tree();
} }
......
src/lock_tree/tests/test_conflict_read_table_write.c
View file @ 35a46f2e
...@@ -43,11 +43,11 @@ int main(int argc, const char *argv[]) { ...@@ -43,11 +43,11 @@ int main(int argc, const char *argv[]) {
// setup // setup
toku_ltm *ltm = NULL; toku_ltm *ltm = NULL;
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
assert(r == 0 && ltm); assert(r == 0 && ltm);
toku_lock_tree *lt = NULL; toku_lock_tree *lt = NULL;
r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
assert(r == 0 && lt); assert(r == 0 && lt);
DBT key_l; dbt_init(&key_l, "L", 1); DBT key_l; dbt_init(&key_l, "L", 1);
......
src/lock_tree/tests/test_conflict_read_write.c
View file @ 35a46f2e
...@@ -43,11 +43,11 @@ int main(int argc, const char *argv[]) { ...@@ -43,11 +43,11 @@ int main(int argc, const char *argv[]) {
// setup // setup
toku_ltm *ltm = NULL; toku_ltm *ltm = NULL;
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
assert(r == 0 && ltm); assert(r == 0 && ltm);
toku_lock_tree *lt = NULL; toku_lock_tree *lt = NULL;
r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
assert(r == 0 && lt); assert(r == 0 && lt);
DBT key_l; dbt_init(&key_l, "L", 1); DBT key_l; dbt_init(&key_l, "L", 1);
......
src/lock_tree/tests/test_conflict_write_read.c
View file @ 35a46f2e
...@@ -33,11 +33,11 @@ int main(int argc, const char *argv[]) { ...@@ -33,11 +33,11 @@ int main(int argc, const char *argv[]) {
// setup // setup
toku_ltm *ltm = NULL; toku_ltm *ltm = NULL;
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
assert(r == 0 && ltm); assert(r == 0 && ltm);
toku_lock_tree *lt = NULL; toku_lock_tree *lt = NULL;
r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
assert(r == 0 && lt); assert(r == 0 && lt);
const TXNID txn_a = 1; const TXNID txn_a = 1;
......
src/lock_tree/tests/test_conflict_write_table_read.c
View file @ 35a46f2e
...@@ -33,11 +33,11 @@ int main(int argc, const char *argv[]) { ...@@ -33,11 +33,11 @@ int main(int argc, const char *argv[]) {
// setup // setup
toku_ltm *ltm = NULL; toku_ltm *ltm = NULL;
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
assert(r == 0 && ltm); assert(r == 0 && ltm);
toku_lock_tree *lt = NULL; toku_lock_tree *lt = NULL;
r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
assert(r == 0 && lt); assert(r == 0 && lt);
DBT key_l; dbt_init(&key_l, "L", 1); DBT key_l; dbt_init(&key_l, "L", 1);
......
src/lock_tree/tests/test_conflict_write_write.c
View file @ 35a46f2e
...@@ -33,11 +33,11 @@ int main(int argc, const char *argv[]) { ...@@ -33,11 +33,11 @@ int main(int argc, const char *argv[]) {
// setup // setup
toku_ltm *ltm = NULL; toku_ltm *ltm = NULL;
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
assert(r == 0 && ltm); assert(r == 0 && ltm);
toku_lock_tree *lt = NULL; toku_lock_tree *lt = NULL;
r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
assert(r == 0 && lt); assert(r == 0 && lt);
DBT key_l; dbt_init(&key_l, "L", 1); DBT key_l; dbt_init(&key_l, "L", 1);
......
src/lock_tree/tests/test_default_lock_timeout.c
View file @ 35a46f2e
...@@ -50,11 +50,11 @@ int main(int argc, const char *argv[]) { ...@@ -50,11 +50,11 @@ int main(int argc, const char *argv[]) {
// setup // setup
toku_ltm *ltm = NULL; toku_ltm *ltm = NULL;
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
assert(r == 0 && ltm); assert(r == 0 && ltm);
toku_lock_tree *lt = NULL; toku_lock_tree *lt = NULL;
r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
assert(r == 0 && lt); assert(r == 0 && lt);
const TXNID txn_a = 1; const TXNID txn_a = 1;
......
src/lock_tree/tests/test_default_timeout.c
View file @ 35a46f2e
...@@ -30,7 +30,7 @@ int main(int argc, const char *argv[]) { ...@@ -30,7 +30,7 @@ int main(int argc, const char *argv[]) {
// setup // setup
toku_ltm *ltm = NULL; toku_ltm *ltm = NULL;
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
assert(r == 0 && ltm); assert(r == 0 && ltm);
uint64_t target_wait_time, the_wait_time; uint64_t target_wait_time, the_wait_time;
......
src/lock_tree/tests/test_write_lock_memory.c → src/lock_tree/tests/test_footprint_point_write.c
View file @ 35a46f2e
...@@ -3,7 +3,18 @@ ...@@ -3,7 +3,18 @@
// //
// example: ./benchmark_point_write_locks.tlog --max_locks 1000000 --max_lock_memory 1000000000 --nrows 1000000 // example: ./benchmark_point_write_locks.tlog --max_locks 1000000 --max_lock_memory 1000000000 --nrows 1000000
#define TOKU_ALLOW_DEPRECATED
#include <malloc.h>
#include "test.h" #include "test.h"
#include <byteswap.h>
static uint64_t htonl64(uint64_t x) {
#if BYTE_ORDER == LITTLE_ENDIAN
return bswap_64(x);
#else
#error
#endif
}
struct my_ltm_status { struct my_ltm_status {
uint32_t max_locks, curr_locks; uint32_t max_locks, curr_locks;
...@@ -15,12 +26,32 @@ static void my_ltm_get_status(toku_ltm *ltm, struct my_ltm_status *my_status) { ...@@ -15,12 +26,32 @@ static void my_ltm_get_status(toku_ltm *ltm, struct my_ltm_status *my_status) {
toku_ltm_get_status(ltm, &my_status->max_locks, &my_status->curr_locks, &my_status->max_lock_memory, &my_status->curr_lock_memory, &my_status->status); toku_ltm_get_status(ltm, &my_status->max_locks, &my_status->curr_locks, &my_status->max_lock_memory, &my_status->curr_lock_memory, &my_status->status);
} }
static void *my_malloc(size_t s) {
void * p = malloc(s);
if (verbose)
printf("%s %lu %lu\n", __FUNCTION__, s, malloc_usable_size(p));
return p;
}
static void *my_realloc(void *p, size_t s) {
if (verbose)
printf("%s %p %lu\n", __FUNCTION__, p, s);
return realloc(p, s);
}
static void my_free(void *p) {
if (verbose)
printf("%s %p %lu\n", __FUNCTION__, p, malloc_usable_size(p));
free(p);
}
int main(int argc, const char *argv[]) { int main(int argc, const char *argv[]) {
int r; int r;
uint32_t max_locks = 2; uint32_t max_locks = 2;
uint64_t max_lock_memory = 4096; uint64_t max_lock_memory = 4096;
uint64_t nrows = 1; uint64_t nrows = 1;
bool do_malloc_trace = false;
for (int i = 1; i < argc; i++) { for (int i = 1; i < argc; i++) {
if (strcmp(argv[i], "-v") == 0 || strcmp(argv[i], "--verbose") == 0) { if (strcmp(argv[i], "-v") == 0 || strcmp(argv[i], "--verbose") == 0) {
...@@ -43,12 +74,22 @@ int main(int argc, const char *argv[]) { ...@@ -43,12 +74,22 @@ int main(int argc, const char *argv[]) {
nrows = atoi(argv[++i]); nrows = atoi(argv[++i]);
continue; continue;
} }
if (strcmp(argv[i], "--malloc") == 0) {
do_malloc_trace = true;
continue;
}
assert(0); assert(0);
} }
if (do_malloc_trace) {
toku_set_func_malloc(my_malloc);
toku_set_func_free(my_free);
toku_set_func_realloc(my_realloc);
}
// setup // setup
toku_ltm *ltm = NULL; toku_ltm *ltm = NULL;
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
assert(r == 0 && ltm); assert(r == 0 && ltm);
struct my_ltm_status s; struct my_ltm_status s;
...@@ -59,14 +100,15 @@ int main(int argc, const char *argv[]) { ...@@ -59,14 +100,15 @@ int main(int argc, const char *argv[]) {
assert(s.curr_lock_memory == 0); assert(s.curr_lock_memory == 0);
toku_lock_tree *lt = NULL; toku_lock_tree *lt = NULL;
r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
assert(r == 0 && lt); assert(r == 0 && lt);
DB *db_a = (DB *) 2; DB *db_a = (DB *) 2;
TXNID txn_a = 1; TXNID txn_a = 1;
// acquire the locks on keys 1 .. nrows // acquire the locks on keys 1 .. nrows
for (uint64_t k = 1; k <= nrows; k++) { for (uint64_t i = 1; i <= nrows; i++) {
uint64_t k = htonl64(i);
DBT key = { .data = &k, .size = sizeof k }; DBT key = { .data = &k, .size = sizeof k };
r = toku_lt_acquire_write_lock(lt, db_a, txn_a, &key); r = toku_lt_acquire_write_lock(lt, db_a, txn_a, &key);
if (r != 0) { if (r != 0) {
...@@ -77,12 +119,12 @@ int main(int argc, const char *argv[]) { ...@@ -77,12 +119,12 @@ int main(int argc, const char *argv[]) {
struct my_ltm_status t; struct my_ltm_status t;
my_ltm_get_status(ltm, &t); my_ltm_get_status(ltm, &t);
assert(t.max_locks == max_locks); assert(t.max_locks == max_locks);
assert(t.curr_locks == k); assert(t.curr_locks == i);
assert(t.max_lock_memory == max_lock_memory); assert(t.max_lock_memory == max_lock_memory);
assert(t.curr_lock_memory > s.curr_lock_memory); assert(t.curr_lock_memory > s.curr_lock_memory);
if (verbose) if (verbose)
printf("%"PRIu64" %"PRIu64"\n", k, t.curr_lock_memory); printf("%"PRIu64" %"PRIu64"\n", i, t.curr_lock_memory - s.curr_lock_memory);
s = t; s = t;
} }
...@@ -91,6 +133,9 @@ int main(int argc, const char *argv[]) { ...@@ -91,6 +133,9 @@ int main(int argc, const char *argv[]) {
// release the locks // release the locks
r = toku_lt_unlock(lt, txn_a); assert(r == 0); r = toku_lt_unlock(lt, txn_a); assert(r == 0);
my_ltm_get_status(ltm, &s);
assert(s.curr_locks == 0);
// shutdown // shutdown
r = toku_lt_close(lt); assert(r == 0); r = toku_lt_close(lt); assert(r == 0);
r = toku_ltm_close(ltm); assert(r == 0); r = toku_ltm_close(ltm); assert(r == 0);
......
src/lock_tree/tests/test_footprint_range_write.c 0 → 100644
View file @ 35a46f2e
// benchmark point write locks acquisition rate.
// rate = nrows / time to execute the benchmark.
//
// example: ./benchmark_point_write_locks.tlog --max_locks 1000000 --max_lock_memory 1000000000 --nrows 1000000
#define TOKU_ALLOW_DEPRECATED
#include <malloc.h>
#include "test.h"
#include <byteswap.h>
static uint64_t htonl64(uint64_t x) {
#if BYTE_ORDER == LITTLE_ENDIAN
return bswap_64(x);
#else
#error
#endif
}
struct my_ltm_status {
uint32_t max_locks, curr_locks;
uint64_t max_lock_memory, curr_lock_memory;
LTM_STATUS_S status;
};
static void my_ltm_get_status(toku_ltm *ltm, struct my_ltm_status *my_status) {
toku_ltm_get_status(ltm, &my_status->max_locks, &my_status->curr_locks, &my_status->max_lock_memory, &my_status->curr_lock_memory, &my_status->status);
}
static void *my_malloc(size_t s) {
void * p = malloc(s);
if (verbose)
printf("%s %lu %lu\n", __FUNCTION__, s, malloc_usable_size(p));
return p;
}
static void *my_realloc(void *p, size_t s) {
if (verbose)
printf("%s %p %lu\n", __FUNCTION__, p, s);
return realloc(p, s);
}
static void my_free(void *p) {
if (verbose)
printf("%s %p %lu\n", __FUNCTION__, p, malloc_usable_size(p));
free(p);
}
int main(int argc, const char *argv[]) {
int r;
uint32_t max_locks = 2;
uint64_t max_lock_memory = 4096;
uint64_t nrows = 1;
bool do_malloc_trace = false;
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;
}
if (strcmp(argv[i], "--nrows") == 0 && i+1 < argc) {
nrows = atoi(argv[++i]);
continue;
}
if (strcmp(argv[i], "--malloc") == 0) {
do_malloc_trace = true;
continue;
}
assert(0);
}
if (do_malloc_trace) {
toku_set_func_malloc(my_malloc);
toku_set_func_free(my_free);
toku_set_func_realloc(my_realloc);
}
// setup
toku_ltm *ltm = NULL;
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
assert(r == 0 && ltm);
struct my_ltm_status s;
my_ltm_get_status(ltm, &s);
assert(s.max_locks == max_locks);
assert(s.curr_locks == 0);
assert(s.max_lock_memory == max_lock_memory);
assert(s.curr_lock_memory == 0);
toku_lock_tree *lt = NULL;
r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
assert(r == 0 && lt);
DB *db_a = (DB *) 2;
TXNID txn_a = 1;
// acquire the locks on keys 1 .. nrows
for (uint64_t i = 1; i <= nrows; i++) {
uint64_t k_left = htonl64(2*i);
uint64_t k_right = htonl64(2*i+1);
DBT key_left = { .data = &k_left, .size = sizeof k_left };
DBT key_right = { .data = &k_right, .size = sizeof k_right };
r = toku_lt_acquire_range_write_lock(lt, db_a, txn_a, &key_left, &key_right);
if (r != 0) {
assert(r == TOKUDB_OUT_OF_LOCKS);
break;
}
struct my_ltm_status t;
my_ltm_get_status(ltm, &t);
assert(t.max_locks == max_locks);
assert(t.curr_locks == i);
assert(t.max_lock_memory == max_lock_memory);
assert(t.curr_lock_memory > s.curr_lock_memory);
if (verbose)
printf("%"PRIu64" %"PRIu64"\n", i, t.curr_lock_memory - s.curr_lock_memory);
s = t;
}
// release the locks
r = toku_lt_unlock(lt, txn_a); assert(r == 0);
my_ltm_get_status(ltm, &s);
assert(s.curr_locks == 0);
// shutdown
r = toku_lt_close(lt); assert(r == 0);
r = toku_ltm_close(ltm); assert(r == 0);
return 0;
}
src/lock_tree/tests/test_global_write_lock.c
View file @ 35a46f2e
...@@ -36,14 +36,10 @@ static void init_query(void) { ...@@ -36,14 +36,10 @@ static void init_query(void) {
static void setup_tree(void) { static void setup_tree(void) {
assert(!lt && !ltm); assert(!lt && !ltm);
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
get_compare_fun_from_db,
toku_malloc, toku_free, toku_realloc);
CKERR(r); CKERR(r);
assert(ltm); assert(ltm);
r = toku_lt_create(&lt, dbpanic, ltm, r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
get_compare_fun_from_db,
toku_malloc, toku_free, toku_realloc);
CKERR(r); CKERR(r);
assert(lt); assert(lt);
init_query(); init_query();
...@@ -106,45 +102,57 @@ static void lt_insert_write_range(int r_expect, char txn, int key_l, int key_r) ...@@ -106,45 +102,57 @@ static void lt_insert_write_range(int r_expect, char txn, int key_l, int key_r)
lt_verify(); lt_verify();
} }
static void lt_unlock(TXNID txnid) {
r = toku_lt_unlock(lt, txnid); CKERR(r);
}
static void runtest(void) { static void runtest(void) {
setup_tree(); setup_tree();
lt_insert_write_range(0, 'a', neg_infinite, infinite); lt_insert_write_range(0, 'a', neg_infinite, infinite);
lt_unlock('a');
close_tree(); close_tree();
setup_tree(); setup_tree();
lt_insert_read_range(0, 'a', 1, 2); lt_insert_read_range(0, 'a', 1, 2);
lt_insert_write_range(0, 'a', neg_infinite, infinite); lt_insert_write_range(0, 'a', neg_infinite, infinite);
lt_unlock('a');
close_tree(); close_tree();
setup_tree(); setup_tree();
lt_insert_write_range(0, 'a', 1, 2); lt_insert_write_range(0, 'a', 1, 2);
lt_insert_write_range(0, 'a', neg_infinite, infinite); lt_insert_write_range(0, 'a', neg_infinite, infinite);
lt_unlock('a');
close_tree(); close_tree();
setup_tree(); setup_tree();
lt_insert_read_range(0, 'b', 1, 2); lt_insert_read_range(0, 'b', 1, 2);
lt_insert_write_range(DB_LOCK_NOTGRANTED, 'a', neg_infinite, infinite); lt_insert_write_range(DB_LOCK_NOTGRANTED, 'a', neg_infinite, infinite);
lt_unlock('b');
close_tree(); close_tree();
setup_tree(); setup_tree();
lt_insert_write_range(0, 'b', 1, 2); lt_insert_write_range(0, 'b', 1, 2);
lt_insert_write_range(DB_LOCK_NOTGRANTED, 'a', neg_infinite, infinite); lt_insert_write_range(DB_LOCK_NOTGRANTED, 'a', neg_infinite, infinite);
lt_unlock('b');
close_tree(); close_tree();
setup_tree(); setup_tree();
lt_insert_write_range(0, 'a', neg_infinite, infinite); lt_insert_write_range(0, 'a', neg_infinite, infinite);
lt_insert_write_range(0, 'a', neg_infinite, infinite); lt_insert_write_range(0, 'a', neg_infinite, infinite);
lt_unlock('a');
close_tree(); close_tree();
setup_tree(); setup_tree();
lt_insert_write_range(0, 'a', neg_infinite, infinite); lt_insert_write_range(0, 'a', neg_infinite, infinite);
lt_insert_write_range(DB_LOCK_NOTGRANTED, 'b', neg_infinite, infinite); lt_insert_write_range(DB_LOCK_NOTGRANTED, 'b', neg_infinite, infinite);
lt_unlock('a');
close_tree(); close_tree();
setup_tree(); setup_tree();
lt_insert_write_range(0, 'a', neg_infinite, infinite); lt_insert_write_range(0, 'a', neg_infinite, infinite);
lt_insert_read_range(0, 'a', 1, 2); lt_insert_read_range(0, 'a', 1, 2);
lt_insert_read_range(DB_LOCK_NOTGRANTED, 'b', 10, 20); lt_insert_read_range(DB_LOCK_NOTGRANTED, 'b', 10, 20);
lt_unlock('a');
close_tree(); close_tree();
} }
......
src/lock_tree/tests/test_lock_timeout.c
View file @ 35a46f2e
...@@ -50,11 +50,11 @@ int main(int argc, const char *argv[]) { ...@@ -50,11 +50,11 @@ int main(int argc, const char *argv[]) {
// setup // setup
toku_ltm *ltm = NULL; toku_ltm *ltm = NULL;
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
assert(r == 0 && ltm); assert(r == 0 && ltm);
toku_lock_tree *lt = NULL; toku_lock_tree *lt = NULL;
r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
assert(r == 0 && lt); assert(r == 0 && lt);
const TXNID txn_a = 1; const TXNID txn_a = 1;
......
src/lock_tree/tests/test_ltm_get_status.c
View file @ 35a46f2e
...@@ -22,9 +22,7 @@ int main(int argc, const char *argv[]) { ...@@ -22,9 +22,7 @@ int main(int argc, const char *argv[]) {
int r; int r;
toku_ltm *ltm = NULL; toku_ltm *ltm = NULL;
r = toku_ltm_create(&ltm, MAX_LOCKS, MAX_LOCK_MEMORY, dbpanic, r = toku_ltm_create(&ltm, MAX_LOCKS, MAX_LOCK_MEMORY, dbpanic, get_compare_fun_from_db);
get_compare_fun_from_db,
toku_malloc, toku_free, toku_realloc);
CKERR(r); CKERR(r);
do_ltm_status(ltm); do_ltm_status(ltm);
#if 0 #if 0
......
src/lock_tree/tests/test_read_notgranted.c
View file @ 35a46f2e
...@@ -49,11 +49,11 @@ int main(int argc, const char *argv[]) { ...@@ -49,11 +49,11 @@ int main(int argc, const char *argv[]) {
// setup // setup
toku_ltm *ltm = NULL; toku_ltm *ltm = NULL;
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
assert(r == 0 && ltm); assert(r == 0 && ltm);
toku_lock_tree *lt = NULL; toku_lock_tree *lt = NULL;
r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
assert(r == 0 && lt); assert(r == 0 && lt);
const TXNID txn_a = 1; const TXNID txn_a = 1;
......
src/lock_tree/tests/test_read_out_of_locks.c
View file @ 35a46f2e
...@@ -38,11 +38,11 @@ int main(int argc, const char *argv[]) { ...@@ -38,11 +38,11 @@ int main(int argc, const char *argv[]) {
// setup // setup
toku_ltm *ltm = NULL; toku_ltm *ltm = NULL;
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
assert(r == 0 && ltm); assert(r == 0 && ltm);
toku_lock_tree *lt = NULL; toku_lock_tree *lt = NULL;
r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
assert(r == 0 && lt); assert(r == 0 && lt);
const TXNID txn_a = 1; const TXNID txn_a = 1;
......
src/lock_tree/tests/test_read_request_blocked.c
View file @ 35a46f2e
...@@ -37,11 +37,11 @@ int main(int argc, const char *argv[]) { ...@@ -37,11 +37,11 @@ int main(int argc, const char *argv[]) {
// setup // setup
toku_ltm *ltm = NULL; toku_ltm *ltm = NULL;
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
assert(r == 0 && ltm); assert(r == 0 && ltm);
toku_lock_tree *lt = NULL; toku_lock_tree *lt = NULL;
r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
assert(r == 0 && lt); assert(r == 0 && lt);
const TXNID txn_a = 1; const TXNID txn_a = 1;
......
src/lock_tree/tests/test_set_mutex.c
View file @ 35a46f2e
...@@ -36,7 +36,7 @@ main(int argc, const char *argv[]) { ...@@ -36,7 +36,7 @@ main(int argc, const char *argv[]) {
// setup // setup
toku_ltm *ltm = NULL; toku_ltm *ltm = NULL;
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
assert(r == 0 && ltm); assert(r == 0 && ltm);
toku_ltm_set_lock_wait_time(ltm, 5000); toku_ltm_set_lock_wait_time(ltm, 5000);
...@@ -45,7 +45,7 @@ main(int argc, const char *argv[]) { ...@@ -45,7 +45,7 @@ main(int argc, const char *argv[]) {
toku_ltm_set_mutex(ltm, &my_mutex); toku_ltm_set_mutex(ltm, &my_mutex);
toku_lock_tree *lt = NULL; toku_lock_tree *lt = NULL;
r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
assert(r == 0 && lt); assert(r == 0 && lt);
const TXNID txn_a = 1; const TXNID txn_a = 1;
......
src/lock_tree/tests/test_set_mutex_default_lock_timeout.c
View file @ 35a46f2e
...@@ -54,14 +54,14 @@ int main(int argc, const char *argv[]) { ...@@ -54,14 +54,14 @@ int main(int argc, const char *argv[]) {
// setup // setup
toku_ltm *ltm = NULL; toku_ltm *ltm = NULL;
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
assert(r == 0 && ltm); assert(r == 0 && ltm);
toku_pthread_mutex_t my_mutex = TOKU_PTHREAD_MUTEX_INITIALIZER; toku_pthread_mutex_t my_mutex = TOKU_PTHREAD_MUTEX_INITIALIZER;
toku_ltm_set_mutex(ltm, &my_mutex); toku_ltm_set_mutex(ltm, &my_mutex);
toku_lock_tree *lt = NULL; toku_lock_tree *lt = NULL;
r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
assert(r == 0 && lt); assert(r == 0 && lt);
const TXNID txn_a = 1; const TXNID txn_a = 1;
......
src/lock_tree/tests/test_simple_deadlock.c
View file @ 35a46f2e
...@@ -36,11 +36,11 @@ int main(int argc, const char *argv[]) { ...@@ -36,11 +36,11 @@ int main(int argc, const char *argv[]) {
// setup // setup
toku_ltm *ltm = NULL; toku_ltm *ltm = NULL;
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
assert(r == 0 && ltm); assert(r == 0 && ltm);
toku_lock_tree *lt = NULL; toku_lock_tree *lt = NULL;
r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
assert(r == 0 && lt); assert(r == 0 && lt);
const TXNID txn_a = 1; const TXNID txn_a = 1;
......
src/lock_tree/tests/test_update_deadlock.c
View file @ 35a46f2e
...@@ -36,11 +36,11 @@ int main(int argc, const char *argv[]) { ...@@ -36,11 +36,11 @@ int main(int argc, const char *argv[]) {
// setup // setup
toku_ltm *ltm = NULL; toku_ltm *ltm = NULL;
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
assert(r == 0 && ltm); assert(r == 0 && ltm);
toku_lock_tree *lt = NULL; toku_lock_tree *lt = NULL;
r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
assert(r == 0 && lt); assert(r == 0 && lt);
const TXNID txn_a = 1; const TXNID txn_a = 1;
......
src/lock_tree/tests/test_update_deadlock_copy_keys.c
View file @ 35a46f2e
...@@ -36,11 +36,11 @@ int main(int argc, const char *argv[]) { ...@@ -36,11 +36,11 @@ int main(int argc, const char *argv[]) {
// setup // setup
toku_ltm *ltm = NULL; toku_ltm *ltm = NULL;
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
assert(r == 0 && ltm); assert(r == 0 && ltm);
toku_lock_tree *lt = NULL; toku_lock_tree *lt = NULL;
r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
assert(r == 0 && lt); assert(r == 0 && lt);
const TXNID txn_a = 1; const TXNID txn_a = 1;
......
src/lock_tree/tests/test_write_conflict_with_threads.c
View file @ 35a46f2e
...@@ -65,11 +65,11 @@ int main(int argc, const char *argv[]) { ...@@ -65,11 +65,11 @@ int main(int argc, const char *argv[]) {
// setup // setup
toku_ltm *ltm = NULL; toku_ltm *ltm = NULL;
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
assert(r == 0 && ltm); assert(r == 0 && ltm);
toku_lock_tree *lt = NULL; toku_lock_tree *lt = NULL;
r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
assert(r == 0 && lt); assert(r == 0 && lt);
const TXNID txn_a = 1; const TXNID txn_a = 1;
......
src/lock_tree/tests/test_write_notgranted.c
View file @ 35a46f2e
...@@ -40,11 +40,11 @@ int main(int argc, const char *argv[]) { ...@@ -40,11 +40,11 @@ int main(int argc, const char *argv[]) {
// setup // setup
toku_ltm *ltm = NULL; toku_ltm *ltm = NULL;
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
assert(r == 0 && ltm); assert(r == 0 && ltm);
toku_lock_tree *lt = NULL; toku_lock_tree *lt = NULL;
r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
assert(r == 0 && lt); assert(r == 0 && lt);
const TXNID txn_a = 1; const TXNID txn_a = 1;
......
src/lock_tree/tests/test_write_range.c
View file @ 35a46f2e
...@@ -36,14 +36,10 @@ static void init_query(void) { ...@@ -36,14 +36,10 @@ static void init_query(void) {
static void setup_tree(void) { static void setup_tree(void) {
assert(!lt && !ltm); assert(!lt && !ltm);
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
get_compare_fun_from_db,
toku_malloc, toku_free, toku_realloc);
CKERR(r); CKERR(r);
assert(ltm); assert(ltm);
r = toku_lt_create(&lt, dbpanic, ltm, r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
get_compare_fun_from_db,
toku_malloc, toku_free, toku_realloc);
CKERR(r); CKERR(r);
assert(lt); assert(lt);
init_query(); init_query();
...@@ -75,7 +71,7 @@ static DBT* set_to_infty(DBT *dbt, int value) { ...@@ -75,7 +71,7 @@ static DBT* set_to_infty(DBT *dbt, int value) {
} }
static void lt_insert(int r_expect, char txn, int key_l, static void lt_insert(int r_expect, char txn, int key_l,
int key_r, BOOL read_flag) { int key_r, bool read_flag) {
DBT _key_left; DBT _key_left;
DBT _key_right; DBT _key_right;
DBT* key_left = &_key_left; DBT* key_left = &_key_left;
...@@ -102,12 +98,12 @@ static void lt_insert(int r_expect, char txn, int key_l, ...@@ -102,12 +98,12 @@ static void lt_insert(int r_expect, char txn, int key_l,
static void lt_insert_read(int r_expect, char txn, int key_l, int key_r) UU(); static void lt_insert_read(int r_expect, char txn, int key_l, int key_r) UU();
static void lt_insert_read(int r_expect, char txn, int key_l, int key_r) { static void lt_insert_read(int r_expect, char txn, int key_l, int key_r) {
lt_insert(r_expect, txn, key_l, key_r, TRUE); lt_insert(r_expect, txn, key_l, key_r, true);
} }
static void lt_insert_write(int r_expect, char txn, int key_l) UU(); static void lt_insert_write(int r_expect, char txn, int key_l) UU();
static void lt_insert_write(int r_expect, char txn, int key_l) { static void lt_insert_write(int r_expect, char txn, int key_l) {
lt_insert(r_expect, txn, key_l, 0, FALSE); lt_insert(r_expect, txn, key_l, 0, false);
} }
static void lt_insert_write_range(int r_expect, char txn, int key_l, int key_r) { static void lt_insert_write_range(int r_expect, char txn, int key_l, int key_r) {
...@@ -141,30 +137,35 @@ static void runtest(void) { ...@@ -141,30 +137,35 @@ static void runtest(void) {
lt_insert_write_range(0, 'a', 30, 40); lt_insert_write_range(0, 'a', 30, 40);
lt_insert_write(0, 'a', 25); lt_insert_write(0, 'a', 25);
lt_insert_write(0, 'a', 50); lt_insert_write(0, 'a', 50);
lt_unlock('a');
close_tree(); close_tree();
// no overlaps (reverse) // no overlaps (reverse)
setup_tree(); setup_tree();
lt_insert_write_range(0, 'a', 30, 40); lt_insert_write_range(0, 'a', 30, 40);
lt_insert_write_range(0, 'a', 10, 20); lt_insert_write_range(0, 'a', 10, 20);
lt_unlock('a');
close_tree(); close_tree();
// overlaps // overlaps
setup_tree(); setup_tree();
lt_insert_write_range(0, 'a', 5, 15); lt_insert_write_range(0, 'a', 5, 15);
lt_insert_write_range(0, 'a', 10, 20); lt_insert_write_range(0, 'a', 10, 20);
lt_unlock('a');
close_tree(); close_tree();
setup_tree(); setup_tree();
lt_insert_write_range(0, 'a', 5, 15); lt_insert_write_range(0, 'a', 5, 15);
lt_insert_write_range(0, 'a', 30, 40); lt_insert_write_range(0, 'a', 30, 40);
lt_insert_write_range(0, 'a', 10, 20); lt_insert_write_range(0, 'a', 10, 20);
lt_unlock('a');
close_tree(); close_tree();
// overlaps (reverse) // overlaps (reverse)
setup_tree(); setup_tree();
lt_insert_write_range(0, 'a', 10, 20); lt_insert_write_range(0, 'a', 10, 20);
lt_insert_write_range(0, 'a', 5, 15); lt_insert_write_range(0, 'a', 5, 15);
lt_unlock('a');
close_tree(); close_tree();
// test borderwrite split // test borderwrite split
...@@ -173,6 +174,8 @@ static void runtest(void) { ...@@ -173,6 +174,8 @@ static void runtest(void) {
lt_insert_write_range(0, 'a', 5, 6); lt_insert_write_range(0, 'a', 5, 6);
lt_insert_write_range(0, 'a', 20, 30); lt_insert_write_range(0, 'a', 20, 30);
lt_insert_write_range(0, 'b', 10, 10); lt_insert_write_range(0, 'b', 10, 10);
lt_unlock('a');
lt_unlock('b');
close_tree(); close_tree();
// test borderwrite split // test borderwrite split
...@@ -180,38 +183,46 @@ static void runtest(void) { ...@@ -180,38 +183,46 @@ static void runtest(void) {
lt_insert_write_range(0, 'a', 0, 5); lt_insert_write_range(0, 'a', 0, 5);
lt_insert_write_range(0, 'a', 20, 30); lt_insert_write_range(0, 'a', 20, 30);
lt_insert_write_range(0, 'b', 10, 10); lt_insert_write_range(0, 'b', 10, 10);
lt_unlock('a');
lt_unlock('b');
close_tree(); close_tree();
setup_tree(); setup_tree();
lt_insert_write_range(0, 'a', 15, 20); lt_insert_write_range(0, 'a', 15, 20);
lt_insert_write_range(0, 'a', 10, 30); lt_insert_write_range(0, 'a', 10, 30);
lt_unlock('a');
close_tree(); close_tree();
setup_tree(); setup_tree();
lt_insert_write_range(0, 'a', 10, 30); lt_insert_write_range(0, 'a', 10, 30);
lt_insert_write_range(0, 'a', 15, 20); lt_insert_write_range(0, 'a', 15, 20);
lt_unlock('a');
close_tree(); close_tree();
setup_tree(); setup_tree();
lt_insert_write_range(0, 'b', 70, 80); lt_insert_write_range(0, 'b', 70, 80);
lt_insert_write_range(0, 'b', 60, 70); lt_insert_write_range(0, 'b', 60, 70);
lt_insert_write_range(0, 'b', 80, 90); lt_insert_write_range(0, 'b', 80, 90);
lt_unlock('b');
close_tree(); close_tree();
setup_tree(); setup_tree();
lt_insert_write(0, 'a', 5); lt_insert_write(0, 'a', 5);
lt_insert_write_range(0, 'a', 1, 20); lt_insert_write_range(0, 'a', 1, 20);
lt_unlock('a');
close_tree(); close_tree();
setup_tree(); setup_tree();
lt_insert_write(0, 'a', 5); lt_insert_write(0, 'a', 5);
lt_insert_write(0, 'a', 10); lt_insert_write(0, 'a', 10);
lt_unlock('a');
close_tree(); close_tree();
setup_tree(); setup_tree();
lt_insert_write(0, 'a', 5); lt_insert_write(0, 'a', 5);
lt_insert_write(0, 'a', 10); lt_insert_write(0, 'a', 10);
lt_insert_write_range(0, 'a', 1, 20); lt_insert_write_range(0, 'a', 1, 20);
lt_unlock('a');
close_tree(); close_tree();
} }
......
src/lock_tree/tests/test_write_range_conflict_read.c
View file @ 35a46f2e
...@@ -36,14 +36,10 @@ static void init_query(void) { ...@@ -36,14 +36,10 @@ static void init_query(void) {
static void setup_tree(void) { static void setup_tree(void) {
assert(!lt && !ltm); assert(!lt && !ltm);
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
get_compare_fun_from_db,
toku_malloc, toku_free, toku_realloc);
CKERR(r); CKERR(r);
assert(ltm); assert(ltm);
r = toku_lt_create(&lt, dbpanic, ltm, r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
get_compare_fun_from_db,
toku_malloc, toku_free, toku_realloc);
CKERR(r); CKERR(r);
assert(lt); assert(lt);
init_query(); init_query();
...@@ -113,6 +109,8 @@ static void runtest(void) { ...@@ -113,6 +109,8 @@ static void runtest(void) {
setup_tree(); setup_tree();
lt_insert_read_range(0, 'a', 1, 50); lt_insert_read_range(0, 'a', 1, 50);
lt_insert_write_range(0, 'b', 51, 99); lt_insert_write_range(0, 'b', 51, 99);
lt_unlock('a');
lt_unlock('b');
close_tree(); close_tree();
setup_tree(); setup_tree();
...@@ -124,6 +122,8 @@ static void runtest(void) { ...@@ -124,6 +122,8 @@ static void runtest(void) {
lt_insert_write_range(DB_LOCK_NOTGRANTED, 'b', 10, 11); lt_insert_write_range(DB_LOCK_NOTGRANTED, 'b', 10, 11);
lt_insert_write_range(DB_LOCK_NOTGRANTED, 'b', 55, 56); lt_insert_write_range(DB_LOCK_NOTGRANTED, 'b', 55, 56);
lt_insert_write_range(DB_LOCK_NOTGRANTED, 'b', 55, 65); lt_insert_write_range(DB_LOCK_NOTGRANTED, 'b', 55, 65);
lt_unlock('a');
lt_unlock('b');
close_tree(); close_tree();
} }
......
src/lock_tree/tests/test_write_range_conflict_write.c
View file @ 35a46f2e
...@@ -36,14 +36,10 @@ static void init_query(void) { ...@@ -36,14 +36,10 @@ static void init_query(void) {
static void setup_tree(void) { static void setup_tree(void) {
assert(!lt && !ltm); assert(!lt && !ltm);
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
get_compare_fun_from_db,
toku_malloc, toku_free, toku_realloc);
CKERR(r); CKERR(r);
assert(ltm); assert(ltm);
r = toku_lt_create(&lt, dbpanic, ltm, r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
get_compare_fun_from_db,
toku_malloc, toku_free, toku_realloc);
CKERR(r); CKERR(r);
assert(lt); assert(lt);
init_query(); init_query();
...@@ -114,6 +110,8 @@ static void runtest(void) { ...@@ -114,6 +110,8 @@ static void runtest(void) {
setup_tree(); setup_tree();
lt_insert_write_range(0, 'a', 1, 50); lt_insert_write_range(0, 'a', 1, 50);
lt_insert_write_range(0, 'b', 51, 99); lt_insert_write_range(0, 'b', 51, 99);
lt_unlock('a');
lt_unlock('b');
close_tree(); close_tree();
setup_tree(); setup_tree();
...@@ -123,6 +121,8 @@ static void runtest(void) { ...@@ -123,6 +121,8 @@ static void runtest(void) {
lt_insert_write_range(0, 'b', 80, 90); lt_insert_write_range(0, 'b', 80, 90);
lt_insert_write_range(DB_LOCK_NOTGRANTED, 'b', 50, 60); lt_insert_write_range(DB_LOCK_NOTGRANTED, 'b', 50, 60);
lt_insert_write_range(DB_LOCK_NOTGRANTED, 'b', 50, 50); lt_insert_write_range(DB_LOCK_NOTGRANTED, 'b', 50, 50);
lt_unlock('a');
lt_unlock('b');
close_tree(); close_tree();
} }
......
src/lock_tree/tests/test_write_request_blocked.c
View file @ 35a46f2e
...@@ -34,11 +34,11 @@ int main(int argc, const char *argv[]) { ...@@ -34,11 +34,11 @@ int main(int argc, const char *argv[]) {
// setup // setup
toku_ltm *ltm = NULL; toku_ltm *ltm = NULL;
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
assert(r == 0 && ltm); assert(r == 0 && ltm);
toku_lock_tree *lt = NULL; toku_lock_tree *lt = NULL;
r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
assert(r == 0 && lt); assert(r == 0 && lt);
const TXNID txn_a = 1; const TXNID txn_a = 1;
......
src/lock_tree/tests/test_wrw.c
View file @ 35a46f2e
...@@ -33,11 +33,11 @@ int main(int argc, const char *argv[]) { ...@@ -33,11 +33,11 @@ int main(int argc, const char *argv[]) {
// setup // setup
toku_ltm *ltm = NULL; toku_ltm *ltm = NULL;
r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_ltm_create(&ltm, max_locks, max_lock_memory, dbpanic, get_compare_fun_from_db);
assert(r == 0 && ltm); assert(r == 0 && ltm);
toku_lock_tree *lt = NULL; toku_lock_tree *lt = NULL;
r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db, toku_malloc, toku_free, toku_realloc); r = toku_lt_create(&lt, dbpanic, ltm, get_compare_fun_from_db);
assert(r == 0 && lt); assert(r == 0 && lt);
const TXNID txn_a = 1; const TXNID txn_a = 1;
......
src/range_tree/linear.c
View file @ 35a46f2e
This diff is collapsed.
src/range_tree/log_nooverlap.c
View file @ 35a46f2e
...@@ -12,6 +12,7 @@ ...@@ -12,6 +12,7 @@
//Currently this is a stub implementation just so we can write and compile tests //Currently this is a stub implementation just so we can write and compile tests
//before actually implementing the range tree. //before actually implementing the range tree.
#include "memory.h"
#include <rangetree.h> #include <rangetree.h>
#include <errno.h> #include <errno.h>
#include <toku_assert.h> #include <toku_assert.h>
...@@ -31,39 +32,42 @@ int ...@@ -31,39 +32,42 @@ int
toku_rt_create(toku_range_tree** ptree, toku_rt_create(toku_range_tree** ptree,
int (*end_cmp)(const toku_point*,const toku_point*), int (*end_cmp)(const toku_point*,const toku_point*),
int (*data_cmp)(const TXNID,const TXNID), int (*data_cmp)(const TXNID,const TXNID),
BOOL allow_overlaps, bool allow_overlaps,
void* (*user_malloc) (size_t), void (*incr_memory_size)(void *extra_memory_size, size_t s),
void (*user_free) (void*), void (*decr_memory_size)(void *extra_memory_size, size_t s),
void* (*user_realloc)(void*, size_t)) { void *extra_memory_size) {
int r = ENOSYS; int r = ENOSYS;
toku_range_tree* temptree = NULL; toku_range_tree* tmptree = NULL;
if (allow_overlaps) if (allow_overlaps)
return EINVAL; return EINVAL;
r = toku_rt_super_create(ptree, &temptree, end_cmp, data_cmp, allow_overlaps, r = toku_rt_super_create(ptree, &tmptree, end_cmp, data_cmp, allow_overlaps, incr_memory_size, decr_memory_size, extra_memory_size);
user_malloc, user_free, user_realloc);
if (r != 0) if (r != 0)
goto cleanup; goto cleanup;
//Any local initializers go here. //Any local initializers go here.
r = toku_omt_create(&temptree->i.omt); r = toku_omt_create(&tmptree->i.omt);
if (r != 0) if (r != 0)
goto cleanup; goto cleanup;
*ptree = temptree; tmptree->incr_memory_size(tmptree->extra_memory_size, toku_rt_memory_size(tmptree));
*ptree = tmptree;
r = 0; r = 0;
cleanup: cleanup:
if (r != 0) { if (r != 0) {
if (temptree) if (tmptree)
user_free(temptree); toku_free(tmptree);
} }
return r; return r;
} }
static int static int
rt_clear_helper(OMTVALUE value, u_int32_t UU(index), void* extra) { rt_clear_helper(OMTVALUE value, u_int32_t UU(index), void* extra) {
void (*user_free)(void*) = (void(*)(void*))extra; toku_range_tree *tree = (toku_range_tree *) extra;
user_free(value); size_t s = toku_malloc_usable_size(value);
tree->decr_memory_size(tree->extra_memory_size, s);
toku_free(value);
return 0; return 0;
} }
...@@ -71,20 +75,24 @@ int ...@@ -71,20 +75,24 @@ int
toku_rt_close(toku_range_tree* tree) { toku_rt_close(toku_range_tree* tree) {
if (!tree) if (!tree)
return EINVAL; return EINVAL;
int r = toku_omt_iterate(tree->i.omt, rt_clear_helper, tree->free); int r = toku_omt_iterate(tree->i.omt, rt_clear_helper, tree);
assert_zero(r); assert_zero(r);
tree->decr_memory_size(tree->extra_memory_size, toku_rt_memory_size(tree));
toku_omt_destroy(&tree->i.omt); toku_omt_destroy(&tree->i.omt);
tree->free(tree); toku_free(tree);
return 0; return 0;
} }
void void
toku_rt_clear(toku_range_tree* tree) { toku_rt_clear(toku_range_tree* tree) {
assert(tree); assert(tree);
int r = toku_omt_iterate(tree->i.omt, rt_clear_helper, tree->free); int r = toku_omt_iterate(tree->i.omt, rt_clear_helper, tree);
assert_zero(r); assert_zero(r);
size_t start_size = toku_omt_memory_size(tree->i.omt);;
toku_omt_clear(tree->i.omt); toku_omt_clear(tree->i.omt);
tree->numelements = 0; size_t end_size = toku_omt_memory_size(tree->i.omt);
assert(start_size >= end_size);
tree->decr_memory_size(tree->extra_memory_size, start_size - end_size);
} }
typedef struct { typedef struct {
...@@ -204,17 +212,24 @@ toku_rt_insert(toku_range_tree* tree, toku_range* range) { ...@@ -204,17 +212,24 @@ toku_rt_insert(toku_range_tree* tree, toku_range* range) {
r = EDOM; goto cleanup; r = EDOM; goto cleanup;
} }
assert(r == DB_NOTFOUND); assert(r == DB_NOTFOUND);
insert_range = tree->malloc(sizeof(*insert_range)); insert_range = toku_xmalloc(sizeof *insert_range);
*insert_range = *range; *insert_range = *range;
size_t start_omt_size = toku_omt_memory_size(tree->i.omt);
static int count = 0;
count++;
r = toku_omt_insert_at(tree->i.omt, insert_range, index); r = toku_omt_insert_at(tree->i.omt, insert_range, index);
assert_zero(r); assert_zero(r);
size_t end_omt_size = toku_omt_memory_size(tree->i.omt);
tree->numelements++; if (end_omt_size >= start_omt_size)
tree->incr_memory_size(tree->extra_memory_size, end_omt_size - start_omt_size);
else
tree->decr_memory_size(tree->extra_memory_size, start_omt_size - end_omt_size);
tree->incr_memory_size(tree->extra_memory_size, toku_malloc_usable_size(insert_range));
r = 0; r = 0;
cleanup: cleanup:
if (r != 0) { if (r != 0) {
if (insert_range) if (insert_range)
tree->free(insert_range); toku_free(insert_range);
} }
return r; return r;
} }
...@@ -245,11 +260,16 @@ toku_rt_delete(toku_range_tree* tree, toku_range* range) { ...@@ -245,11 +260,16 @@ toku_rt_delete(toku_range_tree* tree, toku_range* range) {
r = EDOM; r = EDOM;
goto cleanup; goto cleanup;
} }
size_t start_omt_size = toku_omt_memory_size(tree->i.omt);
r = toku_omt_delete_at(tree->i.omt, index); r = toku_omt_delete_at(tree->i.omt, index);
assert_zero(r); assert_zero(r);
size_t end_omt_size = toku_omt_memory_size(tree->i.omt);
tree->free(data); if (start_omt_size >= end_omt_size)
tree->numelements--; tree->decr_memory_size(tree->extra_memory_size, start_omt_size - end_omt_size);
else
tree->incr_memory_size(tree->extra_memory_size, end_omt_size - start_omt_size);
tree->decr_memory_size(tree->extra_memory_size, toku_malloc_usable_size(data));
toku_free(data);
r = 0; r = 0;
cleanup: cleanup:
return r; return r;
...@@ -257,7 +277,7 @@ cleanup: ...@@ -257,7 +277,7 @@ cleanup:
static inline int static inline int
rt_neightbor(toku_range_tree* tree, toku_point* point, rt_neightbor(toku_range_tree* tree, toku_point* point,
toku_range* neighbor, BOOL* wasfound, int direction) { toku_range* neighbor, bool* wasfound, int direction) {
int r = ENOSYS; int r = ENOSYS;
if (!tree || !point || !neighbor || !wasfound || tree->allow_overlaps) { if (!tree || !point || !neighbor || !wasfound || tree->allow_overlaps) {
r = EINVAL; goto cleanup; r = EINVAL; goto cleanup;
...@@ -272,14 +292,14 @@ rt_neightbor(toku_range_tree* tree, toku_point* point, ...@@ -272,14 +292,14 @@ rt_neightbor(toku_range_tree* tree, toku_point* point,
assert(direction==1 || direction==-1); assert(direction==1 || direction==-1);
r = toku_omt_find(tree->i.omt, rt_heaviside, &extra, direction, &value, &index); r = toku_omt_find(tree->i.omt, rt_heaviside, &extra, direction, &value, &index);
if (r == DB_NOTFOUND) { if (r == DB_NOTFOUND) {
*wasfound = FALSE; *wasfound = false;
r = 0; r = 0;
goto cleanup; goto cleanup;
} }
assert_zero(r); assert_zero(r);
assert(value); assert(value);
toku_range* data = value; toku_range* data = value;
*wasfound = TRUE; *wasfound = true;
*neighbor = *data; *neighbor = *data;
r = 0; r = 0;
cleanup: cleanup:
...@@ -287,17 +307,17 @@ cleanup: ...@@ -287,17 +307,17 @@ cleanup:
} }
int int
toku_rt_predecessor (toku_range_tree* tree, toku_point* point, toku_range* pred, BOOL* wasfound) { toku_rt_predecessor (toku_range_tree* tree, toku_point* point, toku_range* pred, bool* wasfound) {
return rt_neightbor(tree, point, pred, wasfound, -1); return rt_neightbor(tree, point, pred, wasfound, -1);
} }
int int
toku_rt_successor (toku_range_tree* tree, toku_point* point, toku_range* succ, BOOL* wasfound) { toku_rt_successor (toku_range_tree* tree, toku_point* point, toku_range* succ, bool* wasfound) {
return rt_neightbor(tree, point, succ, wasfound, 1); return rt_neightbor(tree, point, succ, wasfound, 1);
} }
int int
toku_rt_get_allow_overlaps(toku_range_tree* tree, BOOL* allowed) { toku_rt_get_allow_overlaps(toku_range_tree* tree, bool* allowed) {
if (!tree || !allowed) if (!tree || !allowed)
return EINVAL; return EINVAL;
assert(!tree->allow_overlaps); assert(!tree->allow_overlaps);
...@@ -305,12 +325,9 @@ toku_rt_get_allow_overlaps(toku_range_tree* tree, BOOL* allowed) { ...@@ -305,12 +325,9 @@ toku_rt_get_allow_overlaps(toku_range_tree* tree, BOOL* allowed) {
return 0; return 0;
} }
int size_t
toku_rt_get_size(toku_range_tree* tree, u_int32_t* size) { toku_rt_get_size(toku_range_tree* tree) {
if (!tree || !size) return toku_omt_size(tree->i.omt);
return EINVAL;
*size = tree->numelements;
return 0;
} }
typedef struct { typedef struct {
...@@ -332,21 +349,22 @@ toku_rt_iterate(toku_range_tree* tree, int (*f)(toku_range*,void*), void* extra) ...@@ -332,21 +349,22 @@ toku_rt_iterate(toku_range_tree* tree, int (*f)(toku_range*,void*), void* extra)
return toku_omt_iterate(tree->i.omt, rt_iterate_helper, &info); return toku_omt_iterate(tree->i.omt, rt_iterate_helper, &info);
} }
static inline BOOL static inline bool
toku__rt_overlap(toku_range_tree* tree, toku_interval* a, toku_interval* b) { toku__rt_overlap(toku_range_tree* tree, toku_interval* a, toku_interval* b) {
assert(tree); assert(tree);
assert(a); assert(a);
assert(b); assert(b);
//a->left <= b->right && b->left <= a->right //a->left <= b->right && b->left <= a->right
return (BOOL)((tree->end_cmp(a->left, b->right) <= 0) && return ((tree->end_cmp(a->left, b->right) <= 0) &&
(tree->end_cmp(b->left, a->right) <= 0)); (tree->end_cmp(b->left, a->right) <= 0));
} }
void void
toku_rt_verify(toku_range_tree *tree) { toku_rt_verify(toku_range_tree *tree) {
int r; int r;
if (!tree->allow_overlaps) { if (!tree->allow_overlaps) {
for (u_int32_t i = 0; i < tree->numelements; i++) { u_int32_t numelements = toku_omt_size(tree->i.omt);
for (u_int32_t i = 0; i < numelements; i++) {
// assert left <= right // assert left <= right
OMTVALUE omtv; OMTVALUE omtv;
r = toku_omt_fetch(tree->i.omt, i, &omtv); r = toku_omt_fetch(tree->i.omt, i, &omtv);
...@@ -354,7 +372,7 @@ toku_rt_verify(toku_range_tree *tree) { ...@@ -354,7 +372,7 @@ toku_rt_verify(toku_range_tree *tree) {
toku_range *v = (toku_range *) omtv; toku_range *v = (toku_range *) omtv;
assert(tree->end_cmp(v->ends.left, v->ends.right) <= 0); assert(tree->end_cmp(v->ends.left, v->ends.right) <= 0);
// assert ranges are sorted // assert ranges are sorted
if (i < tree->numelements-1) { if (i < numelements-1) {
OMTVALUE omtvnext; OMTVALUE omtvnext;
r = toku_omt_fetch(tree->i.omt, i+1, &omtvnext); r = toku_omt_fetch(tree->i.omt, i+1, &omtvnext);
assert_zero(r); assert_zero(r);
...@@ -363,7 +381,7 @@ toku_rt_verify(toku_range_tree *tree) { ...@@ -363,7 +381,7 @@ toku_rt_verify(toku_range_tree *tree) {
} }
} }
// verify no overlaps // verify no overlaps
for (u_int32_t i = 1; i < tree->numelements; i++) { for (u_int32_t i = 1; i < numelements; i++) {
OMTVALUE omtvprev; OMTVALUE omtvprev;
r = toku_omt_fetch(tree->i.omt, i-1, &omtvprev); r = toku_omt_fetch(tree->i.omt, i-1, &omtvprev);
assert_zero(r); assert_zero(r);
...@@ -376,3 +394,8 @@ toku_rt_verify(toku_range_tree *tree) { ...@@ -376,3 +394,8 @@ toku_rt_verify(toku_range_tree *tree) {
} }
} }
} }
size_t
toku_rt_memory_size(toku_range_tree *tree) {
return sizeof (toku_range_tree) + toku_omt_memory_size(tree->i.omt);
}
src/range_tree/rangetree-internal.h
View file @ 35a46f2e
...@@ -25,17 +25,12 @@ struct __toku_range_tree { ...@@ -25,17 +25,12 @@ struct __toku_range_tree {
with a range */ with a range */
int (*data_cmp)(const TXNID,const TXNID); int (*data_cmp)(const TXNID,const TXNID);
/** Whether this tree allows ranges to overlap */ /** Whether this tree allows ranges to overlap */
BOOL allow_overlaps; bool allow_overlaps;
/** The number of ranges in the range tree */
u_int32_t numelements;
/** The user malloc function */
void* (*malloc) (size_t);
/** The user free function */
void (*free) (void*);
/** The user realloc function */
void* (*realloc)(void*, size_t);
toku_range_tree_local i; toku_range_tree_local i;
void (*incr_memory_size)(void *extra_memory_size, size_t s);
void (*decr_memory_size)(void *extra_memory_size, size_t s);
void *extra_memory_size;
}; };
/* /*
...@@ -53,7 +48,7 @@ static inline int toku__rt_p_cmp(toku_range_tree* tree, ...@@ -53,7 +48,7 @@ static inline int toku__rt_p_cmp(toku_range_tree* tree,
return 0; return 0;
} }
static inline int toku__rt_increase_buffer(toku_range_tree* tree, toku_range** buf, static inline int toku__rt_increase_buffer(toku_range_tree* tree UU(), toku_range** buf,
u_int32_t* buflen, u_int32_t num) { u_int32_t* buflen, u_int32_t num) {
assert(buf); assert(buf);
//TODO: SOME ATTRIBUTE TO REMOVE NEVER EXECUTABLE ERROR: assert(buflen); //TODO: SOME ATTRIBUTE TO REMOVE NEVER EXECUTABLE ERROR: assert(buflen);
...@@ -63,7 +58,7 @@ static inline int toku__rt_increase_buffer(toku_range_tree* tree, toku_range** b ...@@ -63,7 +58,7 @@ static inline int toku__rt_increase_buffer(toku_range_tree* tree, toku_range** b
temp_len = 1; temp_len = 1;
while (temp_len < num) while (temp_len < num)
temp_len *= 2; temp_len *= 2;
toku_range* temp_buf = tree->realloc(*buf, temp_len * sizeof(toku_range)); toku_range* temp_buf = toku_realloc(*buf, temp_len * sizeof(toku_range));
if (!temp_buf) if (!temp_buf)
return errno; return errno;
*buf = temp_buf; *buf = temp_buf;
...@@ -72,31 +67,31 @@ static inline int toku__rt_increase_buffer(toku_range_tree* tree, toku_range** b ...@@ -72,31 +67,31 @@ static inline int toku__rt_increase_buffer(toku_range_tree* tree, toku_range** b
return 0; return 0;
} }
static inline int toku_rt_super_create(toku_range_tree** upperptree, static inline int
toku_range_tree** ptree, toku_rt_super_create(toku_range_tree** upperptree,
int (*end_cmp)(const toku_point*,const toku_point*), toku_range_tree** ptree,
int (*data_cmp)(const TXNID,const TXNID), int (*end_cmp)(const toku_point*,const toku_point*),
BOOL allow_overlaps, int (*data_cmp)(const TXNID,const TXNID),
void* (*user_malloc) (size_t), bool allow_overlaps,
void (*user_free) (void*), void (*incr_memory_size)(void *extra_memory_size, size_t s),
void* (*user_realloc)(void*, size_t)) { void (*decr_memory_size)(void *extra_memory_size, size_t s),
void *extra_memory_size) {
toku_range_tree* temptree; toku_range_tree* temptree;
if (!upperptree || !ptree || !end_cmp || !data_cmp || if (!upperptree || !ptree || !end_cmp || !data_cmp)
!user_malloc || !user_free || !user_realloc)
return EINVAL; return EINVAL;
temptree = (toku_range_tree*)user_malloc(sizeof(toku_range_tree)); temptree = (toku_range_tree*) toku_malloc(sizeof(toku_range_tree));
if (!temptree) if (!temptree)
return ENOMEM; return ENOMEM;
//Any initializers go here. //Any initializers go here.
memset(temptree, 0, sizeof(*temptree));
temptree->end_cmp = end_cmp; temptree->end_cmp = end_cmp;
temptree->data_cmp = data_cmp; temptree->data_cmp = data_cmp;
temptree->allow_overlaps = allow_overlaps; temptree->allow_overlaps = allow_overlaps;
temptree->malloc = user_malloc; temptree->incr_memory_size = incr_memory_size;
temptree->free = user_free; temptree->decr_memory_size = decr_memory_size;
temptree->realloc = user_realloc; temptree->extra_memory_size = extra_memory_size;
*ptree = temptree; *ptree = temptree;
return 0; return 0;
......
src/range_tree/rangetree.h
View file @ 35a46f2e
...@@ -18,7 +18,6 @@ ...@@ -18,7 +18,6 @@
MIT Press and McGraw-Hill, 2001. ISBN 0-262-03293-7 MIT Press and McGraw-Hill, 2001. ISBN 0-262-03293-7
*/ */
//Defines BOOL data type.
#include <toku_portability.h> #include <toku_portability.h>
#include <brttypes.h> #include <brttypes.h>
#include <db.h> #include <db.h>
...@@ -67,7 +66,7 @@ struct __toku_range_tree; ...@@ -67,7 +66,7 @@ struct __toku_range_tree;
\return \return
- 0: Success. - 0: Success.
- EINVAL: If any pointer argument is NULL. */ - EINVAL: If any pointer argument is NULL. */
int toku_rt_get_allow_overlaps(toku_range_tree* tree, BOOL* allowed); int toku_rt_get_allow_overlaps(toku_range_tree* tree, bool* allowed);
/** /**
Creates a range tree. Creates a range tree.
...@@ -87,16 +86,16 @@ int toku_rt_get_allow_overlaps(toku_range_tree* tree, BOOL* allowed); ...@@ -87,16 +86,16 @@ int toku_rt_get_allow_overlaps(toku_range_tree* tree, BOOL* allowed);
\return \return
- 0: Success. - 0: Success.
- EINVAL: If any pointer argument is NULL. - EINVAL: If any pointer argument is NULL.
- EINVAL: If allow_overlaps = TRUE and the implementation does - EINVAL: If allow_overlaps = true and the implementation does
not support overlaps. not support overlaps.
- Other exit codes may be forwarded from underlying system calls. */ - Other exit codes may be forwarded from underlying system calls. */
int toku_rt_create(toku_range_tree** ptree, int toku_rt_create(toku_range_tree** ptree,
int (*end_cmp)(const toku_point*,const toku_point*), int (*end_cmp)(const toku_point*,const toku_point*),
int (*data_cmp)(const TXNID,const TXNID), int (*data_cmp)(const TXNID,const TXNID),
BOOL allow_overlaps, bool allow_overlaps,
void* (*user_malloc) (size_t), void (*incr_memory_size)(void *extra_memory_size, size_t s),
void (*user_free) (void*), void (*decr_memory_size)(void *extra_memory_size, size_t s),
void* (*user_realloc)(void*, size_t)); void *extra_memory_size);
/** /**
Destroys and frees a range tree. Destroys and frees a range tree.
...@@ -164,7 +163,7 @@ int toku_rt_find(toku_range_tree* tree,toku_interval* query, u_int32_t k, ...@@ -164,7 +163,7 @@ int toku_rt_find(toku_range_tree* tree,toku_interval* query, u_int32_t k,
- EDOM: If an equivalent range (left, right, and data according to - EDOM: If an equivalent range (left, right, and data according to
end_cmp and data_cmp) already exists in the tree. end_cmp and data_cmp) already exists in the tree.
If an overlapping range exists in the tree and If an overlapping range exists in the tree and
allow_overlaps == FALSE. allow_overlaps == false.
- Other exit codes may be forwarded from underlying system calls. - Other exit codes may be forwarded from underlying system calls.
*/ */
int toku_rt_insert(toku_range_tree* tree, toku_range* range); int toku_rt_insert(toku_range_tree* tree, toku_range* range);
...@@ -186,7 +185,7 @@ int toku_rt_delete(toku_range_tree* tree, toku_range* range); ...@@ -186,7 +185,7 @@ int toku_rt_delete(toku_range_tree* tree, toku_range* range);
/** /**
Finds the strict predecessor range of a point i.e. the rightmost range Finds the strict predecessor range of a point i.e. the rightmost range
completely to the left of the query point according to end_cmp. completely to the left of the query point according to end_cmp.
This operation is only defined if allow_overlaps == FALSE. This operation is only defined if allow_overlaps == false.
\param tree The range tree to search in. \param tree The range tree to search in.
\param point The point to query. Must be a valid argument to \param point The point to query. Must be a valid argument to
...@@ -203,12 +202,12 @@ int toku_rt_delete(toku_range_tree* tree, toku_range* range); ...@@ -203,12 +202,12 @@ int toku_rt_delete(toku_range_tree* tree, toku_range* range);
- Other exit codes may be forwarded from underlying system calls. - Other exit codes may be forwarded from underlying system calls.
*/ */
int toku_rt_predecessor(toku_range_tree* tree, toku_point* point, int toku_rt_predecessor(toku_range_tree* tree, toku_point* point,
toku_range* pred, BOOL* wasfound); toku_range* pred, bool* wasfound);
/** /**
Finds the strict successor range of a point i.e. the leftmost range Finds the strict successor range of a point i.e. the leftmost range
completely to the right of the query point according to end_cmp. completely to the right of the query point according to end_cmp.
This operation is only defined if allow_overlaps == FALSE. This operation is only defined if allow_overlaps == false.
\param tree The range tree to search in. \param tree The range tree to search in.
\param point The point to query. Must be a valid argument to \param point The point to query. Must be a valid argument to
...@@ -225,24 +224,21 @@ int toku_rt_predecessor(toku_range_tree* tree, toku_point* point, ...@@ -225,24 +224,21 @@ int toku_rt_predecessor(toku_range_tree* tree, toku_point* point,
- Other exit codes may be forwarded from underlying system calls. - Other exit codes may be forwarded from underlying system calls.
*/ */
int toku_rt_successor(toku_range_tree* tree, toku_point* point, int toku_rt_successor(toku_range_tree* tree, toku_point* point,
toku_range* succ, BOOL* wasfound); toku_range* succ, bool* wasfound);
/** /**
Finds the number of elements in the range tree. Finds the number of elements in the range tree.
\param tree The range tree. \param tree The range tree.
\param size A buffer to return the the number of elements \return The number of ranges in the range tree
in the range tree.
\return
- 0: Success.
- EINVAL: If any pointer argument is NULL.
*/ */
int toku_rt_get_size(toku_range_tree* tree, u_int32_t* size); size_t toku_rt_get_size(toku_range_tree* tree);
int toku_rt_iterate(toku_range_tree* tree, int (*f)(toku_range*,void*), void* extra); int toku_rt_iterate(toku_range_tree* tree, int (*f)(toku_range*,void*), void* extra);
void toku_rt_verify(toku_range_tree *tree); void toku_rt_verify(toku_range_tree *tree);
size_t toku_rt_memory_size(toku_range_tree *tree);
#if defined(__cplusplus) #if defined(__cplusplus)
} }
#endif #endif
......
src/range_tree/tests/run.h
View file @ 35a46f2e
...@@ -20,10 +20,10 @@ init_range (toku_range* range, int left, int right, int data) { ...@@ -20,10 +20,10 @@ init_range (toku_range* range, int left, int right, int data) {
} }
static void static void
setup_tree (BOOL allow_overlaps, BOOL insert, int left, int right, int data) { setup_tree (bool allow_overlaps, BOOL insert, int left, int right, int data) {
int r; int r;
toku_range range; toku_range range;
r = toku_rt_create(&tree, int_cmp, char_cmp, allow_overlaps, toku_malloc, toku_free, toku_realloc); r = toku_rt_create(&tree, int_cmp, char_cmp, allow_overlaps, test_incr_memory_size, test_decr_memory_size, NULL);
CKERR(r); CKERR(r);
if (insert) { if (insert) {
......
src/range_tree/tests/test.h
View file @ 35a46f2e
...@@ -100,3 +100,10 @@ verify_all_overlap (toku_interval* query, toku_range* list, unsigned listlen) { ...@@ -100,3 +100,10 @@ verify_all_overlap (toku_interval* query, toku_range* list, unsigned listlen) {
} }
} }
static inline void
test_incr_memory_size(void *extra UU(), size_t s UU()) {
}
static inline void
test_decr_memory_size(void *extra UU(), size_t s UU()) {
}
src/range_tree/tests/test_00000_createclose.c
View file @ 35a46f2e
...@@ -2,17 +2,17 @@ ...@@ -2,17 +2,17 @@
#include "test.h" #include "test.h"
static void test_create_close(BOOL allow_overlaps) { static void test_create_close(bool allow_overlaps) {
int r; int r;
#ifdef TOKU_RT_NOOVERLAPS #ifdef TOKU_RT_NOOVERLAPS
if (allow_overlaps) return; if (allow_overlaps) return;
#endif #endif
toku_range_tree *tree = NULL; toku_range_tree *tree = NULL;
r = toku_rt_create(&tree, int_cmp, char_cmp, allow_overlaps, toku_malloc, toku_free, toku_realloc); r = toku_rt_create(&tree, int_cmp, char_cmp, allow_overlaps, test_incr_memory_size, test_decr_memory_size, NULL);
CKERR(r); CKERR(r);
assert(tree!=NULL); assert(tree!=NULL);
BOOL temp; bool temp;
r = toku_rt_get_allow_overlaps(tree, &temp); r = toku_rt_get_allow_overlaps(tree, &temp);
CKERR(r); CKERR(r);
assert((temp != 0) == (allow_overlaps != 0)); assert((temp != 0) == (allow_overlaps != 0));
...@@ -22,32 +22,12 @@ static void test_create_close(BOOL allow_overlaps) { ...@@ -22,32 +22,12 @@ static void test_create_close(BOOL allow_overlaps) {
tree = NULL; tree = NULL;
} }
static void test_create_close_nomem(BOOL allow_overlaps) {
#ifdef TOKU_RT_NOOVERLAPS
if (allow_overlaps) return;
#endif
for (int i = 1; i <= 1; i++) {
mallocced = 0;
failon = i;
toku_range_tree *tree = NULL;
int r = toku_rt_create(&tree, int_cmp, char_cmp, allow_overlaps,
fail_malloc, toku_free, toku_realloc);
CKERR2(r, ENOMEM);
assert(tree==NULL);
}
}
int main(int argc, const char *argv[]) { int main(int argc, const char *argv[]) {
parse_args(argc, argv); parse_args(argc, argv);
test_create_close(false); test_create_close(false);
test_create_close(true); test_create_close(true);
test_create_close_nomem(false);
test_create_close_nomem(true);
return 0; return 0;
} }
......
src/range_tree/tests/test_00010_parameter_errors.c
View file @ 35a46f2e
...@@ -10,26 +10,16 @@ int main(int argc, const char *argv[]) { ...@@ -10,26 +10,16 @@ int main(int argc, const char *argv[]) {
parse_args(argc, argv); parse_args(argc, argv);
/* Create tests */ /* Create tests */
r = toku_rt_create(NULL, int_cmp, TXNID_cmp, FALSE, toku_malloc, toku_free, toku_realloc); r = toku_rt_create(NULL, int_cmp, TXNID_cmp, false, test_incr_memory_size, test_decr_memory_size, NULL);
CKERR2(r, EINVAL); CKERR2(r, EINVAL);
r = toku_rt_create(&tree, NULL, TXNID_cmp, FALSE, toku_malloc, toku_free, toku_realloc); r = toku_rt_create(&tree, NULL, TXNID_cmp, false, test_incr_memory_size, test_decr_memory_size, NULL);
CKERR2(r, EINVAL); CKERR2(r, EINVAL);
assert(tree == NULL); assert(tree == NULL);
r = toku_rt_create(&tree, int_cmp, NULL, FALSE, toku_malloc, toku_free, toku_realloc); r = toku_rt_create(&tree, int_cmp, NULL, false, test_incr_memory_size, test_decr_memory_size, NULL);
CKERR2(r, EINVAL); CKERR2(r, EINVAL);
r = toku_rt_create(&tree, int_cmp, TXNID_cmp, FALSE, NULL, toku_free, toku_realloc);
CKERR2(r, EINVAL);
r = toku_rt_create(&tree, int_cmp, TXNID_cmp, FALSE, toku_malloc, NULL, toku_realloc);
CKERR2(r, EINVAL);
r = toku_rt_create(&tree, int_cmp, TXNID_cmp, FALSE, toku_malloc, toku_free, NULL);
CKERR2(r, EINVAL);
assert(tree == NULL);
/* Close tests */ /* Close tests */
r = toku_rt_close(NULL); r = toku_rt_close(NULL);
CKERR2(r, EINVAL); CKERR2(r, EINVAL);
...@@ -38,7 +28,7 @@ int main(int argc, const char *argv[]) { ...@@ -38,7 +28,7 @@ int main(int argc, const char *argv[]) {
r = toku_rt_insert(NULL, &range); r = toku_rt_insert(NULL, &range);
CKERR2(r, EINVAL); CKERR2(r, EINVAL);
r = toku_rt_create(&tree, int_cmp, TXNID_cmp, FALSE, toku_malloc, toku_free, toku_realloc); r = toku_rt_create(&tree, int_cmp, TXNID_cmp, false, test_incr_memory_size, test_decr_memory_size, NULL);
CKERR(r); CKERR(r);
assert(tree != NULL); assert(tree != NULL);
...@@ -51,7 +41,7 @@ int main(int argc, const char *argv[]) { ...@@ -51,7 +41,7 @@ int main(int argc, const char *argv[]) {
r = toku_rt_delete(NULL, &range); r = toku_rt_delete(NULL, &range);
CKERR2(r, EINVAL); CKERR2(r, EINVAL);
r = toku_rt_create(&tree, int_cmp, TXNID_cmp, FALSE, toku_malloc, toku_free, toku_realloc); r = toku_rt_create(&tree, int_cmp, TXNID_cmp, false, test_incr_memory_size, test_decr_memory_size, NULL);
CKERR(r); CKERR(r);
assert(tree != NULL); assert(tree != NULL);
...@@ -68,7 +58,7 @@ int main(int argc, const char *argv[]) { ...@@ -68,7 +58,7 @@ int main(int argc, const char *argv[]) {
range.ends.right = (toku_point*)&stuff[1]; range.ends.right = (toku_point*)&stuff[1];
range.data = 0; range.data = 0;
r = toku_rt_create(&tree, int_cmp, TXNID_cmp, FALSE, toku_malloc, toku_free, toku_realloc); r = toku_rt_create(&tree, int_cmp, TXNID_cmp, false, test_incr_memory_size, test_decr_memory_size, NULL);
CKERR(r); CKERR(r);
assert(tree != NULL); assert(tree != NULL);
...@@ -99,8 +89,8 @@ int main(int argc, const char *argv[]) { ...@@ -99,8 +89,8 @@ int main(int argc, const char *argv[]) {
/* Predecessor tests */ /* Predecessor tests */
toku_point* foo = (toku_point*)&stuff[0]; toku_point* foo = (toku_point*)&stuff[0];
BOOL wasfound; bool wasfound;
r = toku_rt_create(&tree, int_cmp, TXNID_cmp, FALSE, toku_malloc, toku_free, toku_realloc); r = toku_rt_create(&tree, int_cmp, TXNID_cmp, false, test_incr_memory_size, test_decr_memory_size, NULL);
CKERR(r); CKERR(r);
assert(tree != NULL); assert(tree != NULL);
...@@ -119,7 +109,7 @@ int main(int argc, const char *argv[]) { ...@@ -119,7 +109,7 @@ int main(int argc, const char *argv[]) {
r = toku_rt_close(tree); CKERR(r); r = toku_rt_close(tree); CKERR(r);
#ifndef TOKU_RT_NOOVERLAPS #ifndef TOKU_RT_NOOVERLAPS
r = toku_rt_create(&tree, int_cmp, TXNID_cmp, TRUE, toku_malloc, toku_free, toku_realloc); r = toku_rt_create(&tree, int_cmp, TXNID_cmp, true, test_incr_memory_size, test_decr_memory_size, NULL);
CKERR(r); CKERR(r);
assert(tree != NULL); assert(tree != NULL);
...@@ -133,7 +123,7 @@ int main(int argc, const char *argv[]) { ...@@ -133,7 +123,7 @@ int main(int argc, const char *argv[]) {
/* Successor tests */ /* Successor tests */
r = toku_rt_create(&tree, int_cmp, TXNID_cmp, FALSE, toku_malloc, toku_free, toku_realloc); r = toku_rt_create(&tree, int_cmp, TXNID_cmp, false, test_incr_memory_size, test_decr_memory_size, NULL);
CKERR(r); CKERR(r);
assert(tree != NULL); assert(tree != NULL);
...@@ -152,7 +142,7 @@ int main(int argc, const char *argv[]) { ...@@ -152,7 +142,7 @@ int main(int argc, const char *argv[]) {
r = toku_rt_close(tree); CKERR(r); r = toku_rt_close(tree); CKERR(r);
#ifndef TOKU_RT_NOOVERLAPS #ifndef TOKU_RT_NOOVERLAPS
r = toku_rt_create(&tree, int_cmp, TXNID_cmp, TRUE, toku_malloc, toku_free, toku_realloc); r = toku_rt_create(&tree, int_cmp, TXNID_cmp, true, test_incr_memory_size, test_decr_memory_size, NULL);
CKERR(r); CKERR(r);
assert(tree != NULL); assert(tree != NULL);
...@@ -165,11 +155,11 @@ int main(int argc, const char *argv[]) { ...@@ -165,11 +155,11 @@ int main(int argc, const char *argv[]) {
#endif #endif
/* Get allow overlap */ /* Get allow overlap */
BOOL allowed; bool allowed;
r = toku_rt_get_allow_overlaps(NULL, &allowed); r = toku_rt_get_allow_overlaps(NULL, &allowed);
CKERR2(r, EINVAL); CKERR2(r, EINVAL);
r = toku_rt_create(&tree, int_cmp, TXNID_cmp, FALSE, toku_malloc, toku_free, toku_realloc); r = toku_rt_create(&tree, int_cmp, TXNID_cmp, false, test_incr_memory_size, test_decr_memory_size, NULL);
CKERR(r); CKERR(r);
assert(tree != NULL); assert(tree != NULL);
...@@ -180,16 +170,10 @@ int main(int argc, const char *argv[]) { ...@@ -180,16 +170,10 @@ int main(int argc, const char *argv[]) {
tree = NULL; tree = NULL;
/* size tests */ /* size tests */
r = toku_rt_create(&tree, int_cmp, TXNID_cmp, FALSE, toku_malloc, toku_free, toku_realloc); r = toku_rt_create(&tree, int_cmp, TXNID_cmp, false, test_incr_memory_size, test_decr_memory_size, NULL);
CKERR(r); CKERR(r);
assert(tree != NULL); assert(tree != NULL);
r = toku_rt_get_size(NULL, NULL); CKERR2(r, EINVAL);
r = toku_rt_get_size(tree, NULL); CKERR2(r, EINVAL);
u_int32_t tree_size;
r = toku_rt_get_size(NULL, &tree_size); CKERR2(r, EINVAL);
r = toku_rt_get_size(tree, &tree_size); CKERR(r);
r = toku_rt_close(tree); CKERR(r); r = toku_rt_close(tree); CKERR(r);
tree = NULL; tree = NULL;
......
src/range_tree/tests/test_00020_insertdelete.c
View file @ 35a46f2e
...@@ -21,7 +21,7 @@ int main(int argc, const char *argv[]) { ...@@ -21,7 +21,7 @@ int main(int argc, const char *argv[]) {
|-------B-------| |-------B-------|
*/ */
#ifndef TOKU_RT_NOOVERLAPS #ifndef TOKU_RT_NOOVERLAPS
r = toku_rt_create(&tree, int_cmp, char_cmp, TRUE, toku_malloc, toku_free, toku_realloc); r = toku_rt_create(&tree, int_cmp, char_cmp, true, test_incr_memory_size, test_decr_memory_size, NULL);
CKERR(r); CKERR(r);
/* Verify we can insert a trivial range and lose it. */ /* Verify we can insert a trivial range and lose it. */
...@@ -29,8 +29,7 @@ int main(int argc, const char *argv[]) { ...@@ -29,8 +29,7 @@ int main(int argc, const char *argv[]) {
range.ends.right = (toku_point*)&nums[1]; range.ends.right = (toku_point*)&nums[1];
range.data = (TXNID)letters[0]; range.data = (TXNID)letters[0];
r = toku_rt_insert(tree, &range); CKERR(r); r = toku_rt_insert(tree, &range); CKERR(r);
u_int32_t num_in_range; size_t num_in_range = toku_rt_get_size(tree);
r = toku_rt_get_size(tree, &num_in_range); CKERR(r);
assert(num_in_range == 1); assert(num_in_range == 1);
r = toku_rt_delete(tree, &range); CKERR(r); r = toku_rt_delete(tree, &range); CKERR(r);
...@@ -112,7 +111,7 @@ int main(int argc, const char *argv[]) { ...@@ -112,7 +111,7 @@ int main(int argc, const char *argv[]) {
|---A---| |---A---|
|---B---| |---B---|
*/ */
r = toku_rt_create(&tree, int_cmp, char_cmp, FALSE, toku_malloc, toku_free, toku_realloc); r = toku_rt_create(&tree, int_cmp, char_cmp, false, test_incr_memory_size, test_decr_memory_size, NULL);
CKERR(r); CKERR(r);
/* Verify we can insert a trivial range and lose it. */ /* Verify we can insert a trivial range and lose it. */
......
src/range_tree/tests/test_00025_memalloc.c
View file @ 35a46f2e
...@@ -3,20 +3,8 @@ ...@@ -3,20 +3,8 @@
#include "test.h" #include "test.h"
unsigned malloc_cnt;
unsigned malloc_cntl;
/* Controllable malloc failure: it fails only the ith time it is invoked */
static void* malloc_fail(size_t size) {
if (malloc_cntl == ++malloc_cnt) {
errno = ENOMEM;
return NULL;
} else
return toku_malloc(size);
}
static void static void
RunTest (BOOL f_overlaps_allowed) { RunTest (bool f_overlaps_allowed) {
int i, j; int i, j;
int r; int r;
toku_range_tree *tree; toku_range_tree *tree;
...@@ -30,7 +18,7 @@ RunTest (BOOL f_overlaps_allowed) { ...@@ -30,7 +18,7 @@ RunTest (BOOL f_overlaps_allowed) {
/* Insert and delete lots of ranges to force memory increase and decrease */ /* Insert and delete lots of ranges to force memory increase and decrease */
r = toku_rt_create(&tree, int_cmp, char_cmp, f_overlaps_allowed, toku_malloc, toku_free, toku_realloc); r = toku_rt_create(&tree, int_cmp, char_cmp, f_overlaps_allowed, test_incr_memory_size, test_decr_memory_size, NULL);
CKERR(r); CKERR(r);
/* Insert lots of ranges */ /* Insert lots of ranges */
...@@ -52,28 +40,16 @@ RunTest (BOOL f_overlaps_allowed) { ...@@ -52,28 +40,16 @@ RunTest (BOOL f_overlaps_allowed) {
} }
r = toku_rt_close(tree); CKERR(r); r = toku_rt_close(tree); CKERR(r);
tree = NULL; tree = NULL;
/* Force malloc to fail */
/* Failure when allocating the tree */
malloc_cnt = 0;
malloc_cntl = 1;
r = toku_rt_create(&tree, int_cmp, char_cmp, f_overlaps_allowed, malloc_fail, toku_free,
toku_realloc);
CKERR2(r, ENOMEM);
} }
int main(int argc, const char *argv[]) { int main(int argc, const char *argv[]) {
parse_args(argc, argv); parse_args(argc, argv);
#ifndef TOKU_RT_NOOVERLAPS #ifndef TOKU_RT_NOOVERLAPS
RunTest(TRUE); RunTest(true);
#endif #endif
RunTest(FALSE); RunTest(false);
return 0; return 0;
} }
src/range_tree/tests/test_00030_closeclean.c
View file @ 35a46f2e
...@@ -3,7 +3,7 @@ ...@@ -3,7 +3,7 @@
#include "test.h" #include "test.h"
static void static void
run_test (BOOL overlap_allowed) { run_test (bool overlap_allowed) {
int r; int r;
toku_range_tree *tree; toku_range_tree *tree;
toku_range range; toku_range range;
...@@ -17,15 +17,7 @@ run_test (BOOL overlap_allowed) { ...@@ -17,15 +17,7 @@ run_test (BOOL overlap_allowed) {
1 2 3 4 5 6 7 1 2 3 4 5 6 7
|---A-----------| |---A-----------|
*/ */
r = toku_rt_create( r = toku_rt_create(&tree, int_cmp, char_cmp, overlap_allowed, test_incr_memory_size, test_decr_memory_size, NULL);
&tree,
int_cmp,
char_cmp,
overlap_allowed,
toku_malloc,
toku_free,
toku_realloc
);
CKERR(r); CKERR(r);
range.ends.left = (toku_point*)&nums[1]; range.ends.left = (toku_point*)&nums[1];
...@@ -43,8 +35,8 @@ int main(int argc, const char *argv[]) { ...@@ -43,8 +35,8 @@ int main(int argc, const char *argv[]) {
parse_args(argc, argv); parse_args(argc, argv);
#ifndef TOKU_RT_NOOVERLAPS #ifndef TOKU_RT_NOOVERLAPS
run_test(TRUE); run_test(true);
#endif #endif
run_test(FALSE); run_test(false);
return 0; return 0;
} }
src/range_tree/tests/test_00040_find.c
View file @ 35a46f2e
...@@ -40,7 +40,7 @@ int main(int argc, const char *argv[]) { ...@@ -40,7 +40,7 @@ int main(int argc, const char *argv[]) {
|-------A-------| |-------A-------|
|-------B-------| |-------B-------|
*/ */
r = toku_rt_create(&tree, int_cmp, char_cmp, TRUE, toku_malloc, toku_free, toku_realloc); r = toku_rt_create(&tree, int_cmp, char_cmp, true, test_incr_memory_size, test_decr_memory_size, NULL);
CKERR(r); CKERR(r);
r = toku_rt_find(tree, &find_range, 4, &buf, &bufsize, &found); CKERR(r); r = toku_rt_find(tree, &find_range, 4, &buf, &bufsize, &found); CKERR(r);
...@@ -190,7 +190,7 @@ int main(int argc, const char *argv[]) { ...@@ -190,7 +190,7 @@ int main(int argc, const char *argv[]) {
find_range.left = (toku_point*)&nums[3]; find_range.left = (toku_point*)&nums[3];
find_range.right = (toku_point*)&nums[4]; find_range.right = (toku_point*)&nums[4];
r = toku_rt_create(&tree, int_cmp, char_cmp, FALSE, toku_malloc, toku_free, toku_realloc); r = toku_rt_create(&tree, int_cmp, char_cmp, false, test_incr_memory_size, test_decr_memory_size, NULL);
CKERR(r); CKERR(r);
r = toku_rt_find(tree, &find_range, 4, &buf, &bufsize, &found); CKERR(r); r = toku_rt_find(tree, &find_range, 4, &buf, &bufsize, &found); CKERR(r);
......
src/range_tree/tests/test_00047_find_memory.c
View file @ 35a46f2e
...@@ -20,11 +20,11 @@ rundelete (int rexpect, toku_range* todelete) { ...@@ -20,11 +20,11 @@ rundelete (int rexpect, toku_range* todelete) {
} }
static void static void
tests (BOOL allow_overlaps) { tests (bool allow_overlaps) {
toku_range insert; toku_range insert;
int i; int i;
/* Force buf to increase. */ /* Force buf to increase. */
setup_tree(allow_overlaps, FALSE, 0, 0, 0); setup_tree(allow_overlaps, false, 0, 0, 0);
for (i = 0; i < (int)numlen / 2; i++) { for (i = 0; i < (int)numlen / 2; i++) {
runinsert(0, init_range(&insert, i, i, 0)); runinsert(0, init_range(&insert, i, i, 0));
int j = numlen /2 + i; int j = numlen /2 + i;
...@@ -48,9 +48,9 @@ int main(int argc, const char *argv[]) { ...@@ -48,9 +48,9 @@ int main(int argc, const char *argv[]) {
for (i = 0; i < sizeof(nums) / sizeof(nums[0]); i++) nums[i] = i; for (i = 0; i < sizeof(nums) / sizeof(nums[0]); i++) nums[i] = i;
buflen = 2; buflen = 2;
buf = (toku_range*)toku_malloc(2 * sizeof(toku_range)); buf = (toku_range*)toku_malloc(2 * sizeof(toku_range));
tests(FALSE); tests(false);
#ifndef TOKU_RT_NOOVERLAPS #ifndef TOKU_RT_NOOVERLAPS
tests(TRUE); tests(true);
#endif #endif
tree = NULL; tree = NULL;
......
src/range_tree/tests/test_rt_clear.c
View file @ 35a46f2e
...@@ -26,15 +26,15 @@ int main(int argc, const char *argv[]) { ...@@ -26,15 +26,15 @@ int main(int argc, const char *argv[]) {
parse_args(argc, argv); parse_args(argc, argv);
toku_range_tree *tree; toku_range_tree *tree;
r = toku_rt_create(&tree, int_cmp, char_cmp, FALSE, toku_malloc, toku_free, toku_realloc); CKERR(r); r = toku_rt_create(&tree, int_cmp, char_cmp, false, test_incr_memory_size, test_decr_memory_size, NULL);
CKERR(r);
assert(count_ranges(tree) == 0); assert(count_ranges(tree) == 0);
const int nranges = 10; const int nranges = 10;
int nums[nranges]; int nums[nranges];
for (int i = 0; i < nranges; i++) { for (int i = 0; i < nranges; i++) {
assert(count_ranges(tree) == i); assert(count_ranges(tree) == i);
u_int32_t treesize = 0; u_int32_t treesize = toku_rt_get_size(tree);
r = toku_rt_get_size(tree, &treesize); CKERR(r);
assert(treesize == (u_int32_t) i); assert(treesize == (u_int32_t) i);
nums[i] = i; nums[i] = i;
toku_range range; my_init_range(&range, &nums[i], &nums[i], 'a'); toku_range range; my_init_range(&range, &nums[i], &nums[i], 'a');
......
src/range_tree/tests/test_rt_delete_edom.c
View file @ 35a46f2e
This diff is collapsed.
src/range_tree/tests/test_rt_memory_size.c 0 → 100644
View file @ 35a46f2e
This diff is collapsed.
src/ydb.c
View file @ 35a46f2e
This diff is collapsed.
toku_include/memory.h
View file @ 35a46f2e
This diff is collapsed.
windows/memory.c
View file @ 35a46f2e
This diff is collapsed.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7