mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-01-22 06:44:16 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

#2921 refs[t:2921] remove obsolete memory functions

Browse source 
git-svn-id: file:///svn/toku/tokudb@23625 c7de825b-a66e-492c-adef-691d508d4ae1
This commit is contained in:
Rich Prohaska 2013-04-16 23:59:22 -04:00 • committed by Yoni Fogel
parent 3538bf9888
commit 8cf78727aa
25 changed files with 101 additions and 157 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
newbrt/brtdump.c
View file

@ -453,7 +453,6 @@ main (int argc, const char *const argv[]) {
dump_node_wrapper, &info, TRUE, TRUE);
}
toku_brtheader_free(h);
toku_malloc_cleanup();
return 0;
}

1
newbrt/tdb-recover.c
View file

@ -41,6 +41,5 @@ int recovery_main (int argc, const char *const argv[]) {
fprintf(stderr, "Recovery failed\n");
return(1);
}
toku_malloc_cleanup();
return 0;
}

5
newbrt/tests/benchmark-test.c
View file

@ -194,10 +194,7 @@ test_main (int argc, const char *argv[]) {
fflush(stdout);
}
unlink(fname);
if (verbose>1) {
toku_malloc_report();
}
toku_malloc_cleanup();
return 0;
}

1
newbrt/tests/brt-serialize-test.c
View file

@ -149,6 +149,5 @@ test_main (int argc __attribute__((__unused__)), const char *argv[] __attribute_
toku_memory_check = 1;
test_serialize_leaf();
test_serialize_nonleaf();
toku_malloc_cleanup();
return 0;
}

2
newbrt/tests/brt-test-cursor-2.c
View file

@ -102,8 +102,6 @@ test_main (int argc , const char *argv[]) {
DB a_db;
DB *db = &a_db;
test_brt_cursor(db);
toku_malloc_cleanup();
if (verbose) printf("test ok\n");
return 0;
}

34
newbrt/tests/brt-test-cursor.c
View file

@ -885,40 +885,40 @@ static void test_brt_cursor(DB *db) {
test_multiple_brt_cursors(3, db);
for (n=0; n<test_brt_cursor_limit; n += test_brt_cursor_inc) {
test_brt_cursor_first(n, db); toku_memory_check_all_free();
test_brt_cursor_first(n, db);
}
for (n=0; n<test_brt_cursor_limit; n += test_brt_cursor_inc) {
test_brt_cursor_rfirst(n, db); toku_memory_check_all_free();
test_brt_cursor_rfirst(n, db);
}
for (n=0; n<test_brt_cursor_limit; n += test_brt_cursor_inc) {
test_brt_cursor_walk(n, db); toku_memory_check_all_free();
test_brt_cursor_walk(n, db);
}
for (n=0; n<test_brt_cursor_limit; n += test_brt_cursor_inc) {
test_brt_cursor_last(n, db); toku_memory_check_all_free();
test_brt_cursor_last(n, db);
}
for (n=0; n<test_brt_cursor_limit; n += test_brt_cursor_inc) {
test_brt_cursor_first_last(n, db); toku_memory_check_all_free();
test_brt_cursor_first_last(n, db);
}
for (n=0; n<test_brt_cursor_limit; n += test_brt_cursor_inc) {
test_brt_cursor_split(n, db); toku_memory_check_all_free();
test_brt_cursor_split(n, db);
}
for (n=0; n<test_brt_cursor_limit; n += test_brt_cursor_inc) {
test_brt_cursor_rand(n, db); toku_memory_check_all_free();
test_brt_cursor_rand(n, db);
}
for (n=0; n<test_brt_cursor_limit; n += test_brt_cursor_inc) {
test_brt_cursor_rwalk(n, db); toku_memory_check_all_free();
test_brt_cursor_rwalk(n, db);
}
test_brt_cursor_set(1000, DB_SET, db); toku_memory_check_all_free();
test_brt_cursor_set(10000, DB_SET, db); toku_memory_check_all_free();
test_brt_cursor_set(1000, DB_SET_RANGE, db); toku_memory_check_all_free();
test_brt_cursor_set_range(1000, db); toku_memory_check_all_free();
test_brt_cursor_set_range(10000, db); toku_memory_check_all_free();
test_brt_cursor_set(1000, DB_SET, db);
test_brt_cursor_set(10000, DB_SET, db);
test_brt_cursor_set(1000, DB_SET_RANGE, db);
test_brt_cursor_set_range(1000, db);
test_brt_cursor_set_range(10000, db);
test_brt_cursor_delete(1000, db); toku_memory_check_all_free();
test_multiple_brt_cursor_walk(10000, db); toku_memory_check_all_free();
test_multiple_brt_cursor_walk(100000, db); toku_memory_check_all_free();
test_brt_cursor_delete(1000, db);
test_multiple_brt_cursor_walk(10000, db);
test_multiple_brt_cursor_walk(100000, db);
}
@ -929,8 +929,6 @@ test_main (int argc , const char *argv[]) {
DB a_db;
DB *db = &a_db;
test_brt_cursor(db);
toku_malloc_cleanup();
if (verbose) printf("test ok\n");
return 0;
}

