From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: From: Vladimir Davydov Subject: [PATCH] vinyl: factor out procedure looking up LSM tree range intersection Date: Mon, 1 Apr 2019 15:07:22 +0300 Message-Id: To: tarantool-patches@freelists.org List-ID: It's an independent piece of code that is definitely worth moving from vy_scheduler to vy_lsm internals anyway. Besides, having it wrapped up in a separate function will make it easier to patch. --- src/box/vy_lsm.c | 24 ++++++++++++++++++++++++ src/box/vy_lsm.h | 16 ++++++++++++++++ src/box/vy_scheduler.c | 25 +++---------------------- 3 files changed, 43 insertions(+), 22 deletions(-) diff --git a/src/box/vy_lsm.c b/src/box/vy_lsm.c index 727a5397..1e08c0e1 100644 --- a/src/box/vy_lsm.c +++ b/src/box/vy_lsm.c @@ -1065,6 +1065,30 @@ vy_lsm_rollback_stmt(struct vy_lsm *lsm, struct vy_mem *mem, vy_cache_on_write(&lsm->cache, stmt, NULL); } +int +vy_lsm_find_range_intersection(struct vy_lsm *lsm, + const char *min_key, const char *max_key, + struct vy_range **begin, struct vy_range **end) +{ + struct tuple_format *key_format = lsm->env->key_format; + struct tuple *stmt; + + stmt = vy_key_from_msgpack(key_format, min_key); + if (stmt == NULL) + return -1; + *begin = vy_range_tree_psearch(&lsm->range_tree, stmt); + tuple_unref(stmt); + + stmt = vy_key_from_msgpack(key_format, max_key); + if (stmt == NULL) + return -1; + *end = vy_range_tree_psearch(&lsm->range_tree, stmt); + *end = vy_range_tree_next(&lsm->range_tree, *end); + tuple_unref(stmt); + + return 0; +} + bool vy_lsm_split_range(struct vy_lsm *lsm, struct vy_range *range) { diff --git a/src/box/vy_lsm.h b/src/box/vy_lsm.h index e969e45c..c85bd2b3 100644 --- a/src/box/vy_lsm.h +++ b/src/box/vy_lsm.h @@ -536,6 +536,22 @@ void vy_lsm_delete_mem(struct vy_lsm *lsm, struct vy_mem *mem); /** + * Lookup ranges intersecting [min_key, max_key] interval in + * the given LSM tree. + * + * On success returns 0 and sets @begin to the first range + * and @end to the one following the last range instersecting + * the given interval (NULL if max_key lays in the rightmost + * range). + * + * On memory allocation error returns -1 and sets diag. + */ +int +vy_lsm_find_range_intersection(struct vy_lsm *lsm, + const char *min_key, const char *max_key, + struct vy_range **begin, struct vy_range **end); + +/** * Split a range if it has grown too big, return true if the range * was split. Splitting is done by making slices of the runs used * by the original range, adding them to new ranges, and reflecting diff --git a/src/box/vy_scheduler.c b/src/box/vy_scheduler.c index 6191bcd9..aaae1a89 100644 --- a/src/box/vy_scheduler.c +++ b/src/box/vy_scheduler.c @@ -1103,11 +1103,9 @@ vy_task_dump_complete(struct vy_task *task) double dump_time = ev_monotonic_now(loop()) - task->start_time; struct vy_disk_stmt_counter dump_output = new_run->count; struct vy_stmt_counter dump_input; - struct tuple_format *key_format = lsm->env->key_format; struct vy_mem *mem, *next_mem; struct vy_slice **new_slices, *slice; struct vy_range *range, *begin_range, *end_range; - struct tuple *min_key, *max_key; int i; assert(lsm->is_dumping); @@ -1131,28 +1129,11 @@ vy_task_dump_complete(struct vy_task *task) /* * Figure out which ranges intersect the new run. - * @begin_range is the first range intersecting the run. - * @end_range is the range following the last range - * intersecting the run or NULL if the run itersects all - * ranges. */ - min_key = vy_key_from_msgpack(key_format, new_run->info.min_key); - if (min_key == NULL) + if (vy_lsm_find_range_intersection(lsm, new_run->info.min_key, + new_run->info.max_key, + &begin_range, &end_range) != 0) goto fail; - max_key = vy_key_from_msgpack(key_format, new_run->info.max_key); - if (max_key == NULL) { - tuple_unref(min_key); - goto fail; - } - begin_range = vy_range_tree_psearch(&lsm->range_tree, min_key); - end_range = vy_range_tree_psearch(&lsm->range_tree, max_key); - /* - * If min_key == max_key, the slice has to span over at - * least one range. - */ - end_range = vy_range_tree_next(&lsm->range_tree, end_range); - tuple_unref(min_key); - tuple_unref(max_key); /* * For each intersected range allocate a slice of the new run. -- 2.11.0