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

[t:3999] working on orthopush-flush, got a new test to a point where it doesn't fail (but the test is incomplete)

Browse source 
git-svn-id: file:///svn/toku/tokudb@35606 c7de825b-a66e-492c-adef-691d508d4ae1
This commit is contained in:
Leif Walsh 2013-04-16 23:59:51 -04:00 • committed by Yoni Fogel
parent 8945913952
commit 1475600191
3 changed files with 79 additions and 65 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
newbrt/brt-internal.h
View file

@ -788,6 +788,18 @@ brt_leaf_apply_cmd_once (
uint64_t *workdonep
);
void
brt_leaf_put_cmd (
BRT t,
BASEMENTNODE bn,
SUBTREE_EST se,
BRT_MSG cmd,
bool* made_change,
uint64_t *workdone,
OMT snapshot_txnids,
OMT live_list_reverse
);
void toku_apply_cmd_to_leaf(BRT t, BRTNODE node, BRT_MSG cmd, bool *made_change, uint64_t *workdone, OMT snapshot_txnids, OMT live_list_reverse);
void toku_reset_root_xid_that_created(BRT brt, TXNID new_root_xid_that_created);

2
newbrt/brt.c
View file

@ -2196,7 +2196,7 @@ static int do_update(BRT t, BASEMENTNODE bn, SUBTREE_EST se, BRT_MSG cmd, int id
}
// Should be renamed as something like "apply_cmd_to_basement()."
static void
void
brt_leaf_put_cmd (
BRT t,
BASEMENTNODE bn,

130
newbrt/tests/orthopush-flush.c
View file

@ -1,10 +1,11 @@
/* -*- mode: C; c-basic-offset: 4 -*- */
#ident "$Id: orthopush-flush.c 35539 2011-10-11 02:13:02Z leifwalsh $"
#ident "$Id$"
#ident "Copyright (c) 2007-2011 Tokutek Inc. All rights reserved."
#include "test.h"
#include "includes.h"
#include "ule.h"
static TOKUTXN const null_txn = 0;
static DB * const null_db = 0;
@ -33,24 +34,22 @@ rand_bytes(void *dest, int size)
}
}
#if 0
static void
rand_bytes_limited(void *dest, int size)
{
long *l;
for (l = dest; (unsigned int) size >= (sizeof *l); ++l, size -= (sizeof *l)) {
for (l = dest; (size_t) size >= (sizeof *l); ++l, size -= (sizeof *l)) {
char c = random() & 0xff;
int i = 0;
unsigned int i = 0;
for (char *p = (char *) l; i < (sizeof *l); ++i) {
*p = c;
*p++ = c;
}
}
char c = random() & 0xff;
for (char *p = (char *) l; size > 0; ++c, --size) {
*p = c;
*p++ = c;
}
}
#endif
static void
insert_random_message(NONLEAF_CHILDINFO bnc, BRT_MSG_S **save, bool *is_fresh_out, XIDS xids, int pfx)
@ -85,26 +84,25 @@ insert_random_message(NONLEAF_CHILDINFO bnc, BRT_MSG_S **save, bool *is_fresh_ou
assert_zero(r);
}
#if 0
static void
insert_random_message_to_leaf(BRT t, BASEMENTNODE blb, LEAFENTRY *save, XIDS xids, int pfx)
insert_random_message_to_leaf(BRT t, BRTNODE leaf, int childnum, BASEMENTNODE blb, LEAFENTRY *save, XIDS xids, int pfx)
{
int keylen = (random() % 16) + 16;
int vallen = (random() % 1024) + 16;
void *key = toku_xmalloc(keylen + (sizeof pfx));
void *val = toku_xmalloc(vallen);
char key[keylen+(sizeof pfx)];
char val[vallen];
*(int *) key = pfx;
rand_bytes_limited((char *) key + (sizeof pfx), keylen);
rand_bytes(val, vallen);
MSN msn = next_dummymsn();
bool is_fresh = (random() & 0x100) == 0;
DBT *keydbt, *valdbt;
keydbt = toku_xmalloc(sizeof *keydbt);
valdbt = toku_xmalloc(sizeof *valdbt);
DBT keydbt_s, *keydbt, valdbt_s, *valdbt;
keydbt = &keydbt_s;
valdbt = &valdbt_s;
toku_fill_dbt(keydbt, key, keylen + (sizeof pfx));
toku_fill_dbt(valdbt, val, vallen);
BRT_MSG_S *result = toku_xmalloc(sizeof *result);
BRT_MSG_S msg;
BRT_MSG_S *result = &msg;
result->type = BRT_INSERT;
result->msn = msn;
result->xids = xids;
@ -113,20 +111,22 @@ insert_random_message_to_leaf(BRT t, BASEMENTNODE blb, LEAFENTRY *save, XIDS xid
size_t memsize, disksize;
int r = apply_msg_to_leafentry(result, NULL, &memsize, &disksize, save, NULL, NULL);
assert_zero(r);
struct subtree_estimates subtree_est = zero_estimates;
bool made_change;
uint64_t workdone;
brt_leaf_put_cmd(t, blb, &subtree_est, result, &made_change, &workdone, NULL, NULL);
brt_leaf_put_cmd(t, blb, &BP_SUBTREE_EST(leaf, childnum), result, &made_change, NULL, NULL, NULL);
}
struct orthopush_flush_update_fun_extra {
...;
void *new_val;
int num_applications;
};
static int
orthopush_flush_update_fun(DB *db, const DBT *key, const DBT *old_val, const DBT *extra,
orthopush_flush_update_fun(DB *UU(db), const DBT *UU(key), const DBT *UU(old_val), const DBT *extra,
void (*set_val)(const DBT *new_val, void *set_extra), void *set_extra) {
...;
struct orthopush_flush_update_fun_extra *e = extra->data;
e->num_applications++;
set_val(extra, set_extra);
return 0;
}
@ -134,13 +134,15 @@ static void
insert_random_update_message(NONLEAF_CHILDINFO bnc, BRT_MSG_S **save, bool *is_fresh_out, XIDS xids, int pfx)
{
int keylen = (random() % 16) + 16;
int vallen = sizeof(struct orthopush_flush_update_fun_extra);
int vallen = (random() % 16) + 16;
void *key = toku_xmalloc(keylen + (sizeof pfx));
void *val = toku_xmalloc(vallen);
struct orthopush_flush_update_fun_extra *update_extra =
toku_xmalloc(sizeof *update_extra);
*(int *) key = pfx;
rand_bytes_limited((char *) key + (sizeof pfx), keylen);
struct orthopush_flush_update_fun_extra *update_extra = val;
...;
update_extra->new_val = toku_xmalloc(vallen);
rand_bytes(update_extra->new_val, vallen);
update_extra->num_applications = 0;
MSN msn = next_dummymsn();
bool is_fresh = (random() & 0x100) == 0;
@ -148,7 +150,7 @@ insert_random_update_message(NONLEAF_CHILDINFO bnc, BRT_MSG_S **save, bool *is_f
keydbt = toku_xmalloc(sizeof *keydbt);
valdbt = toku_xmalloc(sizeof *valdbt);
toku_fill_dbt(keydbt, key, keylen + (sizeof pfx));
toku_fill_dbt(valdbt, val, vallen);
toku_fill_dbt(valdbt, update_extra, sizeof *update_extra);
BRT_MSG_S *result = toku_xmalloc(sizeof *result);
result->type = BRT_UPDATE;
result->msn = msn;
@ -158,12 +160,12 @@ insert_random_update_message(NONLEAF_CHILDINFO bnc, BRT_MSG_S **save, bool *is_f
*save = result;
*is_fresh_out = is_fresh;
int r = toku_bnc_insert_msg(bnc, key, keylen + (sizeof pfx), val, vallen,
int r = toku_bnc_insert_msg(bnc, key, keylen + (sizeof pfx),
update_extra, sizeof *update_extra,
BRT_INSERT, msn, xids, is_fresh,
NULL, dummy_cmp);
assert_zero(r);
}
#endif
const int M = 1024 * 1024;
@ -422,7 +424,6 @@ flush_to_internal_multiple(BRT t) {
toku_free(child_messages_is_fresh);
}
#if 0
static void
flush_to_leaf(BRT t, bool make_leaf_up_to_date, bool use_flush) {
int r;
@ -448,16 +449,26 @@ flush_to_leaf(BRT t, bool make_leaf_up_to_date, bool use_flush) {
toku_init_dbt(&childkeys[i]);
}
}
BRTNODE XMALLOC(child);
BLOCKNUM blocknum = { 42 };
toku_initialize_empty_brtnode(child, blocknum, 0, 8, BRT_LAYOUT_VERSION, 4*M, 0);
for (i = 0; i < 8; ++i) {
destroy_basement_node(BLB(child, i));
set_BLB(child, i, child_blbs[i]);
BP_STATE(child, i) = PT_AVAIL;
}
int total_size = 0;
for (i = 0; total_size < 4*M; ++i) {
total_size -= child_blbs[i%8]->n_bytes_in_buffer;
insert_random_message_to_leaf(t, child_blbs[i%8], &child_messages[i], xids_123, i%8);
insert_random_message_to_leaf(t, child, i%8, child_blbs[i%8], &child_messages[i], xids_123, i%8);
total_size += child_blbs[i%8]->n_bytes_in_buffer;
if (i % 8 < 7) {
u_int32_t keylen;
char *key = le_key_and_len(child_messages[i], &keylen);
DBT keydbt;
if (dummy_cmp(NULL, toku_fill_dbt(&keydbt, key, keylen), childkeys[i%8]) > 0) {
if (dummy_cmp(NULL, toku_fill_dbt(&keydbt, key, keylen), &childkeys[i%8]) > 0) {
toku_fill_dbt(&childkeys[i%8], key, keylen);
}
}
@ -470,56 +481,50 @@ flush_to_leaf(BRT t, bool make_leaf_up_to_date, bool use_flush) {
}
int num_parent_messages = i;
BRTNODE XMALLOC(child);
BLOCKNUM blocknum = { 42 };
toku_initialize_empty_brtnode(child, blocknum, 0, 8, BRT_LAYOUT_VERSION, 4*M, 0);
for (i = 0; i < 8; ++i) {
destroy_basement_node(BLB(child, i));
set_BLB(child, i, child_blbs[i]);
BP_STATE(child, i) = PT_AVAIL;
if (i < 7) {
child->childkeys[i] = kv_pair_malloc(childkeys[i].data, childkeys[i].size, NULL, 0);
}
for (i = 0; i < 7; ++i) {
child->childkeys[i] = kv_pair_malloc(childkeys[i].data, childkeys[i].size, NULL, 0);
}
if (make_leaf_up_to_date) {
for (i = 0; i < num_parent_messages; ++i) {
if (!parent_messages_is_fresh[i]) {
bool made_change;
uint64_t workdone;
toku_apply_cmd_to_leaf(t, child, parent_messages[i], &made_change, &workdone, NULL, NULL);
toku_apply_cmd_to_leaf(t, child, parent_messages[i], &made_change, NULL, NULL, NULL);
}
}
child->stale_ancestor_messages_applied = true;
for (i = 0; i < 8; ++i) {
BLB(child, i)->stale_ancestor_messages_applied = true;
}
} else {
child->stale_ancestor_messages_applied = false;
for (i = 0; i < 8; ++i) {
BLB(child, i)->stale_ancestor_messages_applied = false;
}
}
if (use_flush) {
toku_bnc_flush_to_child(t, parent_bnc, child);
destroy_nonleaf_childinfo(parent_bnc);
} else {
BRTNODE XMALLOC(parentnode);
BLOCKNUM parentblocknum = { 17 };
toku_initialize_empty_brtnode(parentnode, parentblocknum, 1, 1, BRT_LAYOUT_VERSION, 4*M, 0);
destroy_nonleaf_childinfo(BNC(parent, 0));
set_BNC(parent, 0, parent_bnc);
BP_STATE(parent, 0) = PT_AVAIL;
destroy_nonleaf_childinfo(BNC(parentnode, 0));
set_BNC(parentnode, 0, parent_bnc);
BP_STATE(parentnode, 0) = PT_AVAIL;
struct ancestors ancestors = { .node = parentnode, .childnum = 0, .next = NULL };
const struct pivot_bounds infinite_bounds = { .lower_bound_exclusive = NULL, .upper_bound_inclusive = NULL };
maybe_apply_ancestors_messages_to_node(t, child, &ancestors, &infinite_bounds);
toku_brtnode_free(&parentnode);
}
int total_messages = 0;
for (i = 0; i < 8; ++i) {
total_messages += toku_bnc_n_entries(BNC(child, i));
total_messages += toku_omt_size(BLB_BUFFER(child, i));
}
assert(total_messages == num_parent_messages + num_child_messages);
int parent_messages_present[num_parent_messages];
int child_messages_present[num_child_messages];
memset(parent_messages_present, 0, sizeof parent_messages_present);
memset(child_messages_present, 0, sizeof child_messages_present);
assert(true || total_messages <= num_parent_messages + num_child_messages);
for (int j = 0; j < 8; ++j) {
/*
FIFO_ITERATE(child_bncs[j]->buffer, key, keylen, val, vallen, type, msn, xids, is_fresh,
{
DBT keydbt;
@ -555,14 +560,17 @@ flush_to_leaf(BRT t, bool make_leaf_up_to_date, bool use_flush) {
}
assert(found == 1);
});
*/
}
/*
for (i = 0; i < num_parent_messages; ++i) {
assert(parent_messages_present[i] == 1);
}
for (i = 0; i < num_child_messages; ++i) {
assert(child_messages_present[i] == 1);
}
*/
xids_destroy(&xids_0);
xids_destroy(&xids_123);
@ -571,25 +579,21 @@ flush_to_leaf(BRT t, bool make_leaf_up_to_date, bool use_flush) {
for (i = 0; i < num_parent_messages; ++i) {
toku_free(parent_messages[i]->u.id.key->data);
toku_free((DBT *) parent_messages[i]->u.id.key);
struct orthopush_flush_update_fun_extra *extra =
parent_messages[i]->u.id.val->data;
toku_free(extra->new_val);
toku_free(parent_messages[i]->u.id.val->data);
toku_free((DBT *) parent_messages[i]->u.id.val);
toku_free(parent_messages[i]);
}
for (i = 0; i < num_child_messages; ++i) {
toku_free(child_messages[i]->u.id.key->data);
toku_free((DBT *) child_messages[i]->u.id.key);
toku_free(child_messages[i]->u.id.val->data);
toku_free((DBT *) child_messages[i]->u.id.val);
toku_free(child_messages[i]);
}
destroy_nonleaf_childinfo(parent_bnc);
toku_brtnode_free(&child);
toku_free(parent_messages);
toku_free(child_messages);
toku_free(parent_messages_is_fresh);
toku_free(child_messages_is_fresh);
}
#endif
int
test_main (int argc, const char *argv[]) {
@ -611,7 +615,6 @@ test_main (int argc, const char *argv[]) {
for (int i = 0; i < 10; ++i) {
flush_to_internal_multiple(t);
}
#if 0
r = toku_brt_set_update(t, orthopush_flush_update_fun); assert(r==0);
for (int i = 0; i < 10; ++i) {
flush_to_leaf(t, false, false);
@ -619,7 +622,6 @@ test_main (int argc, const char *argv[]) {
flush_to_leaf(t, true, false);
flush_to_leaf(t, true, true);
}
#endif
r = toku_close_brt(t, 0); assert(r==0);
r = toku_cachetable_close(&ct); assert(r==0);