105
newbrt/tests/brt-test.c
View file

@ -22,7 +22,7 @@ static void test_dump_empty_db (void) {
if (verbose) toku_dump_brt(stdout, t);
r = toku_close_brt(t, 0); assert(r==0);
r = toku_cachetable_close(&ct); assert(r==0);
toku_memory_check_all_free();
}
/* Test running multiple trees in different files */
@ -35,7 +35,7 @@ static void test_multiple_files_of_size (int size) {
if (verbose) printf("test_multiple_files_of_size(%d)\n", size);
unlink(n0);
unlink(n1);
toku_memory_check_all_free();
r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER); assert(r==0);
r = toku_open_brt(n0, 1, &t0, size, ct, null_txn, toku_builtin_compare_fun, null_db); assert(r==0);
r = toku_open_brt(n1, 1, &t1, size, ct, null_txn, toku_builtin_compare_fun, null_db); assert(r==0);
@ -57,7 +57,7 @@ static void test_multiple_files_of_size (int size) {
r = toku_close_brt(t0, 0); assert(r==0);
r = toku_close_brt(t1, 0); assert(r==0);
r = toku_cachetable_close(&ct); assert(r==0);
toku_memory_check_all_free();
/* Now see if the data is all there. */
r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER); assert(r==0);
@ -78,7 +78,7 @@ static void test_multiple_files_of_size (int size) {
r = toku_close_brt(t0, 0); assert(r==0);
r = toku_close_brt(t1, 0); assert(r==0);
r = toku_cachetable_close(&ct); assert(r==0);
toku_memory_check_all_free();
}
static void test_multiple_files (void) {
@ -93,7 +93,7 @@ static void test_multiple_brts_one_db_one_file (void) {
CACHETABLE ct;
BRT trees[MANYN];
if (verbose) printf("test_multiple_brts_one_db_one_file:");
toku_memory_check_all_free();
unlink(fname);
r = toku_brt_create_cachetable(&ct, 32, ZERO_LSN, NULL_LOGGER); assert(r==0);
for (i=0; i<MANYN; i++) {
@ -117,7 +117,7 @@ static void test_multiple_brts_one_db_one_file (void) {
r=toku_close_brt(trees[i], 0); assert(r==0);
}
r = toku_cachetable_close(&ct); assert(r==0);
toku_memory_check_all_free();
if (verbose) printf(" ok\n");
}
@ -132,14 +132,14 @@ static void test_read_what_was_written (void) {
if (verbose) printf("test_read_what_was_written(): "); fflush(stdout);
unlink(fname);
toku_memory_check_all_free();
r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER); assert(r==0);
r = toku_open_brt(fname, 1, &brt, 1<<12, ct, null_txn, toku_builtin_compare_fun, null_db); assert(r==0);
r = toku_close_brt(brt, 0); assert(r==0);
r = toku_cachetable_close(&ct); assert(r==0);
toku_memory_check_all_free();
/* Now see if we can read an empty tree in. */
r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER); assert(r==0);
@ -154,7 +154,7 @@ static void test_read_what_was_written (void) {
r = toku_close_brt(brt, 0); assert(r==0);
r = toku_cachetable_close(&ct); assert(r==0);
toku_memory_check_all_free();
/* Now see if we can read it in and get the value. */
r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER); assert(r==0);
@ -216,7 +216,7 @@ static void test_read_what_was_written (void) {
if (verbose) printf("%s:%d About to close %p\n", __FILE__, __LINE__, ct);
r = toku_cachetable_close(&ct); assert(r==0);
toku_memory_check_all_free();
r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER); assert(r==0);
r = toku_open_brt(fname, 0, &brt, 1<<12, ct, null_txn, toku_builtin_compare_fun, null_db); assert(r==0);
@ -235,7 +235,7 @@ static void test_read_what_was_written (void) {
r = toku_close_brt(brt, 0); assert(r==0);
r = toku_cachetable_close(&ct); assert(r==0);
toku_memory_check_all_free();
if (verbose) printf(" ok\n");
@ -249,7 +249,7 @@ static void test_cursor_last_empty(void) {
int r;
if (verbose) printf("%s", __FUNCTION__);
unlink(fname);
toku_memory_check_all_free();
//printf("%s:%d %d alloced\n", __FILE__, __LINE__, toku_get_n_items_malloced()); toku_print_malloced_items();
r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER); assert(r==0);
//printf("%s:%d %d alloced\n", __FILE__, __LINE__, toku_get_n_items_malloced()); toku_print_malloced_items();
@ -272,7 +272,7 @@ static void test_cursor_last_empty(void) {
//printf("%s:%d %d alloced\n", __FILE__, __LINE__, toku_get_n_items_malloced()); toku_print_malloced_items();
r = toku_cachetable_close(&ct); assert(r==0);
//printf("%s:%d %d alloced\n", __FILE__, __LINE__, toku_get_n_items_malloced()); toku_print_malloced_items();
toku_memory_check_all_free();
}
static void test_cursor_next (void) {
@ -283,7 +283,7 @@ static void test_cursor_next (void) {
DBT kbt, vbt;
unlink(fname);
toku_memory_check_all_free();
r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER); assert(r==0);
//printf("%s:%d %d alloced\n", __FILE__, __LINE__, toku_get_n_items_malloced()); toku_print_malloced_items();
r = toku_open_brt(fname, 1, &brt, 1<<12, ct, null_txn, toku_builtin_compare_fun, null_db); assert(r==0);
@ -323,7 +323,7 @@ static void test_cursor_next (void) {
//printf("%s:%d %d alloced\n", __FILE__, __LINE__, toku_get_n_items_malloced()); toku_print_malloced_items();
r = toku_cachetable_close(&ct); assert(r==0);
//printf("%s:%d %d alloced\n", __FILE__, __LINE__, toku_get_n_items_malloced()); toku_print_malloced_items();
toku_memory_check_all_free();
}
@ -351,7 +351,7 @@ static void test_wrongendian_compare (int wrong_p, unsigned int N) {
unsigned int i;
unlink(fname);
toku_memory_check_all_free();
{
char a[4]={0,1,0,0};
@ -442,7 +442,7 @@ static void test_wrongendian_compare (int wrong_p, unsigned int N) {
assert(r==0);
}
r = toku_cachetable_close(&ct); assert(r==0);
toku_memory_check_all_free();
}
static int test_brt_cursor_keycompare(DB *db __attribute__((unused)), const DBT *a, const DBT *b) {
@ -487,7 +487,7 @@ static void test_brt_limits(void) {
int bsize = 1024;
int kvsize = 4;
while (kvsize < bsize/2) {
test_large_kv(bsize, kvsize, kvsize); toku_memory_check_all_free();
test_large_kv(bsize, kvsize, kvsize);
kvsize *= 2;
}
}
@ -774,19 +774,19 @@ static void test_insert_delete_lookup(int n) {
static void test_brt_delete(void) {
test_brt_delete_empty(); toku_memory_check_all_free();
test_brt_delete_present(1); toku_memory_check_all_free();
test_brt_delete_present(100); toku_memory_check_all_free();
test_brt_delete_present(500); toku_memory_check_all_free();
test_brt_delete_not_present(1); toku_memory_check_all_free();
test_brt_delete_not_present(100); toku_memory_check_all_free();
test_brt_delete_not_present(500); toku_memory_check_all_free();
test_brt_delete_cursor_first(1); toku_memory_check_all_free();
test_brt_delete_cursor_first(100); toku_memory_check_all_free();
test_brt_delete_cursor_first(500); toku_memory_check_all_free();
test_brt_delete_cursor_first(10000); toku_memory_check_all_free();
test_insert_delete_lookup(2); toku_memory_check_all_free();
test_insert_delete_lookup(512); toku_memory_check_all_free();
test_brt_delete_empty();
test_brt_delete_present(1);
test_brt_delete_present(100);
test_brt_delete_present(500);
test_brt_delete_not_present(1);
test_brt_delete_not_present(100);
test_brt_delete_not_present(500);
test_brt_delete_cursor_first(1);
test_brt_delete_cursor_first(100);
test_brt_delete_cursor_first(500);
test_brt_delete_cursor_first(10000);
test_insert_delete_lookup(2);
test_insert_delete_lookup(512);
}
static void test_new_brt_cursor_create_close (void) {
@ -1207,33 +1207,33 @@ static void test_new_brt_cursor_set(int n, int cursor_op, DB *db) {
static void test_new_brt_cursors(int dup_mode) {
assert(dup_mode==0);
test_new_brt_cursor_create_close(); toku_memory_check_all_free();
test_new_brt_cursor_first(8, dup_mode); toku_memory_check_all_free();
test_new_brt_cursor_last(8, dup_mode); toku_memory_check_all_free();
test_new_brt_cursor_last(512, dup_mode); toku_memory_check_all_free();
test_new_brt_cursor_next(8, dup_mode); toku_memory_check_all_free();
test_new_brt_cursor_prev(8, dup_mode); toku_memory_check_all_free();
test_new_brt_cursor_current(8, dup_mode); toku_memory_check_all_free();
test_new_brt_cursor_next(512, dup_mode); toku_memory_check_all_free();
test_new_brt_cursor_set_range(512, dup_mode); toku_memory_check_all_free();
test_new_brt_cursor_set(512, DB_SET, 0); toku_memory_check_all_free();
test_new_brt_cursor_create_close();
test_new_brt_cursor_first(8, dup_mode);
test_new_brt_cursor_last(8, dup_mode);
test_new_brt_cursor_last(512, dup_mode);
test_new_brt_cursor_next(8, dup_mode);
test_new_brt_cursor_prev(8, dup_mode);
test_new_brt_cursor_current(8, dup_mode);
test_new_brt_cursor_next(512, dup_mode);
test_new_brt_cursor_set_range(512, dup_mode);
test_new_brt_cursor_set(512, DB_SET, 0);
}
static void brt_blackbox_test (void) {
toku_memory_check = 1;
test_wrongendian_compare(0, 2); toku_memory_check_all_free();
test_wrongendian_compare(1, 2); toku_memory_check_all_free();
test_wrongendian_compare(1, 257); toku_memory_check_all_free();
test_wrongendian_compare(1, 1000); toku_memory_check_all_free();
test_wrongendian_compare(0, 2);
test_wrongendian_compare(1, 2);
test_wrongendian_compare(1, 257);
test_wrongendian_compare(1, 1000);
test_new_brt_cursors(0);
test_read_what_was_written(); toku_memory_check_all_free(); if (verbose) printf("did read_what_was_written\n");
test_cursor_next(); toku_memory_check_all_free();
test_cursor_last_empty(); toku_memory_check_all_free();
test_multiple_brts_one_db_one_file(); toku_memory_check_all_free();
test_dump_empty_db(); toku_memory_check_all_free();
toku_memory_check_all_free();
toku_memory_check_all_free();
test_read_what_was_written(); if (verbose) printf("did read_what_was_written\n");
test_cursor_next();
test_cursor_last_empty();
test_multiple_brts_one_db_one_file();
test_dump_empty_db();
if (verbose) printf("test_multiple_files\n");
test_multiple_files();
@ -1260,7 +1260,6 @@ test_main (int argc , const char *argv[]) {
default_parse_args(argc, argv);
brt_blackbox_test();
toku_malloc_cleanup();
if (verbose) printf("test ok\n");
return 0;
}

6
newbrt/tests/brt-test0.c
View file

@ -14,7 +14,7 @@ static void test0 (void) {
char fname[]= __FILE__ "0.brt";
if (verbose) printf("%s:%d test0\n", __FILE__, __LINE__);
toku_memory_check=1;
toku_memory_check_all_free();
r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER);
assert(r==0);
if (verbose) printf("%s:%d test0\n", __FILE__, __LINE__);
@ -27,7 +27,7 @@ static void test0 (void) {
//printf("%s:%d n_items_malloced=%lld\n", __FILE__, __LINE__, n_items_malloced);
r = toku_cachetable_close(&ct);
assert(r==0);
toku_memory_check_all_free();
}
int
@ -37,7 +37,7 @@ test_main (int argc , const char *argv[]) {
test0();
if (verbose) printf("test0 B\n");
test0(); /* Make sure it works twice. */
toku_malloc_cleanup();
if (verbose) printf("test0 ok\n");
return 0;
}

6
newbrt/tests/brt-test1.c
View file

@ -14,7 +14,7 @@ static void test1 (void) {
char fname[]= __FILE__ "1.brt";
DBT k,v;
toku_memory_check=1;
toku_memory_check_all_free();
r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER);
assert(r==0);
unlink(fname);
@ -29,7 +29,7 @@ static void test1 (void) {
}
r = toku_close_brt(t, 0); assert(r==0);
r = toku_cachetable_close(&ct); assert(r==0);
toku_memory_check_all_free();
if (verbose) printf("test1 ok\n");
}
int
@ -37,7 +37,7 @@ test_main (int argc , const char *argv[]) {
default_parse_args(argc, argv);
if (verbose) printf("test1\n");
test1();
toku_malloc_cleanup();
if (verbose) printf("test1 ok\n");
return 0;
}

6
newbrt/tests/brt-test2.c
View file

@ -15,7 +15,7 @@ static void test2 (int memcheck, int limit) {
char fname[]= __FILE__ "2.brt";
toku_memory_check=memcheck;
if (verbose) printf("%s:%d checking\n", __FILE__, __LINE__);
toku_memory_check_all_free();
r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER); assert(r==0);
unlink(fname);
r = toku_open_brt(fname, 1, &t, 1024, ct, null_txn, toku_builtin_compare_fun, null_db);
@ -43,7 +43,7 @@ static void test2 (int memcheck, int limit) {
r = toku_verify_brt(t); assert(r==0);
r = toku_close_brt(t, 0); assert(r==0);
r = toku_cachetable_close(&ct); assert(r==0);
toku_memory_check_all_free();
if (verbose) printf("test2 ok\n");
}
@ -57,7 +57,7 @@ test_main (int argc , const char *argv[]) {
test2(0, 27);
test2(0, 212);
test2(0, 4096);
toku_malloc_cleanup();
if (verbose) printf("test1 ok\n");
return 0;
}

6
newbrt/tests/brt-test3.c
View file

@ -17,7 +17,7 @@ static void test3 (int nodesize, int count, int memcheck) {
int i;
CACHETABLE ct;
toku_memory_check=memcheck;
toku_memory_check_all_free();
r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER); assert(r==0);
gettimeofday(&t0, 0);
unlink(fname);
@ -33,7 +33,7 @@ static void test3 (int nodesize, int count, int memcheck) {
r = toku_verify_brt(t); assert(r==0);
r = toku_close_brt(t, 0); assert(r==0);
r = toku_cachetable_close(&ct); assert(r==0);
toku_memory_check_all_free();
gettimeofday(&t1, 0);
{
double diff = toku_tdiff(&t1, &t0);
@ -71,7 +71,7 @@ test_main (int argc , const char *argv[]) {
default_parse_args(argc, argv);
brt_blackbox_test();
toku_malloc_cleanup();
if (verbose) printf("test ok\n");
return 0;
}

6
newbrt/tests/brt-test4.c
View file

@ -19,7 +19,7 @@ static void test4 (int nodesize, int count, int memcheck) {
gettimeofday(&t0, 0);
unlink(fname);
toku_memory_check=memcheck;
toku_memory_check_all_free();
r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER); assert(r==0);
r = toku_open_brt(fname, 1, &t, nodesize, ct, null_txn, toku_builtin_compare_fun, null_db); assert(r==0);
for (i=0; i<count; i++) {
@ -33,7 +33,7 @@ static void test4 (int nodesize, int count, int memcheck) {
r = toku_verify_brt(t); assert(r==0);
r = toku_close_brt(t, 0); assert(r==0);
r = toku_cachetable_close(&ct); assert(r==0);
toku_memory_check_all_free();
gettimeofday(&t1, 0);
{
double diff = toku_tdiff(&t1, &t0);
@ -65,7 +65,7 @@ test_main (int argc , const char *argv[]) {
default_parse_args(argc, argv);
brt_blackbox_test();
toku_malloc_cleanup();
if (verbose) printf("test ok\n");
return 0;
}

6
newbrt/tests/brt-test5.c
View file

@ -15,7 +15,7 @@ static void test5 (void) {
int i;
CACHETABLE ct;
char fname[]= __FILE__ ".brt";
toku_memory_check_all_free();
MALLOC_N(limit,values);
for (i=0; i<limit; i++) values[i]=-1;
unlink(fname);
@ -51,7 +51,7 @@ static void test5 (void) {
toku_free(values);
r = toku_close_brt(t, 0); assert(r==0);
r = toku_cachetable_close(&ct); assert(r==0);
toku_memory_check_all_free();
}
int
@ -59,7 +59,7 @@ test_main (int argc , const char *argv[]) {
default_parse_args(argc, argv);
test5();
toku_malloc_cleanup();
if (verbose) printf("test ok\n");
return 0;
}

4
newbrt/tests/brtloader-error-injector.h
View file

@ -110,7 +110,7 @@ static void *my_malloc(size_t n) {
(void) toku_sync_fetch_and_increment_int32(&my_big_malloc_count); // my_big_malloc_count++;
if (do_malloc_errors) {
caller = __builtin_return_address(1);
if ((void*)toku_xmalloc <= caller && caller <= (void*)toku_malloc_report)
if ((void*)toku_xmalloc <= caller && caller <= (void*)toku_set_func_malloc)
goto skip;
if (event_add_and_fetch()== event_count_trigger) {
event_hit();
@ -135,7 +135,7 @@ static void *my_realloc(void *p, size_t n) {
(void) toku_sync_increment_and_fetch_int32(&my_big_realloc_count); // my_big_realloc_count++;
if (do_realloc_errors) {
caller = __builtin_return_address(1);
if ((void*)toku_xrealloc <= caller && caller <= (void*)toku_malloc_report)
if ((void*)toku_xrealloc <= caller && caller <= (void*)toku_set_func_malloc)
goto skip;
if (event_add_and_fetch() == event_count_trigger) {
event_hit();

4
newbrt/tests/brtloader-test-merge-files-dbufio.c
View file

@ -184,7 +184,7 @@ static void *my_malloc(size_t n) {
my_big_malloc_count++;
if (my_malloc_event) {
caller = __builtin_return_address(1);
if ((void*)toku_xmalloc <= caller && caller <= (void*)toku_malloc_report)
if ((void*)toku_xmalloc <= caller && caller <= (void*)toku_set_func_malloc)
goto skip;
event_count++;
if (event_count == event_count_trigger) {
@ -210,7 +210,7 @@ static void *my_realloc(void *p, size_t n) {
my_big_realloc_count++;
if (do_realloc_errors) {
caller = __builtin_return_address(1);
if ((void*)toku_xrealloc <= caller && caller <= (void*)toku_malloc_report)
if ((void*)toku_xrealloc <= caller && caller <= (void*)toku_set_func_malloc)
goto skip;
event_count++;
if (event_count == event_count_trigger) {

4
newbrt/tests/cachetable-test.c
View file

@ -294,7 +294,7 @@ static void test0 (void) {
assert(r==0);
assert(expect_n_flushes==0);
expect_f = 0;
toku_memory_check_all_free();
}
static void flush_n (CACHEFILE f __attribute__((__unused__)), int UU(fd), CACHEKEY key __attribute__((__unused__)),
@ -745,7 +745,7 @@ test_main (int argc, const char *argv[]) {
}
test_mutex_destroy();
toku_malloc_cleanup();
if (verbose) printf("ok\n");
return 0;
}

2
newbrt/tests/cachetable-test2.c
View file

@ -250,7 +250,7 @@ test_main (int argc, const char *argv[]) {
test_mutex_init();
test_chaining();
test_mutex_destroy();
toku_malloc_cleanup();
if (verbose) printf("ok\n");
return 0;
}

2
newbrt/tests/fifo-test.c
View file

@ -87,6 +87,6 @@ test_main(int argc, const char *argv[]) {
test_fifo_create();
test_fifo_enq(4);
test_fifo_enq(512);
toku_malloc_cleanup();
return 0;
}

2
newbrt/tests/keyrange-unflat.c
View file

@ -65,7 +65,7 @@ test_main (int argc , const char *argv[]) {
default_parse_args(argc, argv);
test_flat();
toku_malloc_cleanup();
if (verbose) printf("test ok\n");
return 0;
}

2
newbrt/tests/keyrange.c
View file

@ -69,7 +69,7 @@ test_main (int argc , const char *argv[]) {
default_parse_args(argc, argv);
test_flat();
toku_malloc_cleanup();
if (verbose) printf("test ok\n");
return 0;
}

2
newbrt/tests/test-brt-overflow.c
View file

@ -45,6 +45,6 @@ test_main (int argc, const char *argv[]) {
verbose = 0;
}
test_overflow();
toku_malloc_cleanup();
return 0;
}

2
newbrt/tests/test-inc-split.c
View file

@ -151,6 +151,6 @@ test_main (int argc __attribute__((__unused__)), const char *argv[] __attribute_
}
}
#endif
toku_malloc_cleanup();
return 0;
}

4
newbrt/tests/ybt-test.c
View file

@ -47,7 +47,7 @@ static void ybt_test0 (void) {
cleanup_and_free(&v0);
cleanup_and_free(&v1);
toku_memory_check_all_free();
/* See if we can probe to find out how big something is by setting ulen=0 with YBT_USERMEM */
toku_init_dbt(&t0);
@ -80,7 +80,7 @@ static void ybt_test0 (void) {
assert(strcmp(t0.data, "provincial")==0);
toku_free(t0.data);
toku_memory_check_all_free();
}
int

19
src/ydb.c
View file

@ -137,21 +137,6 @@ ydb_getf_do_nothing(DBT const* UU(key), DBT const* UU(val), void* UU(extra)) {
return 0;
}
/* the ydb reference is used to cleanup the library when there are no more references to it */
static int toku_ydb_refs = 0;
static inline void ydb_add_ref(void) {
++toku_ydb_refs;
}
static inline void ydb_unref(void) {
assert(toku_ydb_refs > 0);
if (--toku_ydb_refs == 0) {
/* call global destructors */
toku_malloc_cleanup();
}
}
/* env methods */
static int toku_env_close(DB_ENV *env, u_int32_t flags);
static int toku_env_set_data_dir(DB_ENV * env, const char *dir);
@ -935,7 +920,6 @@ static int toku_env_close(DB_ENV * env, u_int32_t flags) {
env->i = NULL;
toku_free(env);
env = NULL;
ydb_unref();
if ((flags!=0) && !(flags==DB_CLOSE_DONT_TRIM_LOG))
r = EINVAL;
return r;
@ -1829,7 +1813,6 @@ static int toku_env_create(DB_ENV ** envp, u_int32_t flags) {
assert(result->i->open_dbs);
}
ydb_add_ref();
*envp = result;
r = 0;
cleanup:
@ -2272,7 +2255,6 @@ db_close_before_brt(DB *db, u_int32_t UU(flags)) {
if (db->i->dname) toku_free(db->i->dname);
toku_free(db->i);
toku_free(db);
ydb_unref();
if (r1) return r1;
if (r2) return r2;
if (is_panicked) return EINVAL;
@ -4880,7 +4862,6 @@ static int toku_db_create(DB ** db, DB_ENV * env, u_int32_t flags) {
toku_free(result);
return r;
}
ydb_add_ref();
*db = result;
return 0;
}

26
windows/memory.c
View file

@ -113,32 +113,6 @@ toku_xstrdup (const char *s)
return toku_xmemdup(s, strlen(s)+1);
}
void
toku_memory_check_all_free (void)
{
}
int
toku_get_n_items_malloced (void)
{
return 0;
}
void
toku_print_malloced_items (void)
{
}
void
toku_malloc_report (void)
{
}
void
toku_malloc_cleanup (void)
{
}
int
toku_set_func_malloc(malloc_fun_t f) {
t_malloc = f;