Skip to content

M
mariadb
Commit 86646f79 authored by Zardosht Kasheff's avatar Zardosht Kasheff Committed by Yoni Fogel
Browse files
Options

[t:4740], remove fifo->memory_start 

git-svn-id: file:///svn/toku/tokudb@42746 c7de825b-a66e-492c-adef-691d508d4ae1
parent 0657bfdf
Hide whitespace changes
Inline Side-by-side
Showing with 29 additions and 164 deletions
newbrt/fifo.c
View file @ 86646f79
...@@ -10,7 +10,6 @@ struct fifo { ...@@ -10,7 +10,6 @@ struct fifo {
int n_items_in_fifo; int n_items_in_fifo;
char *memory; // An array of bytes into which fifo_entries are embedded. char *memory; // An array of bytes into which fifo_entries are embedded.
int memory_size; // How big is fifo_memory int memory_size; // How big is fifo_memory
int memory_start; // Where is the first used byte?
int memory_used; // How many bytes are in use? int memory_used; // How many bytes are in use?
}; };
...@@ -19,7 +18,6 @@ static void fifo_init(struct fifo *fifo) { ...@@ -19,7 +18,6 @@ static void fifo_init(struct fifo *fifo) {
fifo->n_items_in_fifo = 0; fifo->n_items_in_fifo = 0;
fifo->memory = 0; fifo->memory = 0;
fifo->memory_size = 0; fifo->memory_size = 0;
fifo->memory_start = 0;
fifo->memory_used = 0; fifo->memory_used = 0;
} }
...@@ -29,11 +27,6 @@ static int fifo_entry_size(struct fifo_entry *entry) { ...@@ -29,11 +27,6 @@ static int fifo_entry_size(struct fifo_entry *entry) {
- sizeof(XIDS_S); //Prevent double counting from fifo_entry+xids_get_size - sizeof(XIDS_S); //Prevent double counting from fifo_entry+xids_get_size
} }
static struct fifo_entry *fifo_peek(struct fifo *fifo) {
if (fifo->n_items_in_fifo == 0) return NULL;
else return (struct fifo_entry *)(fifo->memory+fifo->memory_start);
}
int toku_fifo_create(FIFO *ptr) { int toku_fifo_create(FIFO *ptr) {
struct fifo *XMALLOC(fifo); struct fifo *XMALLOC(fifo);
if (fifo == 0) return ENOMEM; if (fifo == 0) return ENOMEM;
...@@ -63,13 +56,6 @@ static int next_power_of_two (int n) { ...@@ -63,13 +56,6 @@ static int next_power_of_two (int n) {
return r; return r;
} }
void toku_fifo_size_hint(FIFO fifo, size_t size) {
if (fifo->memory == NULL) {
fifo->memory_size = next_power_of_two(size);
fifo->memory = toku_xmalloc(fifo->memory_size);
}
}
int toku_fifo_enq(FIFO fifo, const void *key, unsigned int keylen, const void *data, unsigned int datalen, enum brt_msg_type type, MSN msn, XIDS xids, bool is_fresh, long *dest) { int toku_fifo_enq(FIFO fifo, const void *key, unsigned int keylen, const void *data, unsigned int datalen, enum brt_msg_type type, MSN msn, XIDS xids, bool is_fresh, long *dest) {
int need_space_here = sizeof(struct fifo_entry) int need_space_here = sizeof(struct fifo_entry)
+ keylen + datalen + keylen + datalen
...@@ -80,7 +66,7 @@ int toku_fifo_enq(FIFO fifo, const void *key, unsigned int keylen, const void *d ...@@ -80,7 +66,7 @@ int toku_fifo_enq(FIFO fifo, const void *key, unsigned int keylen, const void *d
fifo->memory_size = next_power_of_two(need_space_total); fifo->memory_size = next_power_of_two(need_space_total);
fifo->memory = toku_xmalloc(fifo->memory_size); fifo->memory = toku_xmalloc(fifo->memory_size);
} }
if (fifo->memory_start+need_space_total > fifo->memory_size) { if (need_space_total > fifo->memory_size) {
// Out of memory at the end. // Out of memory at the end.
int next_2 = next_power_of_two(need_space_total); int next_2 = next_power_of_two(need_space_total);
if ((2*next_2 > fifo->memory_size) if ((2*next_2 > fifo->memory_size)
...@@ -89,20 +75,13 @@ int toku_fifo_enq(FIFO fifo, const void *key, unsigned int keylen, const void *d ...@@ -89,20 +75,13 @@ int toku_fifo_enq(FIFO fifo, const void *key, unsigned int keylen, const void *d
char *newmem = toku_xmalloc(next_2); char *newmem = toku_xmalloc(next_2);
char *oldmem = fifo->memory; char *oldmem = fifo->memory;
if (newmem==0) return ENOMEM; if (newmem==0) return ENOMEM;
memcpy(newmem, oldmem+fifo->memory_start, fifo->memory_used); memcpy(newmem, oldmem, fifo->memory_used);
fifo->memory_size = next_2; fifo->memory_size = next_2;
assert(fifo->memory_start == 0);
fifo->memory_start = 0;
fifo->memory = newmem; fifo->memory = newmem;
toku_free(oldmem); toku_free(oldmem);
} else {
// slide things over
memmove(fifo->memory, fifo->memory+fifo->memory_start, fifo->memory_used);
assert(fifo->memory_start == 0);
fifo->memory_start = 0;
} }
} }
struct fifo_entry *entry = (struct fifo_entry *)(fifo->memory + fifo->memory_start + fifo->memory_used); struct fifo_entry *entry = (struct fifo_entry *)(fifo->memory + fifo->memory_used);
fifo_entry_set_msg_type(entry, type); fifo_entry_set_msg_type(entry, type);
entry->msn = msn; entry->msn = msn;
xids_cpy(&entry->xids_s, xids); xids_cpy(&entry->xids_s, xids);
...@@ -113,7 +92,6 @@ int toku_fifo_enq(FIFO fifo, const void *key, unsigned int keylen, const void *d ...@@ -113,7 +92,6 @@ int toku_fifo_enq(FIFO fifo, const void *key, unsigned int keylen, const void *d
entry->vallen = datalen; entry->vallen = datalen;
memcpy(e_key + keylen, data, datalen); memcpy(e_key + keylen, data, datalen);
if (dest) { if (dest) {
assert(fifo->memory_start == 0);
*dest = fifo->memory_used; *dest = fifo->memory_used;
} }
fifo->n_items_in_fifo++; fifo->n_items_in_fifo++;
...@@ -125,22 +103,6 @@ int toku_fifo_enq_cmdstruct (FIFO fifo, const BRT_MSG cmd, bool is_fresh, long * ...@@ -125,22 +103,6 @@ int toku_fifo_enq_cmdstruct (FIFO fifo, const BRT_MSG cmd, bool is_fresh, long *
return toku_fifo_enq(fifo, cmd->u.id.key->data, cmd->u.id.key->size, cmd->u.id.val->data, cmd->u.id.val->size, cmd->type, cmd->msn, cmd->xids, is_fresh, dest); return toku_fifo_enq(fifo, cmd->u.id.key->data, cmd->u.id.key->size, cmd->u.id.val->data, cmd->u.id.val->size, cmd->type, cmd->msn, cmd->xids, is_fresh, dest);
} }
/* peek at the head (the oldest entry) of the fifo */
int toku_fifo_peek(FIFO fifo, bytevec *key, unsigned int *keylen, bytevec *data, unsigned int *datalen, enum brt_msg_type *type, MSN *msn, XIDS *xids, bool *is_fresh) {
struct fifo_entry *entry = fifo_peek(fifo);
if (entry == 0) return -1;
unsigned char *e_key = xids_get_end_of_array(&entry->xids_s);
*key = e_key;
*keylen = entry->keylen;
*data = e_key + entry->keylen;
*datalen = entry->vallen;
*type = fifo_entry_get_msg_type(entry);
*msn = entry->msn;
*xids = &entry->xids_s;
*is_fresh = entry->is_fresh;
return 0;
}
#if 0 #if 0
// fill in the BRT_MSG, using the two DBTs for the DBT part. // fill in the BRT_MSG, using the two DBTs for the DBT part.
int toku_fifo_peek_cmdstruct (FIFO fifo, BRT_MSG cmd, DBT*key, DBT*data) { int toku_fifo_peek_cmdstruct (FIFO fifo, BRT_MSG cmd, DBT*key, DBT*data) {
...@@ -158,26 +120,8 @@ int toku_fifo_peek_cmdstruct (FIFO fifo, BRT_MSG cmd, DBT*key, DBT*data) { ...@@ -158,26 +120,8 @@ int toku_fifo_peek_cmdstruct (FIFO fifo, BRT_MSG cmd, DBT*key, DBT*data) {
} }
#endif #endif
int toku_fifo_deq(FIFO fifo) { int toku_fifo_iterate_internal_start(FIFO UU(fifo)) { return 0; }
if (fifo->n_items_in_fifo==0) return -1; int toku_fifo_iterate_internal_has_more(FIFO fifo, int off) { return off < fifo->memory_used; }
struct fifo_entry * e = fifo_peek(fifo);
assert(e);
int used_here = fifo_entry_size(e);
fifo->n_items_in_fifo--;
fifo->memory_start+=used_here;
fifo->memory_used -=used_here;
return 0;
}
int toku_fifo_empty(FIFO fifo) {
assert(fifo->memory_start == 0);
fifo->memory_used = 0;
fifo->n_items_in_fifo = 0;
return 0;
}
int toku_fifo_iterate_internal_start(FIFO fifo) { return fifo->memory_start; }
int toku_fifo_iterate_internal_has_more(FIFO fifo, int off) { return off < fifo->memory_start + fifo->memory_used; }
int toku_fifo_iterate_internal_next(FIFO fifo, int off) { int toku_fifo_iterate_internal_next(FIFO fifo, int off) {
struct fifo_entry *e = (struct fifo_entry *)(fifo->memory + off); struct fifo_entry *e = (struct fifo_entry *)(fifo->memory + off);
return off + fifo_entry_size(e); return off + fifo_entry_size(e);
...@@ -194,23 +138,22 @@ void toku_fifo_iterate (FIFO fifo, void(*f)(bytevec key,ITEMLEN keylen,bytevec d ...@@ -194,23 +138,22 @@ void toku_fifo_iterate (FIFO fifo, void(*f)(bytevec key,ITEMLEN keylen,bytevec d
void toku_fifo_size_is_stabilized(FIFO fifo) { void toku_fifo_size_is_stabilized(FIFO fifo) {
if (fifo->memory_used < fifo->memory_size/2) { if (fifo->memory_used < fifo->memory_size/2) {
char *old_memory = fifo->memory; char *old_memory = fifo->memory;
int new_memory_size = fifo->memory_used*2; int new_memory_size = fifo->memory_used*2;
char *new_memory = toku_xmalloc(new_memory_size); char *new_memory = toku_xmalloc(new_memory_size);
memcpy(new_memory, old_memory+fifo->memory_start, fifo->memory_used); memcpy(new_memory, old_memory, fifo->memory_used);
fifo->memory = new_memory; fifo->memory = new_memory;
fifo->memory_start = 0; fifo->memory_size = new_memory_size;
fifo->memory_size = new_memory_size; toku_free(old_memory);
toku_free(old_memory);
} }
} }
unsigned long toku_fifo_memory_size_in_use(FIFO fifo) { unsigned long toku_fifo_memory_size_in_use(FIFO fifo) {
return sizeof(*fifo)+fifo->memory_start+fifo->memory_used; return sizeof(*fifo)+fifo->memory_used;
} }
unsigned long toku_fifo_memory_footprint(FIFO fifo) { unsigned long toku_fifo_memory_footprint(FIFO fifo) {
size_t size_used = toku_memory_footprint(fifo->memory, fifo->memory_start+fifo->memory_used); size_t size_used = toku_memory_footprint(fifo->memory, fifo->memory_used);
long rval = sizeof(*fifo) + size_used; long rval = sizeof(*fifo) + size_used;
return rval; return rval;
} }
...@@ -231,14 +174,21 @@ void toku_fifo_clone(FIFO orig_fifo, FIFO* cloned_fifo) { ...@@ -231,14 +174,21 @@ void toku_fifo_clone(FIFO orig_fifo, FIFO* cloned_fifo) {
struct fifo *XMALLOC(new_fifo); struct fifo *XMALLOC(new_fifo);
assert(new_fifo); assert(new_fifo);
new_fifo->n_items_in_fifo = orig_fifo->n_items_in_fifo; new_fifo->n_items_in_fifo = orig_fifo->n_items_in_fifo;
new_fifo->memory_start = 0; new_fifo->memory_used = orig_fifo->memory_used;
new_fifo->memory_used = orig_fifo->memory_used - orig_fifo->memory_start;
new_fifo->memory_size = new_fifo->memory_used; new_fifo->memory_size = new_fifo->memory_used;
new_fifo->memory = toku_xmalloc(new_fifo->memory_size); new_fifo->memory = toku_xmalloc(new_fifo->memory_size);
memcpy( memcpy(
new_fifo->memory, new_fifo->memory,
orig_fifo->memory + orig_fifo->memory_start, orig_fifo->memory,
new_fifo->memory_size new_fifo->memory_size
); );
*cloned_fifo = new_fifo; *cloned_fifo = new_fifo;
} }
BOOL toku_are_fifos_same(FIFO fifo1, FIFO fifo2) {
return (
fifo1->memory_used == fifo2->memory_used &&
memcmp(fifo1->memory, fifo2->memory, fifo1->memory_used) == 0
);
}
newbrt/fifo.h
View file @ 86646f79
...@@ -54,10 +54,6 @@ int toku_fifo_create(FIFO *); ...@@ -54,10 +54,6 @@ int toku_fifo_create(FIFO *);
void toku_fifo_free(FIFO *); void toku_fifo_free(FIFO *);
// Use the size hint to size the storage for the fifo entries in anticipation of putting a bunch of them
// into the fifo.
void toku_fifo_size_hint(FIFO, size_t size_hint);
void toku_fifo_size_is_stabilized(FIFO); void toku_fifo_size_is_stabilized(FIFO);
// Effect: Tell the FIFO that we may have just inserted or removed a bunch of stuff, and now may be a good time to resize memory. // Effect: Tell the FIFO that we may have just inserted or removed a bunch of stuff, and now may be a good time to resize memory.
...@@ -67,13 +63,8 @@ int toku_fifo_enq_cmdstruct (FIFO fifo, const BRT_MSG cmd, bool is_fresh, long * ...@@ -67,13 +63,8 @@ int toku_fifo_enq_cmdstruct (FIFO fifo, const BRT_MSG cmd, bool is_fresh, long *
int toku_fifo_enq (FIFO, const void *key, ITEMLEN keylen, const void *data, ITEMLEN datalen, enum brt_msg_type type, MSN msn, XIDS xids, bool is_fresh, long *dest); int toku_fifo_enq (FIFO, const void *key, ITEMLEN keylen, const void *data, ITEMLEN datalen, enum brt_msg_type type, MSN msn, XIDS xids, bool is_fresh, long *dest);
int toku_fifo_peek (FIFO, bytevec *key, ITEMLEN *keylen, bytevec *data, ITEMLEN *datalen, u_int32_t *type, MSN *msn, XIDS *xids, bool *is_fresh);
// int toku_fifo_peek_cmdstruct (FIFO, BRT_MSG, DBT*, DBT*); // fill in the BRT_MSG, using the two DBTs for the DBT part. // int toku_fifo_peek_cmdstruct (FIFO, BRT_MSG, DBT*, DBT*); // fill in the BRT_MSG, using the two DBTs for the DBT part.
int toku_fifo_deq(FIFO); // we cannot deq items anymore, since their offsets are indexed.
// THIS ONLY REMAINS FOR TESTING, DO NOT USE IT IN CODE // THIS ONLY REMAINS FOR TESTING, DO NOT USE IT IN CODE
int toku_fifo_empty(FIFO); // don't deallocate the memory for the fifo
unsigned long toku_fifo_memory_size_in_use(FIFO fifo); // return how much memory in the fifo holds useful data unsigned long toku_fifo_memory_size_in_use(FIFO fifo); // return how much memory in the fifo holds useful data
unsigned long toku_fifo_memory_footprint(FIFO fifo); // return how much memory the fifo occupies unsigned long toku_fifo_memory_footprint(FIFO fifo); // return how much memory the fifo occupies
...@@ -112,6 +103,8 @@ const struct fifo_entry *toku_fifo_get_entry(FIFO fifo, long off); ...@@ -112,6 +103,8 @@ const struct fifo_entry *toku_fifo_get_entry(FIFO fifo, long off);
void toku_fifo_clone(FIFO orig_fifo, FIFO* cloned_fifo); void toku_fifo_clone(FIFO orig_fifo, FIFO* cloned_fifo);
BOOL toku_are_fifos_same(FIFO fifo1, FIFO fifo2);
#if defined(__cplusplus) || defined(__cilkplusplus) #if defined(__cplusplus) || defined(__cilkplusplus)
}; };
#endif #endif
......
newbrt/tests/brt-serialize-test.c
View file @ 86646f79
...@@ -1281,85 +1281,10 @@ test_serialize_nonleaf(enum brtnode_verify_type bft, BOOL do_clone) { ...@@ -1281,85 +1281,10 @@ test_serialize_nonleaf(enum brtnode_verify_type bft, BOOL do_clone) {
FIFO src_fifo_2 = BNC(&sn, 1)->buffer; FIFO src_fifo_2 = BNC(&sn, 1)->buffer;
FIFO dest_fifo_1 = BNC(dn, 0)->buffer; FIFO dest_fifo_1 = BNC(dn, 0)->buffer;
FIFO dest_fifo_2 = BNC(dn, 1)->buffer; FIFO dest_fifo_2 = BNC(dn, 1)->buffer;
bytevec src_key,src_val, dest_key, dest_val;
ITEMLEN src_keylen, src_vallen;
u_int32_t src_type;
MSN src_msn;
XIDS src_xids;
ITEMLEN dest_keylen, dest_vallen;
u_int32_t dest_type;
MSN dest_msn;
XIDS dest_xids;
bool src_is_fresh;
bool dest_is_fresh;
r = toku_fifo_peek(src_fifo_1, &src_key, &src_keylen, &src_val, &src_vallen, &src_type, &src_msn, &src_xids, &src_is_fresh);
assert(r==0);
r = toku_fifo_peek(dest_fifo_1, &dest_key, &dest_keylen, &dest_val, &dest_vallen, &dest_type, &dest_msn, &dest_xids, &dest_is_fresh);
assert(r==0);
assert(src_keylen == dest_keylen);
assert(src_keylen == 2);
assert(src_vallen == dest_vallen);
assert(src_vallen == 5);
assert(src_type == dest_type);
assert(src_msn.msn == dest_msn.msn);
assert(strcmp(src_key, "a") == 0);
assert(strcmp(dest_key, "a") == 0);
assert(strcmp(src_val, "aval") == 0);
assert(strcmp(dest_val, "aval") == 0);
assert(src_is_fresh == dest_is_fresh);
r = toku_fifo_deq(src_fifo_1);
assert(r==0);
r = toku_fifo_deq(dest_fifo_1);
assert(r==0);
r = toku_fifo_peek(src_fifo_1, &src_key, &src_keylen, &src_val, &src_vallen, &src_type, &src_msn, &src_xids, &src_is_fresh);
assert(r==0);
r = toku_fifo_peek(dest_fifo_1, &dest_key, &dest_keylen, &dest_val, &dest_vallen, &dest_type, &dest_msn, &dest_xids, &dest_is_fresh);
assert(r==0);
assert(src_keylen == dest_keylen);
assert(src_keylen == 2);
assert(src_vallen == dest_vallen);
assert(src_vallen == 5);
assert(src_type == dest_type);
assert(src_msn.msn == dest_msn.msn);
assert(strcmp(src_key, "b") == 0);
assert(strcmp(dest_key, "b") == 0);
assert(strcmp(src_val, "bval") == 0);
assert(strcmp(dest_val, "bval") == 0);
assert(src_is_fresh == dest_is_fresh);
r = toku_fifo_deq(src_fifo_1);
assert(r==0);
r = toku_fifo_deq(dest_fifo_1);
assert(r==0);
r = toku_fifo_peek(src_fifo_1, &src_key, &src_keylen, &src_val, &src_vallen, &src_type, &src_msn, &src_xids, &src_is_fresh);
assert(r!=0);
r = toku_fifo_peek(dest_fifo_1, &dest_key, &dest_keylen, &dest_val, &dest_vallen, &dest_type, &dest_msn, &dest_xids, &dest_is_fresh);
assert(r!=0);
r = toku_fifo_peek(src_fifo_2, &src_key, &src_keylen, &src_val, &src_vallen, &src_type, &src_msn, &src_xids, &src_is_fresh);
assert(r==0);
r = toku_fifo_peek(dest_fifo_2, &dest_key, &dest_keylen, &dest_val, &dest_vallen, &dest_type, &dest_msn, &dest_xids, &dest_is_fresh);
assert(r==0);
assert(src_keylen == dest_keylen);
assert(src_keylen == 2);
assert(src_vallen == dest_vallen);
assert(src_vallen == 5);
assert(src_type == dest_type);
assert(src_msn.msn == dest_msn.msn);
assert(strcmp(src_key, "x") == 0);
assert(strcmp(dest_key, "x") == 0);
assert(strcmp(src_val, "xval") == 0);
assert(strcmp(dest_val, "xval") == 0);
assert(src_is_fresh == dest_is_fresh);
r = toku_fifo_deq(src_fifo_2);
assert(r==0);
r = toku_fifo_deq(dest_fifo_2);
assert(r==0);
r = toku_fifo_peek(src_fifo_2, &src_key, &src_keylen, &src_val, &src_vallen, &src_type, &src_msn, &src_xids, &src_is_fresh);
assert(r!=0);
r = toku_fifo_peek(dest_fifo_2, &dest_key, &dest_keylen, &dest_val, &dest_vallen, &dest_type, &dest_msn, &dest_xids, &dest_is_fresh);
assert(r!=0);
assert(toku_are_fifos_same(src_fifo_1, dest_fifo_1));
assert(toku_are_fifos_same(src_fifo_2, dest_fifo_2));
toku_brtnode_free(&dn); toku_brtnode_free(&dn);
kv_pair_free(sn.childkeys[0]); kv_pair_free(sn.childkeys[0]);
......
newbrt/tests/fifo-test.c
View file @ 86646f79
...@@ -80,9 +80,6 @@ test_fifo_enq (int n) { ...@@ -80,9 +80,6 @@ test_fifo_enq (int n) {
if (thekey) toku_free(thekey); if (thekey) toku_free(thekey);
if (theval) toku_free(theval); if (theval) toku_free(theval);
while (toku_fifo_deq(f) == 0)
;
toku_fifo_free(&f); toku_fifo_free(&f);
assert(f == 0); assert(f == 0);
} }
......
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