From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: From: Vladimir Davydov Subject: [PATCH] vinyl: rename vy_index to vy_lsm Date: Fri, 23 Mar 2018 18:50:11 +0300 Message-Id: <58d4e0a30d6c98e01ac59d2d669021d241401e6b.1521819273.git.vdavydov.dev@gmail.com> To: kostja@tarantool.org Cc: tarantool-patches@freelists.org List-ID: Vinyl assigns a unique id to each index so that it can be identified in vylog, see vy_index->id, but outside Vinyl index id means something completely different - it's the ordinal number of the index in a space. This creates a lot of confusion. To resolve this, let's rename vy_index to vy_lsm and refer to Vinyl indexes as LSM trees in comments so that Vinyl's index_id turns into lsm_id. Also, rename vy_log_record's index_def_id and space_def_id back to conventional index_id and space_id as they doesn't conflict with Vinyl index id anymore (which is now lsm_id). Thanks to @Gerold103 for suggesting the new name. --- src/box/CMakeLists.txt | 2 +- src/box/vinyl.c | 665 +++++++++++++++++++-------------------- src/box/vy_cache.h | 2 +- src/box/vy_log.c | 401 ++++++++++++----------- src/box/vy_log.h | 144 ++++----- src/box/{vy_index.c => vy_lsm.c} | 636 ++++++++++++++++++------------------- src/box/{vy_index.h => vy_lsm.h} | 270 ++++++++-------- src/box/vy_mem.c | 2 +- src/box/vy_point_lookup.c | 98 +++--- src/box/vy_point_lookup.h | 8 +- src/box/vy_range.h | 15 +- src/box/vy_read_iterator.c | 117 ++++--- src/box/vy_read_iterator.h | 16 +- src/box/vy_read_set.c | 24 +- src/box/vy_read_set.h | 46 +-- src/box/vy_run.c | 5 +- src/box/vy_run.h | 14 +- src/box/vy_scheduler.c | 418 ++++++++++++------------ src/box/vy_scheduler.h | 18 +- src/box/vy_stat.h | 14 +- src/box/vy_tx.c | 152 +++++---- src/box/vy_tx.h | 33 +- test/unit/CMakeLists.txt | 2 +- test/unit/vy_log_stub.c | 6 +- test/unit/vy_point_lookup.c | 37 ++- test/unit/vy_point_lookup.result | 6 +- 26 files changed, 1565 insertions(+), 1586 deletions(-) rename src/box/{vy_index.c => vy_lsm.c} (56%) rename src/box/{vy_index.h => vy_lsm.h} (59%) diff --git a/src/box/CMakeLists.txt b/src/box/CMakeLists.txt index fb6602b0..598b596a 100644 --- a/src/box/CMakeLists.txt +++ b/src/box/CMakeLists.txt @@ -75,7 +75,7 @@ add_library(box STATIC vy_mem.c vy_run.c vy_range.c - vy_index.c + vy_lsm.c vy_tx.c vy_write_iterator.c vy_read_iterator.c diff --git a/src/box/vinyl.c b/src/box/vinyl.c index ac12a331..f782ee64 100644 --- a/src/box/vinyl.c +++ b/src/box/vinyl.c @@ -33,7 +33,7 @@ #include "vy_mem.h" #include "vy_run.h" #include "vy_range.h" -#include "vy_index.h" +#include "vy_lsm.h" #include "vy_tx.h" #include "vy_cache.h" #include "vy_log.h" @@ -130,8 +130,8 @@ struct vy_env { * best result among 10% worst measurements. */ struct histogram *dump_bw; - /** Common index environment. */ - struct vy_index_env index_env; + /** Common LSM tree environment. */ + struct vy_lsm_env lsm_env; /** Environment for cache subsystem */ struct vy_cache_env cache_env; /** Environment for run subsystem */ @@ -204,15 +204,15 @@ vy_env(struct engine *engine) struct vinyl_index { struct index base; - /** Vinyl index implementation. */ - struct vy_index *db; + /** LSM tree that stores index data. */ + struct vy_lsm *lsm; }; -/** Extract vy_index from an index object. */ -struct vy_index * -vy_index(struct index *index) +/** Extract vy_lsm from an index object. */ +struct vy_lsm * +vy_lsm(struct index *index) { - return ((struct vinyl_index *)index)->db; + return ((struct vinyl_index *)index)->lsm; } /** Mask passed to vy_gc(). */ @@ -231,8 +231,8 @@ struct vinyl_iterator { struct iterator base; /** Vinyl environment. */ struct vy_env *env; - /** Vinyl index this iterator is for. */ - struct vy_index *index; + /** LSM tree this iterator is for. */ + struct vy_lsm *lsm; /** * Points either to tx_autocommit for autocommit mode * or to a multi-statement transaction active when the @@ -396,12 +396,12 @@ vy_info_append_compact_stat(struct info_handler *h, const char *name, } static void -vinyl_index_info(struct index *base, struct info_handler *h) +vinyl_index_info(struct index *index, struct info_handler *h) { char buf[1024]; - struct vy_index *index = vy_index(base); - struct vy_index_stat *stat = &index->stat; - struct vy_cache_stat *cache_stat = &index->cache.stat; + struct vy_lsm *lsm = vy_lsm(index); + struct vy_lsm_stat *stat = &lsm->stat; + struct vy_cache_stat *cache_stat = &lsm->cache.stat; info_begin(h); @@ -425,7 +425,7 @@ vinyl_index_info(struct index *base, struct info_handler *h) info_append_int(h, "lookup", stat->memory.iterator.lookup); vy_info_append_stmt_counter(h, "get", &stat->memory.iterator.get); info_table_end(h); - info_append_int(h, "index_size", vy_index_mem_tree_size(index)); + info_append_int(h, "index_size", vy_lsm_mem_tree_size(lsm)); info_table_end(h); info_table_begin(h, "disk"); @@ -441,8 +441,8 @@ vinyl_index_info(struct index *base, struct info_handler *h) info_table_end(h); vy_info_append_compact_stat(h, "dump", &stat->disk.dump); vy_info_append_compact_stat(h, "compact", &stat->disk.compact); - info_append_int(h, "index_size", index->page_index_size); - info_append_int(h, "bloom_size", index->bloom_size); + info_append_int(h, "index_size", lsm->page_index_size); + info_append_int(h, "bloom_size", lsm->bloom_size); info_table_end(h); info_table_begin(h, "cache"); @@ -453,7 +453,7 @@ vinyl_index_info(struct index *base, struct info_handler *h) vy_info_append_stmt_counter(h, "invalidate", &cache_stat->invalidate); vy_info_append_stmt_counter(h, "evict", &cache_stat->evict); info_append_int(h, "index_size", - vy_cache_tree_mem_used(&index->cache.cache_tree)); + vy_cache_tree_mem_used(&lsm->cache.cache_tree)); info_table_end(h); info_table_begin(h, "txw"); @@ -464,21 +464,21 @@ vinyl_index_info(struct index *base, struct info_handler *h) info_table_end(h); info_table_end(h); - info_append_int(h, "range_count", index->range_count); - info_append_int(h, "run_count", index->run_count); - info_append_int(h, "run_avg", index->run_count / index->range_count); - histogram_snprint(buf, sizeof(buf), index->run_hist); + info_append_int(h, "range_count", lsm->range_count); + info_append_int(h, "run_count", lsm->run_count); + info_append_int(h, "run_avg", lsm->run_count / lsm->range_count); + histogram_snprint(buf, sizeof(buf), lsm->run_hist); info_append_str(h, "run_histogram", buf); info_end(h); } static void -vinyl_index_reset_stat(struct index *base) +vinyl_index_reset_stat(struct index *index) { - struct vy_index *index = vy_index(base); - struct vy_index_stat *stat = &index->stat; - struct vy_cache_stat *cache_stat = &index->cache.stat; + struct vy_lsm *lsm = vy_lsm(index); + struct vy_lsm_stat *stat = &lsm->stat; + struct vy_cache_stat *cache_stat = &lsm->cache.stat; stat->lookup = 0; latency_reset(&stat->latency); @@ -507,8 +507,8 @@ vinyl_engine_memory_stat(struct engine *engine, struct engine_memory_stat *stat) stat->data += lsregion_used(&env->mem_env.allocator) - env->mem_env.tree_extent_size; stat->index += env->mem_env.tree_extent_size; - stat->index += env->index_env.bloom_size; - stat->index += env->index_env.page_index_size; + stat->index += env->lsm_env.bloom_size; + stat->index += env->lsm_env.page_index_size; stat->cache += env->cache_env.mem_used; stat->tx += env->xm->write_set_size + env->xm->read_set_size; mempool_stats(&env->xm->tx_mempool, &mstats); @@ -553,31 +553,31 @@ vinyl_check_wal(struct vy_env *env, const char *what) } /** - * Given a space and an index id, return vy_index. + * Given a space and an index id, return vy_lsm. * If index not found, return NULL and set diag. */ -static struct vy_index * -vy_index_find(struct space *space, uint32_t iid) +static struct vy_lsm * +vy_lsm_find(struct space *space, uint32_t iid) { struct index *index = index_find(space, iid); if (index == NULL) return NULL; - return vy_index(index); + return vy_lsm(index); } /** - * Wrapper around vy_index_find() which ensures that + * Wrapper around vy_lsm_find() which ensures that * the found index is unique. */ -static struct vy_index * -vy_index_find_unique(struct space *space, uint32_t index_id) +static struct vy_lsm * +vy_lsm_find_unique(struct space *space, uint32_t index_id) { - struct vy_index *index = vy_index_find(space, index_id); - if (index != NULL && !index->opts.is_unique) { + struct vy_lsm *lsm = vy_lsm_find(space, index_id); + if (lsm != NULL && !lsm->opts.is_unique) { diag_set(ClientError, ER_MORE_THAN_ONE_TUPLE); return NULL; } - return index; + return lsm; } static int @@ -684,39 +684,39 @@ vinyl_space_create_index(struct space *space, struct index_def *index_def) return NULL; } struct vy_env *env = vinyl->env; - struct vy_index *pk = NULL; + struct vy_lsm *pk = NULL; if (index_def->iid > 0) { - pk = vy_index(space_index(space, 0)); + pk = vy_lsm(space_index(space, 0)); assert(pk != NULL); } - struct vy_index *db = vy_index_new(&env->index_env, &env->cache_env, - &env->mem_env, index_def, - space->format, pk); - if (db == NULL) { + struct vy_lsm *lsm = vy_lsm_new(&env->lsm_env, &env->cache_env, + &env->mem_env, index_def, + space->format, pk); + if (lsm == NULL) { free(index); return NULL; } if (index_create(&index->base, (struct engine *)vinyl, &vinyl_index_vtab, index_def) != 0) { - vy_index_delete(db); + vy_lsm_delete(lsm); free(index); return NULL; } - index->db = db; + index->lsm = lsm; return &index->base; } static void -vinyl_index_destroy(struct index *base) +vinyl_index_destroy(struct index *index) { - struct vy_index *index = vy_index(base); + struct vy_lsm *lsm = vy_lsm(index); /* - * There still may be a task scheduled for this index + * There still may be a task scheduled for this LSM tree * so postpone actual deletion until the last reference * is gone. */ - vy_index_unref(index); - free(base); + vy_lsm_unref(lsm); + free(index); } /** @@ -726,8 +726,11 @@ vinyl_index_destroy(struct index *base) * account. */ static int -vy_index_open(struct vy_env *env, struct vy_index *index) +vinyl_index_open(struct index *index) { + struct vy_env *env = vy_env(index->engine); + struct vy_lsm *lsm = vy_lsm(index); + /* Ensure vinyl data directory exists. */ if (access(env->path, F_OK) != 0) { diag_set(SystemError, "can not access vinyl data directory"); @@ -740,7 +743,7 @@ vy_index_open(struct vy_env *env, struct vy_index *index) * The recovery is complete, simply * create a new index. */ - rc = vy_index_create(index); + rc = vy_lsm_create(lsm); if (rc == 0) { /* Make sure reader threads are up and running. */ vy_run_env_enable_coio(&env->run_env, @@ -754,7 +757,7 @@ vy_index_open(struct vy_env *env, struct vy_index *index) * exist locally, and we should create the * index directory from scratch. */ - rc = vy_index_create(index); + rc = vy_lsm_create(lsm); break; case VINYL_INITIAL_RECOVERY_LOCAL: case VINYL_FINAL_RECOVERY_LOCAL: @@ -764,10 +767,10 @@ vy_index_open(struct vy_env *env, struct vy_index *index) * have already been created, so try to load * the index files from it. */ - rc = vy_index_recover(index, env->recovery, &env->run_env, - vclock_sum(env->recovery_vclock), - env->status == VINYL_INITIAL_RECOVERY_LOCAL, - env->force_recovery); + rc = vy_lsm_recover(lsm, env->recovery, &env->run_env, + vclock_sum(env->recovery_vclock), + env->status == VINYL_INITIAL_RECOVERY_LOCAL, + env->force_recovery); break; default: unreachable(); @@ -776,12 +779,12 @@ vy_index_open(struct vy_env *env, struct vy_index *index) } static void -vinyl_index_commit_create(struct index *base, int64_t lsn) +vinyl_index_commit_create(struct index *index, int64_t lsn) { - struct vy_env *env = vy_env(base->engine); - struct vy_index *index = vy_index(base); + struct vy_env *env = vy_env(index->engine); + struct vy_lsm *lsm = vy_lsm(index); - assert(index->id >= 0); + assert(lsm->id >= 0); if (env->status == VINYL_INITIAL_RECOVERY_LOCAL || env->status == VINYL_FINAL_RECOVERY_LOCAL) { @@ -793,8 +796,8 @@ vinyl_index_commit_create(struct index *base, int64_t lsn) * the index isn't in the recovery context and we * need to retry to log it now. */ - if (index->is_committed) { - vy_scheduler_add_index(&env->scheduler, index); + if (lsm->is_committed) { + vy_scheduler_add_lsm(&env->scheduler, lsm); return; } } @@ -815,14 +818,14 @@ vinyl_index_commit_create(struct index *base, int64_t lsn) * index by 1. So for legacy indexes use the LSN from * index options. */ - if (index->opts.lsn != 0) - lsn = index->opts.lsn; + if (lsm->opts.lsn != 0) + lsn = lsm->opts.lsn; - assert(!index->is_committed); - index->is_committed = true; + assert(!lsm->is_committed); + lsm->is_committed = true; - assert(index->range_count == 1); - struct vy_range *range = vy_range_tree_first(index->tree); + assert(lsm->range_count == 1); + struct vy_range *range = vy_range_tree_first(lsm->tree); /* * Since it's too late to fail now, in case of vylog write @@ -833,27 +836,27 @@ vinyl_index_commit_create(struct index *base, int64_t lsn) * recovery. */ vy_log_tx_begin(); - vy_log_create_index(index->id, index->space_id, index->index_id, - index->key_def, lsn); - vy_log_insert_range(index->id, range->id, NULL, NULL); + vy_log_create_lsm(lsm->id, lsm->space_id, lsm->index_id, + lsm->key_def, lsn); + vy_log_insert_range(lsm->id, range->id, NULL, NULL); vy_log_tx_try_commit(); /* * After we committed the index in the log, we can schedule * a task for it. */ - vy_scheduler_add_index(&env->scheduler, index); + vy_scheduler_add_lsm(&env->scheduler, lsm); } /* - * Delete all runs, ranges, and slices of a given index + * Delete all runs, ranges, and slices of a given LSM tree * from the metadata log. */ static void -vy_log_index_prune(struct vy_index *index, int64_t gc_lsn) +vy_log_lsm_prune(struct vy_lsm *lsm, int64_t gc_lsn) { int loops = 0; - for (struct vy_range *range = vy_range_tree_first(index->tree); - range != NULL; range = vy_range_tree_next(index->tree, range)) { + for (struct vy_range *range = vy_range_tree_first(lsm->tree); + range != NULL; range = vy_range_tree_next(lsm->tree, range)) { struct vy_slice *slice; rlist_foreach_entry(slice, &range->slices, in_range) vy_log_delete_slice(slice->id); @@ -862,7 +865,7 @@ vy_log_index_prune(struct vy_index *index, int64_t gc_lsn) fiber_sleep(0); } struct vy_run *run; - rlist_foreach_entry(run, &index->runs, in_index) { + rlist_foreach_entry(run, &lsm->runs, in_lsm) { vy_log_drop_run(run->id, gc_lsn); if (++loops % VY_YIELD_LOOPS == 0) fiber_sleep(0); @@ -870,12 +873,12 @@ vy_log_index_prune(struct vy_index *index, int64_t gc_lsn) } static void -vinyl_index_commit_drop(struct index *base) +vinyl_index_commit_drop(struct index *index) { - struct vy_env *env = vy_env(base->engine); - struct vy_index *index = vy_index(base); + struct vy_env *env = vy_env(index->engine); + struct vy_lsm *lsm = vy_lsm(index); - vy_scheduler_remove_index(&env->scheduler, index); + vy_scheduler_remove_lsm(&env->scheduler, lsm); /* * We can't abort here, because the index drop request has @@ -885,14 +888,14 @@ vinyl_index_commit_drop(struct index *base) * not flushed before the instance is shut down, we replay it * on local recovery from WAL. */ - if (env->status == VINYL_FINAL_RECOVERY_LOCAL && index->is_dropped) + if (env->status == VINYL_FINAL_RECOVERY_LOCAL && lsm->is_dropped) return; - index->is_dropped = true; + lsm->is_dropped = true; vy_log_tx_begin(); - vy_log_index_prune(index, checkpoint_last(NULL)); - vy_log_drop_index(index->id); + vy_log_lsm_prune(lsm, checkpoint_last(NULL)); + vy_log_drop_lsm(lsm->id); vy_log_tx_try_commit(); } @@ -916,7 +919,7 @@ vinyl_space_prepare_alter(struct space *old_space, struct space *new_space) */ if (old_space->index_count == 0) return 0; - struct vy_index *pk = vy_index(old_space->index[0]); + struct vy_lsm *pk = vy_lsm(old_space->index[0]); /* * During WAL recovery, the space may be not empty. But we * open existing indexes, not creating new ones. Allow @@ -984,7 +987,7 @@ vinyl_space_check_format(struct space *new_space, struct space *old_space) /* @sa vy_prepare_alter_space for checks below. */ if (old_space->index_count == 0) return 0; - struct vy_index *pk = vy_index(old_space->index[0]); + struct vy_lsm *pk = vy_lsm(old_space->index[0]); if (env->status != VINYL_ONLINE) return 0; if (pk->stat.disk.count.rows == 0 && pk->stat.memory.count.rows == 0) @@ -1002,7 +1005,7 @@ vinyl_space_commit_alter(struct space *old_space, struct space *new_space) return; /* space drop */ struct tuple_format *new_format = new_space->format; - struct vy_index *pk = vy_index(new_space->index[0]); + struct vy_lsm *pk = vy_lsm(new_space->index[0]); struct index_def *new_index_def = space_index_def(new_space, 0); assert(pk->pk == NULL); @@ -1038,33 +1041,32 @@ vinyl_space_commit_alter(struct space *old_space, struct space *new_space) tuple_format_ref(format); pk->mem_format = new_format; tuple_format_ref(new_format); - vy_index_validate_formats(pk); + vy_lsm_validate_formats(pk); key_def_update_optionality(pk->key_def, new_format->min_field_count); key_def_update_optionality(pk->cmp_def, new_format->min_field_count); for (uint32_t i = 1; i < new_space->index_count; ++i) { - struct vy_index *index = vy_index(new_space->index[i]); - vy_index_unref(index->pk); - vy_index_ref(pk); - index->pk = pk; + struct vy_lsm *lsm = vy_lsm(new_space->index[i]); + vy_lsm_unref(lsm->pk); + vy_lsm_ref(pk); + lsm->pk = pk; new_index_def = space_index_def(new_space, i); - index->opts = new_index_def->opts; - index->check_is_unique = index->opts.is_unique; - tuple_format_unref(index->mem_format_with_colmask); - tuple_format_unref(index->mem_format); - tuple_format_unref(index->upsert_format); - index->mem_format_with_colmask = - pk->mem_format_with_colmask; - index->mem_format = pk->mem_format; - index->upsert_format = pk->upsert_format; - tuple_format_ref(index->mem_format_with_colmask); - tuple_format_ref(index->mem_format); - tuple_format_ref(index->upsert_format); - key_def_update_optionality(index->key_def, + lsm->opts = new_index_def->opts; + lsm->check_is_unique = lsm->opts.is_unique; + tuple_format_unref(lsm->mem_format_with_colmask); + tuple_format_unref(lsm->mem_format); + tuple_format_unref(lsm->upsert_format); + lsm->mem_format_with_colmask = pk->mem_format_with_colmask; + lsm->mem_format = pk->mem_format; + lsm->upsert_format = pk->upsert_format; + tuple_format_ref(lsm->mem_format_with_colmask); + tuple_format_ref(lsm->mem_format); + tuple_format_ref(lsm->upsert_format); + key_def_update_optionality(lsm->key_def, new_format->min_field_count); - key_def_update_optionality(index->cmp_def, + key_def_update_optionality(lsm->cmp_def, new_format->min_field_count); - vy_index_validate_formats(index); + vy_lsm_validate_formats(lsm); } /* @@ -1075,14 +1077,14 @@ vinyl_space_commit_alter(struct space *old_space, struct space *new_space) * likelier to have a "colder" cache. */ for (int i = new_space->index_count - 1; i >= 0; i--) { - struct vy_index *index = vy_index(new_space->index[i]); - if (!index->check_is_unique) + struct vy_lsm *lsm = vy_lsm(new_space->index[i]); + if (!lsm->check_is_unique) continue; for (int j = 0; j < (int)new_space->index_count; j++) { - struct vy_index *other = vy_index(new_space->index[j]); - if (other != index && other->check_is_unique && - key_def_contains(index->key_def, other->key_def)) { - index->check_is_unique = false; + struct vy_lsm *other = vy_lsm(new_space->index[j]); + if (other != lsm && other->check_is_unique && + key_def_contains(lsm->key_def, other->key_def)) { + lsm->check_is_unique = false; break; } } @@ -1098,8 +1100,7 @@ fail: static int vinyl_space_add_primary_key(struct space *space) { - return vy_index_open(vy_env(space->engine), - vy_index(space->index[0])); + return vinyl_index_open(space->index[0]); } static void @@ -1135,8 +1136,7 @@ vinyl_space_build_secondary_key(struct space *old_space, * Engine::buildSecondaryKey(old_space, new_space, new_index_arg); * but aware of three cases mentioned above. */ - return vy_index_open(vy_env(new_index->engine), - vy_index(new_index)); + return vinyl_index_open(new_index); } static size_t @@ -1148,28 +1148,27 @@ vinyl_space_bsize(struct space *space) * primary indexes, it is basically the size of * binary data stored in this space's primary index. */ - struct index *pk_base = space_index(space, 0); - if (pk_base == NULL) + struct index *pk = space_index(space, 0); + if (pk == NULL) return 0; - struct vy_index *pk = vy_index(pk_base); - return pk->stat.memory.count.bytes + pk->stat.disk.count.bytes; + struct vy_lsm *lsm = vy_lsm(pk); + return lsm->stat.memory.count.bytes + lsm->stat.disk.count.bytes; } static ssize_t -vinyl_index_size(struct index *base) +vinyl_index_size(struct index *index) { /* - * Return the total number of statements in the index. - * Note, it may be greater than the number of tuples - * actually stored in the space, but it should be a - * fairly good estimate. + * Return the total number of statements in the LSM tree. + * Note, it may be greater than the number of tuples actually + * stored in the space, but it should be a fairly good estimate. */ - struct vy_index *index = vy_index(base); - return index->stat.memory.count.rows + index->stat.disk.count.rows; + struct vy_lsm *lsm = vy_lsm(index); + return lsm->stat.memory.count.rows + lsm->stat.disk.count.rows; } static ssize_t -vinyl_index_bsize(struct index *base) +vinyl_index_bsize(struct index *index) { /* * Return the cost of indexing user data. For both @@ -1179,11 +1178,11 @@ vinyl_index_bsize(struct index *base) * total size of statements stored on disk, because * they are only needed for building the index. */ - struct vy_index *index = vy_index(base); - ssize_t bsize = vy_index_mem_tree_size(index) + - index->page_index_size + index->bloom_size; - if (index->index_id > 0) - bsize += index->stat.disk.count.bytes; + struct vy_lsm *lsm = vy_lsm(index); + ssize_t bsize = vy_lsm_mem_tree_size(lsm) + + lsm->page_index_size + lsm->bloom_size; + if (lsm->index_id > 0) + bsize += lsm->stat.disk.count.bytes; return bsize; } @@ -1192,25 +1191,25 @@ vinyl_index_bsize(struct index *base) */ /** - * Check if a request has already been committed to an index. + * Check if a request has already been committed to an LSM tree. * * If we're recovering the WAL, it may happen so that this * particular run was dumped after the checkpoint, and we're * replaying records already present in the database. In this * case avoid overwriting a newer version with an older one. * - * If the index is going to be dropped or truncated on WAL + * If the LSM tree is going to be dropped or truncated on WAL * recovery, there's no point in replaying statements for it, * either. */ static inline bool -vy_is_committed_one(struct vy_env *env, struct vy_index *index) +vy_is_committed_one(struct vy_env *env, struct vy_lsm *lsm) { if (likely(env->status != VINYL_FINAL_RECOVERY_LOCAL)) return false; - if (index->is_dropped) + if (lsm->is_dropped) return true; - if (vclock_sum(env->recovery_vclock) <= index->dump_lsn) + if (vclock_sum(env->recovery_vclock) <= lsm->dump_lsn) return true; return false; } @@ -1225,16 +1224,16 @@ vy_is_committed(struct vy_env *env, struct space *space) if (likely(env->status != VINYL_FINAL_RECOVERY_LOCAL)) return false; for (uint32_t iid = 0; iid < space->index_count; iid++) { - struct vy_index *index = vy_index(space->index[iid]); - if (!vy_is_committed_one(env, index)) + struct vy_lsm *lsm = vy_lsm(space->index[iid]); + if (!vy_is_committed_one(env, lsm)) return false; } return true; } /** - * Get a vinyl tuple from the index by the key. - * @param index Index in which search. + * Get a vinyl tuple from the LSM tree by the key. + * @param lsm LSM tree in which search. * @param tx Current transaction. * @param rv Read view. * @param key Key statement. @@ -1245,7 +1244,7 @@ vy_is_committed(struct vy_env *env, struct space *space) * @param -1 Memory error or read error. */ static inline int -vy_index_get(struct vy_index *index, struct vy_tx *tx, +vy_lsm_get(struct vy_lsm *lsm, struct vy_tx *tx, const struct vy_read_view **rv, struct tuple *key, struct tuple **result) { @@ -1255,14 +1254,14 @@ vy_index_get(struct vy_index *index, struct vy_tx *tx, */ assert(tx == NULL || tx->state == VINYL_TX_READY); - if (tuple_field_count(key) >= index->cmp_def->part_count) { - if (tx != NULL && vy_tx_track_point(tx, index, key) != 0) + if (tuple_field_count(key) >= lsm->cmp_def->part_count) { + if (tx != NULL && vy_tx_track_point(tx, lsm, key) != 0) return -1; - return vy_point_lookup(index, tx, rv, key, result); + return vy_point_lookup(lsm, tx, rv, key, result); } struct vy_read_iterator itr; - vy_read_iterator_open(&itr, index, tx, ITER_EQ, key, rv); + vy_read_iterator_open(&itr, lsm, tx, ITER_EQ, key, rv); int rc = vy_read_iterator_next(&itr, result); if (*result != NULL) tuple_ref(*result); @@ -1271,12 +1270,12 @@ vy_index_get(struct vy_index *index, struct vy_tx *tx, } /** - * Check if the index contains the key. If true, then set + * Check if the LSM tree contains the key. If true, then set * a duplicate key error in the diagnostics area. * @param env Vinyl environment. * @param tx Current transaction. * @param space Target space. - * @param index Index in which to search. + * @param lsm LSM tree in which to search. * @param key Key statement. * * @retval 0 Success, the key isn't found. @@ -1284,7 +1283,7 @@ vy_index_get(struct vy_index *index, struct vy_tx *tx, */ static inline int vy_check_is_unique(struct vy_env *env, struct vy_tx *tx, struct space *space, - struct vy_index *index, struct tuple *key) + struct vy_lsm *lsm, struct tuple *key) { struct tuple *found; /* @@ -1293,13 +1292,13 @@ vy_check_is_unique(struct vy_env *env, struct vy_tx *tx, struct space *space, */ if (env->status != VINYL_ONLINE) return 0; - if (vy_index_get(index, tx, vy_tx_read_view(tx), key, &found)) + if (vy_lsm_get(lsm, tx, vy_tx_read_view(tx), key, &found)) return -1; if (found) { tuple_unref(found); diag_set(ClientError, ER_TUPLE_FOUND, - index_name_by_id(space, index->index_id), + index_name_by_id(space, lsm->index_id), space_name(space)); return -1; } @@ -1307,11 +1306,11 @@ vy_check_is_unique(struct vy_env *env, struct vy_tx *tx, struct space *space, } /** - * Insert a tuple in a primary index. + * Insert a tuple in a primary index LSM tree. * @param env Vinyl environment. * @param tx Current transaction. * @param space Target space. - * @param pk Primary vinyl index. + * @param pk Primary index LSM tree. * @param stmt Tuple to insert. * * @retval 0 Success. @@ -1319,7 +1318,7 @@ vy_check_is_unique(struct vy_env *env, struct vy_tx *tx, struct space *space, */ static inline int vy_insert_primary(struct vy_env *env, struct vy_tx *tx, struct space *space, - struct vy_index *pk, struct tuple *stmt) + struct vy_lsm *pk, struct tuple *stmt) { assert(vy_stmt_type(stmt) == IPROTO_INSERT); assert(tx != NULL && tx->state == VINYL_TX_READY); @@ -1335,11 +1334,11 @@ vy_insert_primary(struct vy_env *env, struct vy_tx *tx, struct space *space, } /** - * Insert a tuple in a secondary index. + * Insert a tuple in a secondary index LSM tree. * @param env Vinyl environment. * @param tx Current transaction. * @param space Target space. - * @param index Secondary index. + * @param lsm Secondary index LSM tree. * @param stmt Tuple to replace. * * @retval 0 Success. @@ -1347,38 +1346,38 @@ vy_insert_primary(struct vy_env *env, struct vy_tx *tx, struct space *space, */ static int vy_insert_secondary(struct vy_env *env, struct vy_tx *tx, struct space *space, - struct vy_index *index, struct tuple *stmt) + struct vy_lsm *lsm, struct tuple *stmt) { assert(vy_stmt_type(stmt) == IPROTO_INSERT || vy_stmt_type(stmt) == IPROTO_REPLACE); assert(tx != NULL && tx->state == VINYL_TX_READY); - assert(index->index_id > 0); + assert(lsm->index_id > 0); /* * If the index is unique then the new tuple must not * conflict with existing tuples. If the index is not * unique a conflict is impossible. */ - if (index->check_is_unique && - !key_update_can_be_skipped(index->key_def->column_mask, + if (lsm->check_is_unique && + !key_update_can_be_skipped(lsm->key_def->column_mask, vy_stmt_column_mask(stmt)) && - (!index->key_def->is_nullable || - !vy_tuple_key_contains_null(stmt, index->key_def))) { - struct tuple *key = vy_stmt_extract_key(stmt, index->key_def, - index->env->key_format); + (!lsm->key_def->is_nullable || + !vy_tuple_key_contains_null(stmt, lsm->key_def))) { + struct tuple *key = vy_stmt_extract_key(stmt, lsm->key_def, + lsm->env->key_format); if (key == NULL) return -1; - int rc = vy_check_is_unique(env, tx, space, index, key); + int rc = vy_check_is_unique(env, tx, space, lsm, key); tuple_unref(key); if (rc != 0) return -1; } /* * We must always append the statement to transaction write set - * of each index, even if operation itself does not update - * the index, e.g. it's an UPDATE, to ensure we read our + * of each LSM tree, even if operation itself does not update + * the LSM tree, e.g. it's an UPDATE, to ensure we read our * own writes. */ - return vy_tx_set(tx, index, stmt); + return vy_tx_set(tx, lsm, stmt); } /** @@ -1403,7 +1402,7 @@ vy_replace_one(struct vy_env *env, struct vy_tx *tx, struct space *space, { (void)env; assert(tx != NULL && tx->state == VINYL_TX_READY); - struct vy_index *pk = vy_index(space->index[0]); + struct vy_lsm *pk = vy_lsm(space->index[0]); assert(pk->index_id == 0); if (tuple_validate_raw(pk->mem_format, request->tuple)) return -1; @@ -1417,8 +1416,8 @@ vy_replace_one(struct vy_env *env, struct vy_tx *tx, struct space *space, * old tuple to pass it to the trigger. */ if (stmt != NULL && !rlist_empty(&space->on_replace)) { - if (vy_index_get(pk, tx, vy_tx_read_view(tx), - new_tuple, &stmt->old_tuple) != 0) + if (vy_lsm_get(pk, tx, vy_tx_read_view(tx), + new_tuple, &stmt->old_tuple) != 0) goto error_unref; } if (vy_tx_set(tx, pk, new_tuple)) @@ -1459,7 +1458,7 @@ vy_replace_impl(struct vy_env *env, struct vy_tx *tx, struct space *space, struct tuple *old_stmt = NULL; struct tuple *new_stmt = NULL; struct tuple *delete = NULL; - struct vy_index *pk = vy_index_find(space, 0); + struct vy_lsm *pk = vy_lsm_find(space, 0); if (pk == NULL) /* space has no primary key */ return -1; /* Primary key is dumped last. */ @@ -1473,7 +1472,7 @@ vy_replace_impl(struct vy_env *env, struct vy_tx *tx, struct space *space, return -1; /* Get full tuple from the primary index. */ - if (vy_index_get(pk, tx, vy_tx_read_view(tx), + if (vy_lsm_get(pk, tx, vy_tx_read_view(tx), new_stmt, &old_stmt) != 0) goto error; @@ -1500,9 +1499,8 @@ vy_replace_impl(struct vy_env *env, struct vy_tx *tx, struct space *space, /* Update secondary keys, avoid duplicates. */ for (uint32_t iid = 1; iid < space->index_count; ++iid) { - struct vy_index *index; - index = vy_index(space->index[iid]); - if (vy_is_committed_one(env, index)) + struct vy_lsm *lsm = vy_lsm(space->index[iid]); + if (vy_is_committed_one(env, lsm)) continue; /* * Delete goes first, so if old and new keys @@ -1510,10 +1508,10 @@ vy_replace_impl(struct vy_env *env, struct vy_tx *tx, struct space *space, * transaction index. */ if (old_stmt != NULL) { - if (vy_tx_set(tx, index, delete) != 0) + if (vy_tx_set(tx, lsm, delete) != 0) goto error; } - if (vy_insert_secondary(env, tx, space, index, new_stmt) != 0) + if (vy_insert_secondary(env, tx, space, lsm, new_stmt) != 0) goto error; } if (delete != NULL) @@ -1538,8 +1536,9 @@ error: } /** - * Check that the key can be used for search in a unique index. - * @param index Index for checking. + * Check that the key can be used for search in a unique index + * LSM tree. + * @param lsm LSM tree for checking. * @param key MessagePack'ed data, the array without a * header. * @param part_count Part count of the key. @@ -1549,34 +1548,34 @@ error: * in the diagnostics area. */ static inline int -vy_unique_key_validate(struct vy_index *index, const char *key, +vy_unique_key_validate(struct vy_lsm *lsm, const char *key, uint32_t part_count) { - assert(index->opts.is_unique); + assert(lsm->opts.is_unique); assert(key != NULL || part_count == 0); /* - * The index contains tuples with concatenation of + * The LSM tree contains tuples with concatenation of * secondary and primary key fields, while the key * supplied by the user only contains the secondary key * fields. Use the correct key def to validate the key. - * The key can be used to look up in the index since the - * supplied key parts uniquely identify the tuple, as long - * as the index is unique. + * The key can be used to look up in the LSM tree since + * the supplied key parts uniquely identify the tuple, + * as long as the index is unique. */ - uint32_t original_part_count = index->key_def->part_count; + uint32_t original_part_count = lsm->key_def->part_count; if (original_part_count != part_count) { diag_set(ClientError, ER_EXACT_MATCH, original_part_count, part_count); return -1; } - return key_validate_parts(index->cmp_def, key, part_count, false); + return key_validate_parts(lsm->cmp_def, key, part_count, false); } /** - * Find a tuple in the primary index by the key of the specified - * index. - * @param index Index for which the key is specified. Can be - * both primary and secondary. + * Find a tuple in the primary index LSM tree by the key of the + * specified LSM tree. + * @param lsm LSM tree for which the key is specified. + * Can be both primary and secondary. * @param tx Current transaction. * @param rv Read view. * @param key_raw MessagePack'ed data, the array without a @@ -1589,36 +1588,36 @@ vy_unique_key_validate(struct vy_index *index, const char *key, * @retval -1 Memory error. */ static inline int -vy_index_full_by_key(struct vy_index *index, struct vy_tx *tx, - const struct vy_read_view **rv, - const char *key_raw, uint32_t part_count, - struct tuple **result) +vy_lsm_full_by_key(struct vy_lsm *lsm, struct vy_tx *tx, + const struct vy_read_view **rv, + const char *key_raw, uint32_t part_count, + struct tuple **result) { int rc; - struct tuple *key = vy_stmt_new_select(index->env->key_format, + struct tuple *key = vy_stmt_new_select(lsm->env->key_format, key_raw, part_count); if (key == NULL) return -1; struct tuple *found; - rc = vy_index_get(index, tx, rv, key, &found); + rc = vy_lsm_get(lsm, tx, rv, key, &found); tuple_unref(key); if (rc != 0) return -1; - if (index->index_id == 0 || found == NULL) { + if (lsm->index_id == 0 || found == NULL) { *result = found; return 0; } /* * No need in vy_tx_track() as the tuple is already - * tracked in the secondary index. + * tracked in the secondary index LSM tree. */ - rc = vy_point_lookup(index->pk, tx, rv, found, result); + rc = vy_point_lookup(lsm->pk, tx, rv, found, result); tuple_unref(found); return rc; } /** - * Delete the tuple from all indexes of the vinyl space. + * Delete the tuple from all LSM trees of the vinyl space. * @param env Vinyl environment. * @param tx Current transaction. * @param space Vinyl space. @@ -1631,7 +1630,7 @@ static inline int vy_delete_impl(struct vy_env *env, struct vy_tx *tx, struct space *space, const struct tuple *tuple) { - struct vy_index *pk = vy_index_find(space, 0); + struct vy_lsm *pk = vy_lsm_find(space, 0); if (pk == NULL) return -1; /* Primary key is dumped last. */ @@ -1644,12 +1643,11 @@ vy_delete_impl(struct vy_env *env, struct vy_tx *tx, struct space *space, goto error; /* At second, delete from seconary indexes. */ - struct vy_index *index; for (uint32_t i = 1; i < space->index_count; ++i) { - index = vy_index(space->index[i]); - if (vy_is_committed_one(env, index)) + struct vy_lsm *lsm = vy_lsm(space->index[i]); + if (vy_is_committed_one(env, lsm)) continue; - if (vy_tx_set(tx, index, delete) != 0) + if (vy_tx_set(tx, lsm, delete) != 0) goto error; } tuple_unref(delete); @@ -1678,16 +1676,16 @@ vy_delete(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt, { if (vy_is_committed(env, space)) return 0; - struct vy_index *pk = vy_index_find(space, 0); + struct vy_lsm *pk = vy_lsm_find(space, 0); if (pk == NULL) return -1; - struct vy_index *index = vy_index_find_unique(space, request->index_id); - if (index == NULL) + struct vy_lsm *lsm = vy_lsm_find_unique(space, request->index_id); + if (lsm == NULL) return -1; bool has_secondary = space->index_count > 1; const char *key = request->key; uint32_t part_count = mp_decode_array(&key); - if (vy_unique_key_validate(index, key, part_count)) + if (vy_unique_key_validate(lsm, key, part_count)) return -1; /* * There are two cases when need to get the full tuple @@ -1700,7 +1698,7 @@ vy_delete(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt, * and pass them to indexes for deletion. */ if (has_secondary || !rlist_empty(&space->on_replace)) { - if (vy_index_full_by_key(index, tx, vy_tx_read_view(tx), + if (vy_lsm_full_by_key(lsm, tx, vy_tx_read_view(tx), key, part_count, &stmt->old_tuple) != 0) return -1; if (stmt->old_tuple == NULL) @@ -1710,7 +1708,7 @@ vy_delete(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt, assert(stmt->old_tuple != NULL); return vy_delete_impl(env, tx, space, stmt->old_tuple); } else { /* Primary is the single index in the space. */ - assert(index->index_id == 0); + assert(lsm->index_id == 0); struct tuple *delete = vy_stmt_new_surrogate_delete_from_key(request->key, pk->key_def, @@ -1730,9 +1728,7 @@ vy_delete(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt, * primary key of a tuple, which is prohibited, to avoid funny * effects during replication. * - * @param pk Primary index. - * @param index_name Name of the index which was updated - it may - * be not the primary index. + * @param pk Primary index LSM tree. * @param old_tuple The tuple before update. * @param new_tuple The tuple after update. * @param column_mask Bitmask of the update operation. @@ -1742,7 +1738,7 @@ vy_delete(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt, * @retval -1 Attempt to modify the primary key. */ static inline int -vy_check_update(struct space *space, const struct vy_index *pk, +vy_check_update(struct space *space, const struct vy_lsm *pk, const struct tuple *old_tuple, const struct tuple *new_tuple, uint64_t column_mask) { @@ -1776,23 +1772,23 @@ vy_update(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt, assert(tx != NULL && tx->state == VINYL_TX_READY); if (vy_is_committed(env, space)) return 0; - struct vy_index *index = vy_index_find_unique(space, request->index_id); - if (index == NULL) + struct vy_lsm *lsm = vy_lsm_find_unique(space, request->index_id); + if (lsm == NULL) return -1; const char *key = request->key; uint32_t part_count = mp_decode_array(&key); - if (vy_unique_key_validate(index, key, part_count)) + if (vy_unique_key_validate(lsm, key, part_count)) return -1; - if (vy_index_full_by_key(index, tx, vy_tx_read_view(tx), - key, part_count, &stmt->old_tuple) != 0) + if (vy_lsm_full_by_key(lsm, tx, vy_tx_read_view(tx), + key, part_count, &stmt->old_tuple) != 0) return -1; /* Nothing to update. */ if (stmt->old_tuple == NULL) return 0; /* Apply update operations. */ - struct vy_index *pk = vy_index(space->index[0]); + struct vy_lsm *pk = vy_lsm(space->index[0]); assert(pk != NULL); assert(pk->index_id == 0); /* Primary key is dumped last. */ @@ -1849,12 +1845,12 @@ vy_update(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt, vy_stmt_set_column_mask(delete, column_mask); for (uint32_t i = 1; i < space->index_count; ++i) { - index = vy_index(space->index[i]); - if (vy_is_committed_one(env, index)) + lsm = vy_lsm(space->index[i]); + if (vy_is_committed_one(env, lsm)) continue; - if (vy_tx_set(tx, index, delete) != 0) + if (vy_tx_set(tx, lsm, delete) != 0) goto error; - if (vy_insert_secondary(env, tx, space, index, stmt->new_tuple)) + if (vy_insert_secondary(env, tx, space, lsm, stmt->new_tuple)) goto error; } tuple_unref(delete); @@ -1882,14 +1878,13 @@ vy_insert_first_upsert(struct vy_env *env, struct vy_tx *tx, assert(tx != NULL && tx->state == VINYL_TX_READY); assert(space->index_count > 0); assert(vy_stmt_type(stmt) == IPROTO_INSERT); - struct vy_index *pk = vy_index(space->index[0]); + struct vy_lsm *pk = vy_lsm(space->index[0]); assert(pk->index_id == 0); if (vy_tx_set(tx, pk, stmt) != 0) return -1; - struct vy_index *index; for (uint32_t i = 1; i < space->index_count; ++i) { - index = vy_index(space->index[i]); - if (vy_insert_secondary(env, tx, space, index, stmt) != 0) + struct vy_lsm *lsm = vy_lsm(space->index[i]); + if (vy_insert_secondary(env, tx, space, lsm, stmt) != 0) return -1; } return 0; @@ -1898,7 +1893,7 @@ vy_insert_first_upsert(struct vy_env *env, struct vy_tx *tx, /** * Insert UPSERT into the write set of the transaction. * @param tx Transaction which deletes. - * @param index Index in which \p tx deletes. + * @param lsm LSM tree in which \p tx deletes. * @param tuple MessagePack array. * @param tuple_end End of the tuple. * @param expr MessagePack array of update operations. @@ -1908,7 +1903,7 @@ vy_insert_first_upsert(struct vy_env *env, struct vy_tx *tx, * @retval -1 Memory error. */ static int -vy_index_upsert(struct vy_tx *tx, struct vy_index *index, +vy_lsm_upsert(struct vy_tx *tx, struct vy_lsm *lsm, const char *tuple, const char *tuple_end, const char *expr, const char *expr_end) { @@ -1917,12 +1912,12 @@ vy_index_upsert(struct vy_tx *tx, struct vy_index *index, struct iovec operations[1]; operations[0].iov_base = (void *)expr; operations[0].iov_len = expr_end - expr; - vystmt = vy_stmt_new_upsert(index->upsert_format, tuple, tuple_end, + vystmt = vy_stmt_new_upsert(lsm->upsert_format, tuple, tuple_end, operations, 1); if (vystmt == NULL) return -1; assert(vy_stmt_type(vystmt) == IPROTO_UPSERT); - int rc = vy_tx_set(tx, index, vystmt); + int rc = vy_tx_set(tx, lsm, vystmt); tuple_unref(vystmt); return rc; } @@ -2030,7 +2025,7 @@ vy_upsert(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt, const char *tuple_end = request->tuple_end; const char *ops = request->ops; const char *ops_end = request->ops_end; - struct vy_index *pk = vy_index_find(space, 0); + struct vy_lsm *pk = vy_lsm_find(space, 0); if (pk == NULL) return -1; /* Primary key is dumped last. */ @@ -2039,7 +2034,7 @@ vy_upsert(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt, return -1; if (space->index_count == 1 && rlist_empty(&space->on_replace)) - return vy_index_upsert(tx, pk, tuple, tuple_end, ops, ops_end); + return vy_lsm_upsert(tx, pk, tuple, tuple_end, ops, ops_end); const char *old_tuple, *old_tuple_end; const char *new_tuple, *new_tuple_end; @@ -2059,7 +2054,7 @@ vy_upsert(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt, pk->key_def, pk->env->key_format); if (key == NULL) return -1; - int rc = vy_index_get(pk, tx, vy_tx_read_view(tx), + int rc = vy_lsm_get(pk, tx, vy_tx_read_view(tx), key, &stmt->old_tuple); tuple_unref(key); if (rc != 0) @@ -2111,7 +2106,7 @@ vy_upsert(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt, diag_log(); /* * Upsert is skipped, to match the semantics of - * vy_index_upsert(). + * vy_lsm_upsert(). */ return 0; } @@ -2121,7 +2116,6 @@ vy_upsert(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt, return 0; /* Replace in secondary indexes works as delete insert. */ - struct vy_index *index; struct tuple *delete = vy_stmt_new_surrogate_delete(mask_format, stmt->old_tuple); if (delete == NULL) @@ -2129,12 +2123,12 @@ vy_upsert(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt, vy_stmt_set_column_mask(delete, column_mask); for (uint32_t i = 1; i < space->index_count; ++i) { - index = vy_index(space->index[i]); - if (vy_is_committed_one(env, index)) + struct vy_lsm *lsm = vy_lsm(space->index[i]); + if (vy_is_committed_one(env, lsm)) continue; - if (vy_tx_set(tx, index, delete) != 0) + if (vy_tx_set(tx, lsm, delete) != 0) goto error; - if (vy_insert_secondary(env, tx, space, index, + if (vy_insert_secondary(env, tx, space, lsm, stmt->new_tuple) != 0) goto error; } @@ -2164,7 +2158,7 @@ vy_insert(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt, struct space *space, struct request *request) { assert(stmt != NULL); - struct vy_index *pk = vy_index_find(space, 0); + struct vy_lsm *pk = vy_lsm_find(space, 0); if (pk == NULL) /* The space hasn't the primary index. */ return -1; @@ -2182,10 +2176,10 @@ vy_insert(struct vy_env *env, struct vy_tx *tx, struct txn_stmt *stmt, return -1; for (uint32_t iid = 1; iid < space->index_count; ++iid) { - struct vy_index *index = vy_index(space->index[iid]); - if (vy_is_committed_one(env, index)) + struct vy_lsm *lsm = vy_lsm(space->index[iid]); + if (vy_is_committed_one(env, lsm)) continue; - if (vy_insert_secondary(env, tx, space, index, + if (vy_insert_secondary(env, tx, space, lsm, stmt->new_tuple) != 0) return -1; } @@ -2544,7 +2538,7 @@ vy_squash_queue_new(void); static void vy_squash_queue_delete(struct vy_squash_queue *q); static void -vy_squash_schedule(struct vy_index *index, struct tuple *stmt, +vy_squash_schedule(struct vy_lsm *lsm, struct tuple *stmt, void /* struct vy_env */ *arg); static struct vy_env * @@ -2610,10 +2604,10 @@ vy_env_new(const char *path, size_t memory, vy_env_dump_complete_cb, &e->run_env, &e->xm->read_views); - if (vy_index_env_create(&e->index_env, e->path, - &e->scheduler.generation, - vy_squash_schedule, e) != 0) - goto error_index_env; + if (vy_lsm_env_create(&e->lsm_env, e->path, + &e->scheduler.generation, + vy_squash_schedule, e) != 0) + goto error_lsm_env; struct slab_cache *slab_cache = cord_slab_cache(); mempool_create(&e->iterator_pool, slab_cache, @@ -2627,7 +2621,7 @@ vy_env_new(const char *path, size_t memory, vy_run_env_create(&e->run_env); vy_log_init(e->path); return e; -error_index_env: +error_lsm_env: vy_mem_env_destroy(&e->mem_env); vy_scheduler_destroy(&e->scheduler); vy_squash_queue_delete(e->squash_queue); @@ -2653,7 +2647,7 @@ vy_env_delete(struct vy_env *e) histogram_delete(e->dump_bw); mempool_destroy(&e->iterator_pool); vy_run_env_destroy(&e->run_env); - vy_index_env_destroy(&e->index_env); + vy_lsm_env_destroy(&e->lsm_env); vy_mem_env_destroy(&e->mem_env); vy_cache_env_destroy(&e->cache_env); vy_quota_destroy(&e->quota); @@ -2719,7 +2713,7 @@ vinyl_engine_set_too_long_threshold(struct vinyl_engine *vinyl, double too_long_threshold) { vinyl->env->quota.too_long_threshold = too_long_threshold; - vinyl->env->index_env.too_long_threshold = too_long_threshold; + vinyl->env->lsm_env.too_long_threshold = too_long_threshold; } /** }}} Environment */ @@ -2857,11 +2851,11 @@ vinyl_engine_end_recovery(struct engine *engine) unreachable(); } /* - * Do not start reader threads if no Vinyl index was - * recovered. The threads will be started lazily upon - * the first index creation, see vy_index_open(). + * Do not start reader threads if no LSM tree was recovered. + * The threads will be started lazily upon the first LSM tree + * creation, see vinyl_index_open(). */ - if (e->index_env.index_count > 0) + if (e->lsm_env.lsm_count > 0) vy_run_env_enable_coio(&e->run_env, e->read_threads); return 0; } @@ -2888,14 +2882,14 @@ struct vy_join_ctx { /** ID of the space currently being relayed. */ uint32_t space_id; /** - * Index key definition, as defined by the user. + * LSM tree key definition, as defined by the user. * We only send the primary key, so the definition * provided by the user is correct for compare. */ struct key_def *key_def; - /** Index format used for REPLACE and DELETE statements. */ + /** LSM tree format used for REPLACE and DELETE statements. */ struct tuple_format *format; - /** Index format used for UPSERT statements. */ + /** LSM tree format used for UPSERT statements. */ struct tuple_format *upsert_format; /** * Write iterator for merging runs before sending @@ -2930,13 +2924,13 @@ vy_prepare_send_slice(struct vy_join_ctx *ctx, goto out; if (slice_info->begin != NULL) { - begin = vy_key_from_msgpack(ctx->env->index_env.key_format, + begin = vy_key_from_msgpack(ctx->env->lsm_env.key_format, slice_info->begin); if (begin == NULL) goto out; } if (slice_info->end != NULL) { - end = vy_key_from_msgpack(ctx->env->index_env.key_format, + end = vy_key_from_msgpack(ctx->env->lsm_env.key_format, slice_info->end); if (end == NULL) goto out; @@ -3043,28 +3037,27 @@ out: return rc; } -/** Send all tuples stored in the given index. */ +/** Send all tuples stored in the given LSM tree. */ static int -vy_send_index(struct vy_join_ctx *ctx, - struct vy_index_recovery_info *index_info) +vy_send_lsm(struct vy_join_ctx *ctx, struct vy_lsm_recovery_info *lsm_info) { int rc = -1; - if (index_info->is_dropped) + if (lsm_info->is_dropped) return 0; /* - * We are only interested in the primary index. + * We are only interested in the primary index LSM tree. * Secondary keys will be rebuilt on the destination. */ - if (index_info->index_id != 0) + if (lsm_info->index_id != 0) return 0; - ctx->space_id = index_info->space_id; + ctx->space_id = lsm_info->space_id; /* Create key definition and tuple format. */ - ctx->key_def = key_def_new_with_parts(index_info->key_parts, - index_info->key_part_count); + ctx->key_def = key_def_new_with_parts(lsm_info->key_parts, + lsm_info->key_part_count); if (ctx->key_def == NULL) goto out; ctx->format = tuple_format_new(&vy_tuple_format_vtab, &ctx->key_def, @@ -3079,8 +3072,8 @@ vy_send_index(struct vy_join_ctx *ctx, /* Send ranges. */ struct vy_range_recovery_info *range_info; - assert(!rlist_empty(&index_info->ranges)); - rlist_foreach_entry(range_info, &index_info->ranges, in_index) { + assert(!rlist_empty(&lsm_info->ranges)); + rlist_foreach_entry(range_info, &lsm_info->ranges, in_lsm) { rc = vy_send_range(ctx, range_info); if (rc != 0) break; @@ -3156,9 +3149,9 @@ vinyl_engine_join(struct engine *engine, struct vclock *vclock, goto out_join_cord; } rc = 0; - struct vy_index_recovery_info *index_info; - rlist_foreach_entry(index_info, &recovery->indexes, in_recovery) { - rc = vy_send_index(ctx, index_info); + struct vy_lsm_recovery_info *lsm_info; + rlist_foreach_entry(lsm_info, &recovery->lsms, in_recovery) { + rc = vy_send_lsm(ctx, lsm_info); if (rc != 0) break; } @@ -3251,7 +3244,7 @@ vinyl_space_apply_initial_join_row(struct space *space, struct request *request) */ static void vy_gc_run(struct vy_env *env, - struct vy_index_recovery_info *index_info, + struct vy_lsm_recovery_info *lsm_info, struct vy_run_recovery_info *run_info) { ERROR_INJECT(ERRINJ_VY_GC, @@ -3259,8 +3252,8 @@ vy_gc_run(struct vy_env *env, (long long)run_info->id); return;}); /* Try to delete files. */ - if (vy_run_remove_files(env->path, index_info->space_id, - index_info->index_id, run_info->id) != 0) + if (vy_run_remove_files(env->path, lsm_info->space_id, + lsm_info->index_id, run_info->id) != 0) return; /* Forget the run on success. */ @@ -3287,16 +3280,16 @@ vy_gc(struct vy_env *env, struct vy_recovery *recovery, unsigned int gc_mask, int64_t gc_lsn) { int loops = 0; - struct vy_index_recovery_info *index_info; - rlist_foreach_entry(index_info, &recovery->indexes, in_recovery) { + struct vy_lsm_recovery_info *lsm_info; + rlist_foreach_entry(lsm_info, &recovery->lsms, in_recovery) { struct vy_run_recovery_info *run_info; - rlist_foreach_entry(run_info, &index_info->runs, in_index) { + rlist_foreach_entry(run_info, &lsm_info->runs, in_lsm) { if ((run_info->is_dropped && run_info->gc_lsn < gc_lsn && (gc_mask & VY_GC_DROPPED) != 0) || (run_info->is_incomplete && (gc_mask & VY_GC_INCOMPLETE) != 0)) { - vy_gc_run(env, index_info, run_info); + vy_gc_run(env, lsm_info, run_info); } if (loops % VY_YIELD_LOOPS == 0) fiber_sleep(0); @@ -3350,20 +3343,20 @@ vinyl_engine_backup(struct engine *engine, struct vclock *vclock, } int rc = 0; int loops = 0; - struct vy_index_recovery_info *index_info; - rlist_foreach_entry(index_info, &recovery->indexes, in_recovery) { - if (index_info->is_dropped) + struct vy_lsm_recovery_info *lsm_info; + rlist_foreach_entry(lsm_info, &recovery->lsms, in_recovery) { + if (lsm_info->is_dropped) continue; struct vy_run_recovery_info *run_info; - rlist_foreach_entry(run_info, &index_info->runs, in_index) { + rlist_foreach_entry(run_info, &lsm_info->runs, in_lsm) { if (run_info->is_dropped || run_info->is_incomplete) continue; char path[PATH_MAX]; for (int type = 0; type < vy_file_MAX; type++) { vy_run_snprint_path(path, sizeof(path), env->path, - index_info->space_id, - index_info->index_id, + lsm_info->space_id, + lsm_info->index_id, run_info->id, type); rc = cb(path, cb_arg); if (rc != 0) @@ -3390,8 +3383,8 @@ struct vy_squash { struct stailq_entry next; /** Vinyl environment. */ struct vy_env *env; - /** Index this request is for. */ - struct vy_index *index; + /** LSM tree this request is for. */ + struct vy_lsm *lsm; /** Key to squash upserts for. */ struct tuple *stmt; }; @@ -3409,15 +3402,15 @@ struct vy_squash_queue { static struct vy_squash * vy_squash_new(struct mempool *pool, struct vy_env *env, - struct vy_index *index, struct tuple *stmt) + struct vy_lsm *lsm, struct tuple *stmt) { struct vy_squash *squash; squash = mempool_alloc(pool); if (squash == NULL) return NULL; squash->env = env; - vy_index_ref(index); - squash->index = index; + vy_lsm_ref(lsm); + squash->lsm = lsm; tuple_ref(stmt); squash->stmt = stmt; return squash; @@ -3426,7 +3419,7 @@ vy_squash_new(struct mempool *pool, struct vy_env *env, static void vy_squash_delete(struct mempool *pool, struct vy_squash *squash) { - vy_index_unref(squash->index); + vy_lsm_unref(squash->lsm); tuple_unref(squash->stmt); mempool_free(pool, squash); } @@ -3438,23 +3431,23 @@ vy_squash_process(struct vy_squash *squash) if (inj != NULL && inj->dparam > 0) fiber_sleep(inj->dparam); - struct vy_index *index = squash->index; + struct vy_lsm *lsm = squash->lsm; struct vy_env *env = squash->env; /* * vy_apply_upsert() is used for primary key only, - * so this is the same as index->key_def + * so this is the same as lsm->key_def */ - struct key_def *def = index->cmp_def; + struct key_def *def = lsm->cmp_def; - /* Upserts enabled only in the primary index. */ - assert(index->index_id == 0); + /* Upserts enabled only in the primary index LSM tree. */ + assert(lsm->index_id == 0); /* * Use the committed read view to avoid squashing * prepared, but not committed statements. */ struct tuple *result; - if (vy_point_lookup(index, NULL, &env->xm->p_committed_read_view, + if (vy_point_lookup(lsm, NULL, &env->xm->p_committed_read_view, squash->stmt, &result) != 0) return -1; if (result == NULL) @@ -3465,7 +3458,7 @@ vy_squash_process(struct vy_squash *squash) * have been inserted into the in-memory tree. Apply them to * the result. */ - struct vy_mem *mem = index->mem; + struct vy_mem *mem = lsm->mem; struct tree_mem_key tree_key = { .stmt = result, .lsn = vy_stmt_lsn(result), @@ -3501,7 +3494,7 @@ vy_squash_process(struct vy_squash *squash) * lsns = {1, 2, 3} are squashed. But now the n_upsert * values in the prepared statements are not correct. * If we will not update values, then the - * vy_index_commit_upsert will not be able to squash them. + * vy_lsm_commit_upsert will not be able to squash them. * * So after squashing it is necessary to update n_upsert * value in the prepared statements: @@ -3542,11 +3535,11 @@ vy_squash_process(struct vy_squash *squash) tuple_unref(result); return 0; } - assert(index->index_id == 0); + assert(lsm->index_id == 0); struct tuple *applied = vy_apply_upsert(mem_stmt, result, def, mem->format, mem->upsert_format, true); - index->stat.upsert.applied++; + lsm->stat.upsert.applied++; tuple_unref(result); if (applied == NULL) return -1; @@ -3584,7 +3577,7 @@ vy_squash_process(struct vy_squash *squash) } } - index->stat.upsert.squashed++; + lsm->stat.upsert.squashed++; /* * Insert the resulting REPLACE statement to the mem @@ -3592,7 +3585,7 @@ vy_squash_process(struct vy_squash *squash) */ size_t mem_used_before = lsregion_used(&env->mem_env.allocator); const struct tuple *region_stmt = NULL; - int rc = vy_index_set(index, mem, result, ®ion_stmt); + int rc = vy_lsm_set(lsm, mem, result, ®ion_stmt); tuple_unref(result); size_t mem_used_after = lsregion_used(&env->mem_env.allocator); assert(mem_used_after >= mem_used_before); @@ -3661,13 +3654,13 @@ vy_squash_queue_f(va_list va) * statement after it. Done in a background fiber. */ static void -vy_squash_schedule(struct vy_index *index, struct tuple *stmt, void *arg) +vy_squash_schedule(struct vy_lsm *lsm, struct tuple *stmt, void *arg) { struct vy_env *env = arg; struct vy_squash_queue *sq = env->squash_queue; say_verbose("%s: schedule upsert optimization for %s", - vy_index_name(index), vy_stmt_str(stmt)); + vy_lsm_name(lsm), vy_stmt_str(stmt)); /* Start the upsert squashing fiber on demand. */ if (sq->fiber == NULL) { @@ -3677,7 +3670,7 @@ vy_squash_schedule(struct vy_index *index, struct tuple *stmt, void *arg) fiber_start(sq->fiber, sq); } - struct vy_squash *squash = vy_squash_new(&sq->pool, env, index, stmt); + struct vy_squash *squash = vy_squash_new(&sq->pool, env, lsm, stmt); if (squash == NULL) goto fail; @@ -3712,8 +3705,8 @@ static void vinyl_iterator_close(struct vinyl_iterator *it) { vy_read_iterator_close(&it->iterator); - vy_index_unref(it->index); - it->index = NULL; + vy_lsm_unref(it->lsm); + it->lsm = NULL; tuple_unref(it->key); it->key = NULL; if (it->tx == &it->tx_autocommit) { @@ -3736,7 +3729,7 @@ vinyl_iterator_primary_next(struct iterator *base, struct tuple **ret) { assert(base->next = vinyl_iterator_primary_next); struct vinyl_iterator *it = (struct vinyl_iterator *)base; - assert(it->index->index_id == 0); + assert(it->lsm->index_id == 0); struct tuple *tuple; if (it->tx == NULL) { @@ -3770,7 +3763,7 @@ vinyl_iterator_secondary_next(struct iterator *base, struct tuple **ret) { assert(base->next = vinyl_iterator_secondary_next); struct vinyl_iterator *it = (struct vinyl_iterator *)base; - assert(it->index->index_id > 0); + assert(it->lsm->index_id > 0); struct tuple *tuple; if (it->tx == NULL) { @@ -3805,7 +3798,7 @@ vinyl_iterator_secondary_next(struct iterator *base, struct tuple **ret) * Note, there's no need in vy_tx_track() as the * tuple is already tracked in the secondary index. */ - if (vy_point_lookup(it->index->pk, it->tx, vy_tx_read_view(it->tx), + if (vy_point_lookup(it->lsm->pk, it->tx, vy_tx_read_view(it->tx), tuple, &tuple) != 0) goto fail; *ret = tuple_bless(tuple); @@ -3831,7 +3824,7 @@ static struct iterator * vinyl_index_create_iterator(struct index *base, enum iterator_type type, const char *key, uint32_t part_count) { - struct vy_index *index = vy_index(base); + struct vy_lsm *lsm = vy_lsm(base); struct vy_env *env = vy_env(base->engine); if (type > ITER_GT) { @@ -3846,22 +3839,22 @@ vinyl_index_create_iterator(struct index *base, enum iterator_type type, "mempool", "struct vinyl_iterator"); return NULL; } - it->key = vy_stmt_new_select(index->env->key_format, key, part_count); + it->key = vy_stmt_new_select(lsm->env->key_format, key, part_count); if (it->key == NULL) { mempool_free(&env->iterator_pool, it); return NULL; } iterator_create(&it->base, base); - if (index->index_id == 0) + if (lsm->index_id == 0) it->base.next = vinyl_iterator_primary_next; else it->base.next = vinyl_iterator_secondary_next; it->base.free = vinyl_iterator_free; it->env = env; - it->index = index; - vy_index_ref(index); + it->lsm = lsm; + vy_lsm_ref(lsm); struct vy_tx *tx = in_txn() ? in_txn()->engine_tx : NULL; assert(tx == NULL || tx->state == VINYL_TX_READY); @@ -3879,26 +3872,26 @@ vinyl_index_create_iterator(struct index *base, enum iterator_type type, } it->tx = tx; - vy_read_iterator_open(&it->iterator, index, tx, type, it->key, + vy_read_iterator_open(&it->iterator, lsm, tx, type, it->key, (const struct vy_read_view **)&tx->read_view); return (struct iterator *)it; } static int -vinyl_index_get(struct index *base, const char *key, +vinyl_index_get(struct index *index, const char *key, uint32_t part_count, struct tuple **ret) { - assert(base->def->opts.is_unique); - assert(base->def->key_def->part_count == part_count); + assert(index->def->opts.is_unique); + assert(index->def->key_def->part_count == part_count); - struct vy_index *index = vy_index(base); - struct vy_env *env = vy_env(base->engine); + struct vy_lsm *lsm = vy_lsm(index); + struct vy_env *env = vy_env(index->engine); struct vy_tx *tx = in_txn() ? in_txn()->engine_tx : NULL; const struct vy_read_view **rv = (tx != NULL ? vy_tx_read_view(tx) : &env->xm->p_global_read_view); struct tuple *tuple; - if (vy_index_full_by_key(index, tx, rv, key, part_count, &tuple) != 0) + if (vy_lsm_full_by_key(lsm, tx, rv, key, part_count, &tuple) != 0) return -1; if (tuple != NULL) { diff --git a/src/box/vy_cache.h b/src/box/vy_cache.h index fceda5a2..54fd2892 100644 --- a/src/box/vy_cache.h +++ b/src/box/vy_cache.h @@ -150,7 +150,7 @@ void vy_cache_env_set_quota(struct vy_cache_env *e, size_t quota); /** - * Tuple cache (of one particular index) + * Tuple cache (of one particular LSM tree) */ struct vy_cache { /** diff --git a/src/box/vy_log.c b/src/box/vy_log.c index 0a5dd26e..a9fe68cc 100644 --- a/src/box/vy_log.c +++ b/src/box/vy_log.c @@ -68,13 +68,13 @@ * Used for packing a record in MsgPack. */ enum vy_log_key { - VY_LOG_KEY_INDEX_ID = 0, + VY_LOG_KEY_LSM_ID = 0, VY_LOG_KEY_RANGE_ID = 1, VY_LOG_KEY_RUN_ID = 2, VY_LOG_KEY_BEGIN = 3, VY_LOG_KEY_END = 4, - VY_LOG_KEY_INDEX_DEF_ID = 5, - VY_LOG_KEY_SPACE_DEF_ID = 6, + VY_LOG_KEY_INDEX_ID = 5, + VY_LOG_KEY_SPACE_ID = 6, VY_LOG_KEY_DEF = 7, VY_LOG_KEY_SLICE_ID = 8, VY_LOG_KEY_DUMP_LSN = 9, @@ -85,13 +85,13 @@ enum vy_log_key { /** vy_log_key -> human readable name. */ static const char *vy_log_key_name[] = { - [VY_LOG_KEY_INDEX_ID] = "index_id", + [VY_LOG_KEY_LSM_ID] = "lsm_id", [VY_LOG_KEY_RANGE_ID] = "range_id", [VY_LOG_KEY_RUN_ID] = "run_id", [VY_LOG_KEY_BEGIN] = "begin", [VY_LOG_KEY_END] = "end", - [VY_LOG_KEY_INDEX_DEF_ID] = "index_def_id", - [VY_LOG_KEY_SPACE_DEF_ID] = "space_def_id", + [VY_LOG_KEY_INDEX_ID] = "index_id", + [VY_LOG_KEY_SPACE_ID] = "space_id", [VY_LOG_KEY_DEF] = "key_def", [VY_LOG_KEY_SLICE_ID] = "slice_id", [VY_LOG_KEY_DUMP_LSN] = "dump_lsn", @@ -102,8 +102,8 @@ static const char *vy_log_key_name[] = { /** vy_log_type -> human readable name. */ static const char *vy_log_type_name[] = { - [VY_LOG_CREATE_INDEX] = "create_index", - [VY_LOG_DROP_INDEX] = "drop_index", + [VY_LOG_CREATE_LSM] = "create_lsm", + [VY_LOG_DROP_LSM] = "drop_lsm", [VY_LOG_INSERT_RANGE] = "insert_range", [VY_LOG_DELETE_RANGE] = "delete_range", [VY_LOG_PREPARE_RUN] = "prepare_run", @@ -112,9 +112,9 @@ static const char *vy_log_type_name[] = { [VY_LOG_FORGET_RUN] = "forget_run", [VY_LOG_INSERT_SLICE] = "insert_slice", [VY_LOG_DELETE_SLICE] = "delete_slice", - [VY_LOG_DUMP_INDEX] = "dump_index", + [VY_LOG_DUMP_LSM] = "dump_lsm", [VY_LOG_SNAPSHOT] = "snapshot", - [VY_LOG_TRUNCATE_INDEX] = "truncate_index", + [VY_LOG_TRUNCATE_LSM] = "truncate_lsm", }; /** Metadata log object. */ @@ -209,10 +209,9 @@ vy_log_record_snprint(char *buf, int size, const struct vy_log_record *record) assert(record->type < vy_log_record_type_MAX); SNPRINT(total, snprintf, buf, size, "%s{", vy_log_type_name[record->type]); - if (record->index_id > 0) + if (record->lsm_id > 0) SNPRINT(total, snprintf, buf, size, "%s=%"PRIi64", ", - vy_log_key_name[VY_LOG_KEY_INDEX_ID], - record->index_id); + vy_log_key_name[VY_LOG_KEY_LSM_ID], record->lsm_id); if (record->range_id > 0) SNPRINT(total, snprintf, buf, size, "%s=%"PRIi64", ", vy_log_key_name[VY_LOG_KEY_RANGE_ID], @@ -233,14 +232,12 @@ vy_log_record_snprint(char *buf, int size, const struct vy_log_record *record) SNPRINT(total, mp_snprint, buf, size, record->end); SNPRINT(total, snprintf, buf, size, ", "); } - if (record->index_def_id > 0) + if (record->index_id > 0) SNPRINT(total, snprintf, buf, size, "%s=%"PRIu32", ", - vy_log_key_name[VY_LOG_KEY_INDEX_DEF_ID], - record->index_def_id); - if (record->space_def_id > 0) + vy_log_key_name[VY_LOG_KEY_INDEX_ID], record->index_id); + if (record->space_id > 0) SNPRINT(total, snprintf, buf, size, "%s=%"PRIu32", ", - vy_log_key_name[VY_LOG_KEY_SPACE_DEF_ID], - record->space_def_id); + vy_log_key_name[VY_LOG_KEY_SPACE_ID], record->space_id); if (record->key_parts != NULL) { SNPRINT(total, snprintf, buf, size, "%s=", vy_log_key_name[VY_LOG_KEY_DEF]); @@ -307,9 +304,9 @@ vy_log_record_encode(const struct vy_log_record *record, size += mp_sizeof_array(2); size += mp_sizeof_uint(record->type); size_t n_keys = 0; - if (record->index_id > 0) { - size += mp_sizeof_uint(VY_LOG_KEY_INDEX_ID); - size += mp_sizeof_uint(record->index_id); + if (record->lsm_id > 0) { + size += mp_sizeof_uint(VY_LOG_KEY_LSM_ID); + size += mp_sizeof_uint(record->lsm_id); n_keys++; } if (record->range_id > 0) { @@ -338,14 +335,14 @@ vy_log_record_encode(const struct vy_log_record *record, size += p - record->end; n_keys++; } - if (record->index_def_id > 0) { - size += mp_sizeof_uint(VY_LOG_KEY_INDEX_DEF_ID); - size += mp_sizeof_uint(record->index_def_id); + if (record->index_id > 0) { + size += mp_sizeof_uint(VY_LOG_KEY_INDEX_ID); + size += mp_sizeof_uint(record->index_id); n_keys++; } - if (record->space_def_id > 0) { - size += mp_sizeof_uint(VY_LOG_KEY_SPACE_DEF_ID); - size += mp_sizeof_uint(record->space_def_id); + if (record->space_id > 0) { + size += mp_sizeof_uint(VY_LOG_KEY_SPACE_ID); + size += mp_sizeof_uint(record->space_id); n_keys++; } if (record->key_parts != NULL) { @@ -389,9 +386,9 @@ vy_log_record_encode(const struct vy_log_record *record, pos = mp_encode_array(pos, 2); pos = mp_encode_uint(pos, record->type); pos = mp_encode_map(pos, n_keys); - if (record->index_id > 0) { - pos = mp_encode_uint(pos, VY_LOG_KEY_INDEX_ID); - pos = mp_encode_uint(pos, record->index_id); + if (record->lsm_id > 0) { + pos = mp_encode_uint(pos, VY_LOG_KEY_LSM_ID); + pos = mp_encode_uint(pos, record->lsm_id); } if (record->range_id > 0) { pos = mp_encode_uint(pos, VY_LOG_KEY_RANGE_ID); @@ -415,13 +412,13 @@ vy_log_record_encode(const struct vy_log_record *record, memcpy(pos, record->end, p - record->end); pos += p - record->end; } - if (record->index_def_id > 0) { - pos = mp_encode_uint(pos, VY_LOG_KEY_INDEX_DEF_ID); - pos = mp_encode_uint(pos, record->index_def_id); + if (record->index_id > 0) { + pos = mp_encode_uint(pos, VY_LOG_KEY_INDEX_ID); + pos = mp_encode_uint(pos, record->index_id); } - if (record->space_def_id > 0) { - pos = mp_encode_uint(pos, VY_LOG_KEY_SPACE_DEF_ID); - pos = mp_encode_uint(pos, record->space_def_id); + if (record->space_id > 0) { + pos = mp_encode_uint(pos, VY_LOG_KEY_SPACE_ID); + pos = mp_encode_uint(pos, record->space_id); } if (record->key_parts != NULL) { pos = mp_encode_uint(pos, VY_LOG_KEY_DEF); @@ -504,8 +501,8 @@ vy_log_record_decode(struct vy_log_record *record, for (uint32_t i = 0; i < n_keys; i++) { uint32_t key = mp_decode_uint(&pos); switch (key) { - case VY_LOG_KEY_INDEX_ID: - record->index_id = mp_decode_uint(&pos); + case VY_LOG_KEY_LSM_ID: + record->lsm_id = mp_decode_uint(&pos); break; case VY_LOG_KEY_RANGE_ID: record->range_id = mp_decode_uint(&pos); @@ -523,11 +520,11 @@ vy_log_record_decode(struct vy_log_record *record, record->end = mp_decode_array(&tmp) > 0 ? pos : NULL; mp_next(&pos); break; - case VY_LOG_KEY_INDEX_DEF_ID: - record->index_def_id = mp_decode_uint(&pos); + case VY_LOG_KEY_INDEX_ID: + record->index_id = mp_decode_uint(&pos); break; - case VY_LOG_KEY_SPACE_DEF_ID: - record->space_def_id = mp_decode_uint(&pos); + case VY_LOG_KEY_SPACE_ID: + record->space_id = mp_decode_uint(&pos); break; case VY_LOG_KEY_DEF: { uint32_t part_count = mp_decode_array(&pos); @@ -573,16 +570,16 @@ vy_log_record_decode(struct vy_log_record *record, goto fail; } } - if (record->type == VY_LOG_CREATE_INDEX && record->commit_lsn == 0) { + if (record->type == VY_LOG_CREATE_LSM && record->commit_lsn == 0) { /* - * We used to use LSN as unique index identifier + * We used to use LSN as unique LSM tree identifier * and didn't store LSN separately so if there's * no 'commit_lsn' field in the record, we are * recovering from an old vylog and 'id' is in * fact the LSN of the WAL record that committed - * the index. + * the LSM tree. */ - record->commit_lsn = record->index_id; + record->commit_lsn = record->lsm_id; } return 0; fail: @@ -1034,7 +1031,7 @@ vy_log_tx_do_commit(bool no_discard) /* * During recovery, we may replay records we failed to commit - * before restart (e.g. drop index). Since the log isn't open + * before restart (e.g. drop LSM tree). Since the log isn't open * yet, simply leave them in the tx buffer to be flushed upon * recovery completion. */ @@ -1109,10 +1106,10 @@ vy_recovery_index_id_hash(uint32_t space_id, uint32_t index_id) return ((uint64_t)space_id << 32) + index_id; } -/** Lookup a vinyl index in vy_recovery::index_id_hash map. */ -struct vy_index_recovery_info * -vy_recovery_index_by_id(struct vy_recovery *recovery, - uint32_t space_id, uint32_t index_id) +/** Lookup an LSM tree in vy_recovery::index_id_hash map. */ +struct vy_lsm_recovery_info * +vy_recovery_lsm_by_index_id(struct vy_recovery *recovery, + uint32_t space_id, uint32_t index_id) { int64_t key = vy_recovery_index_id_hash(space_id, index_id); struct mh_i64ptr_t *h = recovery->index_id_hash; @@ -1122,11 +1119,11 @@ vy_recovery_index_by_id(struct vy_recovery *recovery, return mh_i64ptr_node(h, k)->val; } -/** Lookup a vinyl index in vy_recovery::index_hash map. */ -static struct vy_index_recovery_info * -vy_recovery_lookup_index(struct vy_recovery *recovery, int64_t id) +/** Lookup an LSM tree in vy_recovery::index_hash map. */ +static struct vy_lsm_recovery_info * +vy_recovery_lookup_lsm(struct vy_recovery *recovery, int64_t id) { - struct mh_i64ptr_t *h = recovery->index_hash; + struct mh_i64ptr_t *h = recovery->lsm_hash; mh_int_t k = mh_i64ptr_find(h, id, NULL); if (k == mh_end(h)) return NULL; @@ -1167,18 +1164,18 @@ vy_recovery_lookup_slice(struct vy_recovery *recovery, int64_t slice_id) } /** - * Handle a VY_LOG_CREATE_INDEX log record. - * This function allocates a new vinyl index with ID @id + * Handle a VY_LOG_CREATE_LSM log record. + * This function allocates a new vinyl LSM tree with ID @id * and inserts it to the hash. * Return 0 on success, -1 on failure (ID collision or OOM). */ static int -vy_recovery_create_index(struct vy_recovery *recovery, int64_t id, - uint32_t space_id, uint32_t index_id, - const struct key_part_def *key_parts, - uint32_t key_part_count, int64_t commit_lsn) +vy_recovery_create_lsm(struct vy_recovery *recovery, int64_t id, + uint32_t space_id, uint32_t index_id, + const struct key_part_def *key_parts, + uint32_t key_part_count, int64_t commit_lsn) { - struct vy_index_recovery_info *index; + struct vy_lsm_recovery_info *lsm; struct key_part_def *key_parts_copy; struct mh_i64ptr_node_t node; struct mh_i64ptr_t *h; @@ -1186,11 +1183,11 @@ vy_recovery_create_index(struct vy_recovery *recovery, int64_t id, /* * Make a copy of the key definition to be used for - * the new index incarnation. + * the new LSM tree incarnation. */ if (key_parts == NULL) { diag_set(ClientError, ER_INVALID_VYLOG_FILE, - tt_sprintf("Missing key definition for index %lld", + tt_sprintf("Missing key definition for LSM tree %lld", (long long)id)); return -1; } @@ -1203,77 +1200,77 @@ vy_recovery_create_index(struct vy_recovery *recovery, int64_t id, memcpy(key_parts_copy, key_parts, sizeof(*key_parts) * key_part_count); /* - * Look up the index in the hash. + * Look up the LSM tree in the hash. */ h = recovery->index_id_hash; node.key = vy_recovery_index_id_hash(space_id, index_id); k = mh_i64ptr_find(h, node.key, NULL); - index = (k != mh_end(h)) ? mh_i64ptr_node(h, k)->val : NULL; + lsm = (k != mh_end(h)) ? mh_i64ptr_node(h, k)->val : NULL; - if (index == NULL) { + if (lsm == NULL) { /* - * This is the first time the index is created + * This is the first time the LSM tree is created * (there's no previous incarnation in the context). - * Allocate a node for the index and add it to + * Allocate a node for the LSM tree and add it to * the hash. */ - index = malloc(sizeof(*index)); - if (index == NULL) { - diag_set(OutOfMemory, sizeof(*index), - "malloc", "struct vy_index_recovery_info"); + lsm = malloc(sizeof(*lsm)); + if (lsm == NULL) { + diag_set(OutOfMemory, sizeof(*lsm), + "malloc", "struct vy_lsm_recovery_info"); free(key_parts_copy); return -1; } - index->index_id = index_id; - index->space_id = space_id; - rlist_create(&index->ranges); - rlist_create(&index->runs); + lsm->index_id = index_id; + lsm->space_id = space_id; + rlist_create(&lsm->ranges); + rlist_create(&lsm->runs); - node.val = index; + node.val = lsm; if (mh_i64ptr_put(h, &node, NULL, NULL) == mh_end(h)) { diag_set(OutOfMemory, 0, "mh_i64ptr_put", "mh_i64ptr_node_t"); free(key_parts_copy); - free(index); + free(lsm); return -1; } - rlist_add_entry(&recovery->indexes, index, in_recovery); + rlist_add_entry(&recovery->lsms, lsm, in_recovery); } else { /* - * The index was dropped and recreated with the + * The LSM tree was dropped and recreated with the * same ID. Update its key definition (because it * could have changed since the last time it was * used) and reset its state. */ - if (!index->is_dropped) { + if (!lsm->is_dropped) { diag_set(ClientError, ER_INVALID_VYLOG_FILE, - tt_sprintf("Index %u/%u created twice", + tt_sprintf("LSM tree %u/%u created twice", (unsigned)space_id, (unsigned)index_id)); free(key_parts_copy); return -1; } - assert(index->index_id == index_id); - assert(index->space_id == space_id); - free(index->key_parts); + assert(lsm->index_id == index_id); + assert(lsm->space_id == space_id); + free(lsm->key_parts); } - index->id = id; - index->key_parts = key_parts_copy; - index->key_part_count = key_part_count; - index->is_dropped = false; - index->commit_lsn = commit_lsn; - index->dump_lsn = -1; + lsm->id = id; + lsm->key_parts = key_parts_copy; + lsm->key_part_count = key_part_count; + lsm->is_dropped = false; + lsm->commit_lsn = commit_lsn; + lsm->dump_lsn = -1; /* - * Add the index to the hash. + * Add the LSM tree to the hash. */ - h = recovery->index_hash; + h = recovery->lsm_hash; node.key = id; - node.val = index; + node.val = lsm; if (mh_i64ptr_find(h, id, NULL) != mh_end(h)) { diag_set(ClientError, ER_INVALID_VYLOG_FILE, - tt_sprintf("Duplicate index id %lld", + tt_sprintf("Duplicate LSM tree id %lld", (long long)id)); return -1; } @@ -1290,72 +1287,72 @@ vy_recovery_create_index(struct vy_recovery *recovery, int64_t id, } /** - * Handle a VY_LOG_DROP_INDEX log record. - * This function marks the vinyl index with ID @id as dropped. - * All ranges and runs of the index must have been deleted by now. - * Returns 0 on success, -1 if ID not found or index is already marked. + * Handle a VY_LOG_DROP_LSM log record. + * This function marks the LSM tree with ID @id as dropped. + * All ranges and runs of the LSM tree must have been deleted by now. + * Returns 0 on success, -1 if ID not found or LSM tree is already marked. */ static int -vy_recovery_drop_index(struct vy_recovery *recovery, int64_t id) +vy_recovery_drop_lsm(struct vy_recovery *recovery, int64_t id) { - struct vy_index_recovery_info *index; - index = vy_recovery_lookup_index(recovery, id); - if (index == NULL) { + struct vy_lsm_recovery_info *lsm; + lsm = vy_recovery_lookup_lsm(recovery, id); + if (lsm == NULL) { diag_set(ClientError, ER_INVALID_VYLOG_FILE, - tt_sprintf("Index %lld deleted but not registered", + tt_sprintf("LSM tree %lld deleted but not registered", (long long)id)); return -1; } - if (index->is_dropped) { + if (lsm->is_dropped) { diag_set(ClientError, ER_INVALID_VYLOG_FILE, - tt_sprintf("Index %lld deleted twice", + tt_sprintf("LSM tree %lld deleted twice", (long long)id)); return -1; } - if (!rlist_empty(&index->ranges)) { + if (!rlist_empty(&lsm->ranges)) { diag_set(ClientError, ER_INVALID_VYLOG_FILE, - tt_sprintf("Dropped index %lld has ranges", + tt_sprintf("Dropped LSM tree %lld has ranges", (long long)id)); return -1; } struct vy_run_recovery_info *run; - rlist_foreach_entry(run, &index->runs, in_index) { + rlist_foreach_entry(run, &lsm->runs, in_lsm) { if (!run->is_dropped && !run->is_incomplete) { diag_set(ClientError, ER_INVALID_VYLOG_FILE, - tt_sprintf("Dropped index %lld has active " + tt_sprintf("Dropped LSM tree %lld has active " "runs", (long long)id)); return -1; } } - index->is_dropped = true; + lsm->is_dropped = true; return 0; } /** - * Handle a VY_LOG_DUMP_INDEX log record. - * This function updates LSN of the last dump of the vinyl index + * Handle a VY_LOG_DUMP_LSM log record. + * This function updates LSN of the last dump of the LSM tree * with ID @id. - * Returns 0 on success, -1 if ID not found or index is dropped. + * Returns 0 on success, -1 if ID not found or LSM tree is dropped. */ static int -vy_recovery_dump_index(struct vy_recovery *recovery, - int64_t id, int64_t dump_lsn) +vy_recovery_dump_lsm(struct vy_recovery *recovery, + int64_t id, int64_t dump_lsn) { - struct vy_index_recovery_info *index; - index = vy_recovery_lookup_index(recovery, id); - if (index == NULL) { + struct vy_lsm_recovery_info *lsm; + lsm = vy_recovery_lookup_lsm(recovery, id); + if (lsm == NULL) { diag_set(ClientError, ER_INVALID_VYLOG_FILE, - tt_sprintf("Dump of unregistered index %lld", + tt_sprintf("Dump of unregistered LSM tree %lld", (long long)id)); return -1; } - if (index->is_dropped) { + if (lsm->is_dropped) { diag_set(ClientError, ER_INVALID_VYLOG_FILE, - tt_sprintf("Dump of deleted index %lld", + tt_sprintf("Dump of deleted LSM tree %lld", (long long)id)); return -1; } - index->dump_lsn = dump_lsn; + lsm->dump_lsn = dump_lsn; return 0; } @@ -1387,7 +1384,7 @@ vy_recovery_do_create_run(struct vy_recovery *recovery, int64_t run_id) run->is_incomplete = false; run->is_dropped = false; run->data = NULL; - rlist_create(&run->in_index); + rlist_create(&run->in_lsm); if (recovery->max_id < run_id) recovery->max_id = run_id; return run; @@ -1396,21 +1393,21 @@ vy_recovery_do_create_run(struct vy_recovery *recovery, int64_t run_id) /** * Handle a VY_LOG_PREPARE_RUN log record. * This function creates a new incomplete vinyl run with ID @run_id - * and adds it to the list of runs of the index with ID @index_id. - * Return 0 on success, -1 if run already exists, index not found, + * and adds it to the list of runs of the LSM tree with ID @lsm_id. + * Return 0 on success, -1 if run already exists, LSM tree not found, * or OOM. */ static int -vy_recovery_prepare_run(struct vy_recovery *recovery, int64_t index_id, +vy_recovery_prepare_run(struct vy_recovery *recovery, int64_t lsm_id, int64_t run_id) { - struct vy_index_recovery_info *index; - index = vy_recovery_lookup_index(recovery, index_id); - if (index == NULL) { + struct vy_lsm_recovery_info *lsm; + lsm = vy_recovery_lookup_lsm(recovery, lsm_id); + if (lsm == NULL) { diag_set(ClientError, ER_INVALID_VYLOG_FILE, tt_sprintf("Run %lld created for unregistered " - "index %lld", (long long)run_id, - (long long)index_id)); + "LSM tree %lld", (long long)run_id, + (long long)lsm_id)); return -1; } if (vy_recovery_lookup_run(recovery, run_id) != NULL) { @@ -1424,36 +1421,36 @@ vy_recovery_prepare_run(struct vy_recovery *recovery, int64_t index_id, if (run == NULL) return -1; run->is_incomplete = true; - rlist_add_entry(&index->runs, run, in_index); + rlist_add_entry(&lsm->runs, run, in_lsm); return 0; } /** * Handle a VY_LOG_CREATE_RUN log record. * This function adds the vinyl run with ID @run_id to the list - * of runs of the index with ID @index_id and marks it committed. + * of runs of the LSM tree with ID @ sm_id and marks it committed. * If the run does not exist, it will be created. - * Return 0 on success, -1 if index not found, run or index + * Return 0 on success, -1 if LSM tree not found, run or LSM tree * is dropped, or OOM. */ static int -vy_recovery_create_run(struct vy_recovery *recovery, int64_t index_id, +vy_recovery_create_run(struct vy_recovery *recovery, int64_t lsm_id, int64_t run_id, int64_t dump_lsn) { - struct vy_index_recovery_info *index; - index = vy_recovery_lookup_index(recovery, index_id); - if (index == NULL) { + struct vy_lsm_recovery_info *lsm; + lsm = vy_recovery_lookup_lsm(recovery, lsm_id); + if (lsm == NULL) { diag_set(ClientError, ER_INVALID_VYLOG_FILE, tt_sprintf("Run %lld created for unregistered " - "index %lld", (long long)run_id, - (long long)index_id)); + "LSM tree %lld", (long long)run_id, + (long long)lsm_id)); return -1; } - if (index->is_dropped) { + if (lsm->is_dropped) { diag_set(ClientError, ER_INVALID_VYLOG_FILE, tt_sprintf("Run %lld created for deleted " - "index %lld", (long long)run_id, - (long long)index_id)); + "LSM tree %lld", (long long)run_id, + (long long)lsm_id)); return -1; } struct vy_run_recovery_info *run; @@ -1471,7 +1468,7 @@ vy_recovery_create_run(struct vy_recovery *recovery, int64_t index_id, } run->dump_lsn = dump_lsn; run->is_incomplete = false; - rlist_move_entry(&index->runs, run, in_index); + rlist_move_entry(&lsm->runs, run, in_lsm); return 0; } @@ -1523,7 +1520,7 @@ vy_recovery_forget_run(struct vy_recovery *recovery, int64_t run_id) } struct vy_run_recovery_info *run = mh_i64ptr_node(h, k)->val; mh_i64ptr_del(h, k, NULL); - rlist_del_entry(run, in_index); + rlist_del_entry(run, in_lsm); free(run); return 0; } @@ -1532,11 +1529,11 @@ vy_recovery_forget_run(struct vy_recovery *recovery, int64_t run_id) * Handle a VY_LOG_INSERT_RANGE log record. * This function allocates a new vinyl range with ID @range_id, * inserts it to the hash, and adds it to the list of ranges of the - * index with ID @index_id. + * LSM tree with ID @lsm_id. * Return 0 on success, -1 on failure (ID collision or OOM). */ static int -vy_recovery_insert_range(struct vy_recovery *recovery, int64_t index_id, +vy_recovery_insert_range(struct vy_recovery *recovery, int64_t lsm_id, int64_t range_id, const char *begin, const char *end) { if (vy_recovery_lookup_range(recovery, range_id) != NULL) { @@ -1545,13 +1542,13 @@ vy_recovery_insert_range(struct vy_recovery *recovery, int64_t index_id, (long long)range_id)); return -1; } - struct vy_index_recovery_info *index; - index = vy_recovery_lookup_index(recovery, index_id); - if (index == NULL) { + struct vy_lsm_recovery_info *lsm; + lsm = vy_recovery_lookup_lsm(recovery, lsm_id); + if (lsm == NULL) { diag_set(ClientError, ER_INVALID_VYLOG_FILE, tt_sprintf("Range %lld created for unregistered " - "index %lld", (long long)range_id, - (long long)index_id)); + "LSM tree %lld", (long long)range_id, + (long long)lsm_id)); return -1; } @@ -1593,7 +1590,7 @@ vy_recovery_insert_range(struct vy_recovery *recovery, int64_t index_id, } else range->end = NULL; rlist_create(&range->slices); - rlist_add_entry(&index->ranges, range, in_index); + rlist_add_entry(&lsm->ranges, range, in_lsm); if (recovery->max_id < range_id) recovery->max_id = range_id; return 0; @@ -1624,7 +1621,7 @@ vy_recovery_delete_range(struct vy_recovery *recovery, int64_t range_id) return -1; } mh_i64ptr_del(h, k, NULL); - rlist_del_entry(range, in_index); + rlist_del_entry(range, in_lsm); free(range); return 0; } @@ -1757,28 +1754,28 @@ vy_recovery_process_record(struct vy_recovery *recovery, { int rc; switch (record->type) { - case VY_LOG_CREATE_INDEX: - rc = vy_recovery_create_index(recovery, record->index_id, - record->space_def_id, record->index_def_id, + case VY_LOG_CREATE_LSM: + rc = vy_recovery_create_lsm(recovery, record->lsm_id, + record->space_id, record->index_id, record->key_parts, record->key_part_count, record->commit_lsn); break; - case VY_LOG_DROP_INDEX: - rc = vy_recovery_drop_index(recovery, record->index_id); + case VY_LOG_DROP_LSM: + rc = vy_recovery_drop_lsm(recovery, record->lsm_id); break; case VY_LOG_INSERT_RANGE: - rc = vy_recovery_insert_range(recovery, record->index_id, + rc = vy_recovery_insert_range(recovery, record->lsm_id, record->range_id, record->begin, record->end); break; case VY_LOG_DELETE_RANGE: rc = vy_recovery_delete_range(recovery, record->range_id); break; case VY_LOG_PREPARE_RUN: - rc = vy_recovery_prepare_run(recovery, record->index_id, + rc = vy_recovery_prepare_run(recovery, record->lsm_id, record->run_id); break; case VY_LOG_CREATE_RUN: - rc = vy_recovery_create_run(recovery, record->index_id, + rc = vy_recovery_create_run(recovery, record->lsm_id, record->run_id, record->dump_lsn); break; case VY_LOG_DROP_RUN: @@ -1796,11 +1793,11 @@ vy_recovery_process_record(struct vy_recovery *recovery, case VY_LOG_DELETE_SLICE: rc = vy_recovery_delete_slice(recovery, record->slice_id); break; - case VY_LOG_DUMP_INDEX: - rc = vy_recovery_dump_index(recovery, record->index_id, + case VY_LOG_DUMP_LSM: + rc = vy_recovery_dump_lsm(recovery, record->lsm_id, record->dump_lsn); break; - case VY_LOG_TRUNCATE_INDEX: + case VY_LOG_TRUNCATE_LSM: /* Not used anymore, ignore. */ rc = 0; break; @@ -1829,21 +1826,21 @@ vy_recovery_new_f(va_list ap) goto fail; } - rlist_create(&recovery->indexes); + rlist_create(&recovery->lsms); recovery->index_id_hash = NULL; - recovery->index_hash = NULL; + recovery->lsm_hash = NULL; recovery->range_hash = NULL; recovery->run_hash = NULL; recovery->slice_hash = NULL; recovery->max_id = -1; recovery->index_id_hash = mh_i64ptr_new(); - recovery->index_hash = mh_i64ptr_new(); + recovery->lsm_hash = mh_i64ptr_new(); recovery->range_hash = mh_i64ptr_new(); recovery->run_hash = mh_i64ptr_new(); recovery->slice_hash = mh_i64ptr_new(); if (recovery->index_id_hash == NULL || - recovery->index_hash == NULL || + recovery->lsm_hash == NULL || recovery->range_hash == NULL || recovery->run_hash == NULL || recovery->slice_hash == NULL) { @@ -1961,16 +1958,16 @@ vy_recovery_delete(struct vy_recovery *recovery) if (recovery->index_id_hash != NULL) { mh_int_t i; mh_foreach(recovery->index_id_hash, i) { - struct vy_index_recovery_info *index; - index = mh_i64ptr_node(recovery->index_id_hash, i)->val; - free(index->key_parts); - free(index); + struct vy_lsm_recovery_info *lsm; + lsm = mh_i64ptr_node(recovery->index_id_hash, i)->val; + free(lsm->key_parts); + free(lsm); } mh_i64ptr_delete(recovery->index_id_hash); } - if (recovery->index_hash != NULL) { + if (recovery->lsm_hash != NULL) { /* Hash entries were deleted along with index_id_hash. */ - mh_i64ptr_delete(recovery->index_hash); + mh_i64ptr_delete(recovery->lsm_hash); } if (recovery->range_hash != NULL) vy_recovery_delete_hash(recovery->range_hash); @@ -1996,9 +1993,9 @@ vy_log_append_record(struct xlog *xlog, struct vy_log_record *record) return 0; } -/** Write all records corresponding to an index to vylog. */ +/** Write all records corresponding to an LSM tree to vylog. */ static int -vy_log_append_index(struct xlog *xlog, struct vy_index_recovery_info *index) +vy_log_append_lsm(struct xlog *xlog, struct vy_lsm_recovery_info *lsm) { struct vy_range_recovery_info *range; struct vy_slice_recovery_info *slice; @@ -2006,25 +2003,25 @@ vy_log_append_index(struct xlog *xlog, struct vy_index_recovery_info *index) struct vy_log_record record; vy_log_record_init(&record); - record.type = VY_LOG_CREATE_INDEX; - record.index_id = index->id; - record.index_def_id = index->index_id; - record.space_def_id = index->space_id; - record.key_parts = index->key_parts; - record.key_part_count = index->key_part_count; + record.type = VY_LOG_CREATE_LSM; + record.lsm_id = lsm->id; + record.index_id = lsm->index_id; + record.space_id = lsm->space_id; + record.key_parts = lsm->key_parts; + record.key_part_count = lsm->key_part_count; if (vy_log_append_record(xlog, &record) != 0) return -1; - if (index->dump_lsn >= 0) { + if (lsm->dump_lsn >= 0) { vy_log_record_init(&record); - record.type = VY_LOG_DUMP_INDEX; - record.index_id = index->id; - record.dump_lsn = index->dump_lsn; + record.type = VY_LOG_DUMP_LSM; + record.lsm_id = lsm->id; + record.dump_lsn = lsm->dump_lsn; if (vy_log_append_record(xlog, &record) != 0) return -1; } - rlist_foreach_entry(run, &index->runs, in_index) { + rlist_foreach_entry(run, &lsm->runs, in_lsm) { vy_log_record_init(&record); if (run->is_incomplete) { record.type = VY_LOG_PREPARE_RUN; @@ -2032,7 +2029,7 @@ vy_log_append_index(struct xlog *xlog, struct vy_index_recovery_info *index) record.type = VY_LOG_CREATE_RUN; record.dump_lsn = run->dump_lsn; } - record.index_id = index->id; + record.lsm_id = lsm->id; record.run_id = run->id; if (vy_log_append_record(xlog, &record) != 0) return -1; @@ -2048,10 +2045,10 @@ vy_log_append_index(struct xlog *xlog, struct vy_index_recovery_info *index) return -1; } - rlist_foreach_entry(range, &index->ranges, in_index) { + rlist_foreach_entry(range, &lsm->ranges, in_lsm) { vy_log_record_init(&record); record.type = VY_LOG_INSERT_RANGE; - record.index_id = index->id; + record.lsm_id = lsm->id; record.range_id = range->id; record.begin = range->begin; record.end = range->end; @@ -2075,10 +2072,10 @@ vy_log_append_index(struct xlog *xlog, struct vy_index_recovery_info *index) } } - if (index->is_dropped) { + if (lsm->is_dropped) { vy_log_record_init(&record); - record.type = VY_LOG_DROP_INDEX; - record.index_id = index->id; + record.type = VY_LOG_DROP_LSM; + record.lsm_id = lsm->id; if (vy_log_append_record(xlog, &record) != 0) return -1; } @@ -2100,14 +2097,14 @@ vy_log_create(const struct vclock *vclock, struct vy_recovery *recovery) mh_int_t i; mh_foreach(recovery->index_id_hash, i) { - struct vy_index_recovery_info *index; - index = mh_i64ptr_node(recovery->index_id_hash, i)->val; + struct vy_lsm_recovery_info *lsm; + lsm = mh_i64ptr_node(recovery->index_id_hash, i)->val; /* - * Purge dropped indexes that are not referenced by runs + * Purge dropped LSM trees that are not referenced by runs * (and thus not needed for garbage collection) from the * log on rotation. */ - if (index->is_dropped && rlist_empty(&index->runs)) + if (lsm->is_dropped && rlist_empty(&lsm->runs)) continue; /* Create the log file on the first write. */ @@ -2115,7 +2112,7 @@ vy_log_create(const struct vclock *vclock, struct vy_recovery *recovery) xdir_create_xlog(&vy_log.dir, &xlog, vclock) != 0) goto err_create_xlog; - if (vy_log_append_index(&xlog, index) != 0) + if (vy_log_append_lsm(&xlog, lsm) != 0) goto err_write_xlog; } if (!xlog_is_open(&xlog)) diff --git a/src/box/vy_log.h b/src/box/vy_log.h index 8e1a2a1d..2dad4ee9 100644 --- a/src/box/vy_log.h +++ b/src/box/vy_log.h @@ -64,19 +64,19 @@ struct mh_i64ptr_t; /** Type of a metadata log record. */ enum vy_log_record_type { /** - * Create a new vinyl index. - * Requires vy_log_record::index_id, index_def_id, space_def_id, + * Create a new LSM tree. + * Requires vy_log_record::lsm_id, index_id, space_id, * key_def (with primary key parts), commit_lsn. */ - VY_LOG_CREATE_INDEX = 0, + VY_LOG_CREATE_LSM = 0, /** - * Drop an index. - * Requires vy_log_record::index_id. + * Drop an LSM tree. + * Requires vy_log_record::lsm_id. */ - VY_LOG_DROP_INDEX = 1, + VY_LOG_DROP_LSM = 1, /** - * Insert a new range into a vinyl index. - * Requires vy_log_record::index_id, range_id, begin, end. + * Insert a new range into an LSM tree. + * Requires vy_log_record::lsm_id, range_id, begin, end. */ VY_LOG_INSERT_RANGE = 2, /** @@ -86,7 +86,7 @@ enum vy_log_record_type { VY_LOG_DELETE_RANGE = 3, /** * Prepare a vinyl run file. - * Requires vy_log_record::index_id, run_id. + * Requires vy_log_record::lsm_id, run_id. * * Record of this type is written before creating a run file. * It is needed to keep track of unfinished due to errors run @@ -95,7 +95,7 @@ enum vy_log_record_type { VY_LOG_PREPARE_RUN = 4, /** * Commit a vinyl run file creation. - * Requires vy_log_record::index_id, run_id, dump_lsn. + * Requires vy_log_record::lsm_id, run_id, dump_lsn. * * Written after a run file was successfully created. */ @@ -135,10 +135,10 @@ enum vy_log_record_type { */ VY_LOG_DELETE_SLICE = 9, /** - * Update LSN of the last index dump. - * Requires vy_log_record::index_id, dump_lsn. + * Update LSN of the last LSM tree dump. + * Requires vy_log_record::lsm_id, dump_lsn. */ - VY_LOG_DUMP_INDEX = 10, + VY_LOG_DUMP_LSM = 10, /** * We don't split vylog into snapshot and log - all records * are written to the same file. Since we need to load a @@ -151,19 +151,19 @@ enum vy_log_record_type { */ VY_LOG_SNAPSHOT = 11, /** - * When we used LSN for identifying indexes in vylog, we - * couldn't simply recreate an index on space truncation, - * because in case the space had more than one index, we + * When we used LSN for identifying LSM trees in vylog, we + * couldn't simply recreate an LSM tree on space truncation, + * because in case the space had more than one LSM tree, we * wouldn't be able to distinguish them after truncation. * So we wrote special 'truncate' record. * - * Now, we assign a unique id to each index and so we don't + * Now, we assign a unique id to each LSM tree and so we don't * need a special record type for space truncation. If we * are recovering from an old vylog, we simply ignore all * 'truncate' records - this will result in replay of all * WAL records written after truncation. */ - VY_LOG_TRUNCATE_INDEX = 12, + VY_LOG_TRUNCATE_LSM = 12, vy_log_record_type_MAX }; @@ -172,8 +172,8 @@ enum vy_log_record_type { struct vy_log_record { /** Type of the record. */ enum vy_log_record_type type; - /** Unique ID of the vinyl index. */ - int64_t index_id; + /** Unique ID of the vinyl LSM tree. */ + int64_t lsm_id; /** Unique ID of the vinyl range. */ int64_t range_id; /** Unique ID of the vinyl run. */ @@ -191,9 +191,9 @@ struct vy_log_record { */ const char *end; /** Ordinal index number in the space. */ - uint32_t index_def_id; + uint32_t index_id; /** Space ID. */ - uint32_t space_def_id; + uint32_t space_id; /** Index key definition, as defined by the user. */ const struct key_def *key_def; /** Array of key part definitions. */ @@ -216,14 +216,14 @@ struct vy_log_record { /** Recovery context. */ struct vy_recovery { /** - * List of all indexes stored in the recovery context, - * linked by vy_index_recovery_info::in_recovery. + * List of all LSM trees stored in the recovery context, + * linked by vy_lsm_recovery_info::in_recovery. */ - struct rlist indexes; - /** space_id, index_id -> vy_index_recovery_info. */ + struct rlist lsms; + /** space_id, index_id -> vy_lsm_recovery_info. */ struct mh_i64ptr_t *index_id_hash; - /** ID -> vy_index_recovery_info. */ - struct mh_i64ptr_t *index_hash; + /** ID -> vy_lsm_recovery_info. */ + struct mh_i64ptr_t *lsm_hash; /** ID -> vy_range_recovery_info. */ struct mh_i64ptr_t *range_hash; /** ID -> vy_run_recovery_info. */ @@ -237,11 +237,11 @@ struct vy_recovery { int64_t max_id; }; -/** Vinyl index info stored in a recovery context. */ -struct vy_index_recovery_info { - /** Link in vy_recovery::indexes. */ +/** LSM tree info stored in a recovery context. */ +struct vy_lsm_recovery_info { + /** Link in vy_recovery::lsms. */ struct rlist in_recovery; - /** ID of the index. */ + /** ID of the LSM tree. */ int64_t id; /** Ordinal index number in the space. */ uint32_t index_id; @@ -251,29 +251,29 @@ struct vy_index_recovery_info { struct key_part_def *key_parts; /** Number of key parts. */ uint32_t key_part_count; - /** True if the index was dropped. */ + /** True if the LSM tree was dropped. */ bool is_dropped; - /** LSN of the WAL row that committed the index. */ + /** LSN of the WAL row that committed the LSM tree. */ int64_t commit_lsn; - /** LSN of the last index dump. */ + /** LSN of the last LSM tree dump. */ int64_t dump_lsn; /** - * List of all ranges in the index, linked by - * vy_range_recovery_info::in_index. + * List of all ranges in the LSM tree, linked by + * vy_range_recovery_info::in_lsm. */ struct rlist ranges; /** - * List of all runs created for the index + * List of all runs created for the LSM tree * (both committed and not), linked by - * vy_run_recovery_info::in_index. + * vy_run_recovery_info::in_lsm. */ struct rlist runs; }; /** Vinyl range info stored in a recovery context. */ struct vy_range_recovery_info { - /** Link in vy_index_recovery_info::ranges. */ - struct rlist in_index; + /** Link in vy_lsm_recovery_info::ranges. */ + struct rlist in_lsm; /** ID of the range. */ int64_t id; /** Start of the range, stored in MsgPack array. */ @@ -291,8 +291,8 @@ struct vy_range_recovery_info { /** Run info stored in a recovery context. */ struct vy_run_recovery_info { - /** Link in vy_index_recovery_info::runs. */ - struct rlist in_index; + /** Link in vy_lsm_recovery_info::runs. */ + struct rlist in_lsm; /** ID of the run. */ int64_t id; /** Max LSN stored on disk. */ @@ -356,10 +356,10 @@ vy_log_open(struct xlog *xlog); /** * Rotate the metadata log. This function creates a new * xlog file in the log directory having vclock @vclock - * and writes records required to recover active indexes. + * and writes records required to recover active LSM trees. * The goal of log rotation is to compact the log file by * discarding records cancelling each other and records left - * from dropped indexes. + * from dropped LSM trees. * * Returns 0 on success, -1 on failure. */ @@ -439,7 +439,7 @@ vy_log_bootstrap(void); * Prepare the metadata log for recovery from the file having * vclock @vclock and return the recovery context. * - * After this function is called, vinyl indexes may be recovered from + * After this function is called, LSM trees may be recovered from * the log using vy_recovery methods. When recovery is complete, * one must call vy_log_end_recovery(). After that the recovery context * may be deleted with vy_recovery_delete(). @@ -481,13 +481,13 @@ void vy_recovery_delete(struct vy_recovery *recovery); /** - * Look up the last incarnation of an index stored in a recovery context. + * Look up the last incarnation of an LSM tree stored in a recovery context. * - * Returns NULL if the index was not found. + * Returns NULL if the LSM tree was not found. */ -struct vy_index_recovery_info * -vy_recovery_index_by_id(struct vy_recovery *recovery, - uint32_t space_id, uint32_t index_id); +struct vy_lsm_recovery_info * +vy_recovery_lsm_by_index_id(struct vy_recovery *recovery, + uint32_t space_id, uint32_t index_id); /** * Initialize a log record with default values. @@ -500,42 +500,42 @@ vy_log_record_init(struct vy_log_record *record) memset(record, 0, sizeof(*record)); } -/** Helper to log a vinyl index creation. */ +/** Helper to log a vinyl LSM tree creation. */ static inline void -vy_log_create_index(int64_t id, uint32_t space_id, uint32_t index_id, - const struct key_def *key_def, int64_t commit_lsn) +vy_log_create_lsm(int64_t id, uint32_t space_id, uint32_t index_id, + const struct key_def *key_def, int64_t commit_lsn) { struct vy_log_record record; vy_log_record_init(&record); - record.type = VY_LOG_CREATE_INDEX; - record.index_id = id; - record.space_def_id = space_id; - record.index_def_id = index_id; + record.type = VY_LOG_CREATE_LSM; + record.lsm_id = id; + record.space_id = space_id; + record.index_id = index_id; record.key_def = key_def; record.commit_lsn = commit_lsn; vy_log_write(&record); } -/** Helper to log a vinyl index drop. */ +/** Helper to log a vinyl LSM tree drop. */ static inline void -vy_log_drop_index(int64_t id) +vy_log_drop_lsm(int64_t id) { struct vy_log_record record; vy_log_record_init(&record); - record.type = VY_LOG_DROP_INDEX; - record.index_id = id; + record.type = VY_LOG_DROP_LSM; + record.lsm_id = id; vy_log_write(&record); } /** Helper to log a vinyl range insertion. */ static inline void -vy_log_insert_range(int64_t index_id, int64_t range_id, +vy_log_insert_range(int64_t lsm_id, int64_t range_id, const char *begin, const char *end) { struct vy_log_record record; vy_log_record_init(&record); record.type = VY_LOG_INSERT_RANGE; - record.index_id = index_id; + record.lsm_id = lsm_id; record.range_id = range_id; record.begin = begin; record.end = end; @@ -555,24 +555,24 @@ vy_log_delete_range(int64_t range_id) /** Helper to log a vinyl run file creation. */ static inline void -vy_log_prepare_run(int64_t index_id, int64_t run_id) +vy_log_prepare_run(int64_t lsm_id, int64_t run_id) { struct vy_log_record record; vy_log_record_init(&record); record.type = VY_LOG_PREPARE_RUN; - record.index_id = index_id; + record.lsm_id = lsm_id; record.run_id = run_id; vy_log_write(&record); } /** Helper to log a vinyl run creation. */ static inline void -vy_log_create_run(int64_t index_id, int64_t run_id, int64_t dump_lsn) +vy_log_create_run(int64_t lsm_id, int64_t run_id, int64_t dump_lsn) { struct vy_log_record record; vy_log_record_init(&record); record.type = VY_LOG_CREATE_RUN; - record.index_id = index_id; + record.lsm_id = lsm_id; record.run_id = run_id; record.dump_lsn = dump_lsn; vy_log_write(&record); @@ -628,14 +628,14 @@ vy_log_delete_slice(int64_t slice_id) vy_log_write(&record); } -/** Helper to log index dump. */ +/** Helper to log LSM tree dump. */ static inline void -vy_log_dump_index(int64_t id, int64_t dump_lsn) +vy_log_dump_lsm(int64_t id, int64_t dump_lsn) { struct vy_log_record record; vy_log_record_init(&record); - record.type = VY_LOG_DUMP_INDEX; - record.index_id = id; + record.type = VY_LOG_DUMP_LSM; + record.lsm_id = id; record.dump_lsn = dump_lsn; vy_log_write(&record); } diff --git a/src/box/vy_index.c b/src/box/vy_lsm.c similarity index 56% rename from src/box/vy_index.c rename to src/box/vy_lsm.c index 09894982..88a75e32 100644 --- a/src/box/vy_index.c +++ b/src/box/vy_lsm.c @@ -28,7 +28,7 @@ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ -#include "vy_index.h" +#include "vy_lsm.h" #include "trivia/util.h" #include @@ -53,36 +53,36 @@ #include "vy_read_set.h" void -vy_index_validate_formats(const struct vy_index *index) +vy_lsm_validate_formats(const struct vy_lsm *lsm) { - (void) index; - assert(index->disk_format != NULL); - assert(index->mem_format != NULL); - assert(index->mem_format_with_colmask != NULL); - assert(index->upsert_format != NULL); - uint32_t index_field_count = index->mem_format->index_field_count; + (void) lsm; + assert(lsm->disk_format != NULL); + assert(lsm->mem_format != NULL); + assert(lsm->mem_format_with_colmask != NULL); + assert(lsm->upsert_format != NULL); + uint32_t index_field_count = lsm->mem_format->index_field_count; (void) index_field_count; - if (index->index_id == 0) { - assert(index->disk_format == index->mem_format); - assert(index->disk_format->index_field_count == + if (lsm->index_id == 0) { + assert(lsm->disk_format == lsm->mem_format); + assert(lsm->disk_format->index_field_count == index_field_count); - assert(index->mem_format_with_colmask->index_field_count == + assert(lsm->mem_format_with_colmask->index_field_count == index_field_count); } else { - assert(index->disk_format != index->mem_format); - assert(index->disk_format->index_field_count <= + assert(lsm->disk_format != lsm->mem_format); + assert(lsm->disk_format->index_field_count <= index_field_count); } - assert(index->upsert_format->index_field_count == index_field_count); - assert(index->mem_format_with_colmask->index_field_count == + assert(lsm->upsert_format->index_field_count == index_field_count); + assert(lsm->mem_format_with_colmask->index_field_count == index_field_count); } int -vy_index_env_create(struct vy_index_env *env, const char *path, - int64_t *p_generation, - vy_upsert_thresh_cb upsert_thresh_cb, - void *upsert_thresh_arg) +vy_lsm_env_create(struct vy_lsm_env *env, const char *path, + int64_t *p_generation, + vy_upsert_thresh_cb upsert_thresh_cb, + void *upsert_thresh_arg) { env->key_format = tuple_format_new(&vy_tuple_format_vtab, NULL, 0, 0, NULL, 0, NULL); @@ -99,40 +99,40 @@ vy_index_env_create(struct vy_index_env *env, const char *path, env->upsert_thresh_cb = upsert_thresh_cb; env->upsert_thresh_arg = upsert_thresh_arg; env->too_long_threshold = TIMEOUT_INFINITY; - env->index_count = 0; + env->lsm_count = 0; return 0; } void -vy_index_env_destroy(struct vy_index_env *env) +vy_lsm_env_destroy(struct vy_lsm_env *env) { tuple_unref(env->empty_key); tuple_format_unref(env->key_format); } const char * -vy_index_name(struct vy_index *index) +vy_lsm_name(struct vy_lsm *lsm) { char *buf = tt_static_buf(); snprintf(buf, TT_STATIC_BUF_LEN, "%u/%u", - (unsigned)index->space_id, (unsigned)index->index_id); + (unsigned)lsm->space_id, (unsigned)lsm->index_id); return buf; } size_t -vy_index_mem_tree_size(struct vy_index *index) +vy_lsm_mem_tree_size(struct vy_lsm *lsm) { struct vy_mem *mem; - size_t size = index->mem->tree_extent_size; - rlist_foreach_entry(mem, &index->sealed, in_sealed) + size_t size = lsm->mem->tree_extent_size; + rlist_foreach_entry(mem, &lsm->sealed, in_sealed) size += mem->tree_extent_size; return size; } -struct vy_index * -vy_index_new(struct vy_index_env *index_env, struct vy_cache_env *cache_env, +struct vy_lsm * +vy_lsm_new(struct vy_lsm_env *lsm_env, struct vy_cache_env *cache_env, struct vy_mem_env *mem_env, struct index_def *index_def, - struct tuple_format *format, struct vy_index *pk) + struct tuple_format *format, struct vy_lsm *pk) { static int64_t run_buckets[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20, 25, 50, 100, @@ -141,17 +141,17 @@ vy_index_new(struct vy_index_env *index_env, struct vy_cache_env *cache_env, assert(index_def->key_def->part_count > 0); assert(index_def->iid == 0 || pk != NULL); - struct vy_index *index = calloc(1, sizeof(struct vy_index)); - if (index == NULL) { - diag_set(OutOfMemory, sizeof(struct vy_index), - "calloc", "struct vy_index"); + struct vy_lsm *lsm = calloc(1, sizeof(struct vy_lsm)); + if (lsm == NULL) { + diag_set(OutOfMemory, sizeof(struct vy_lsm), + "calloc", "struct vy_lsm"); goto fail; } - index->env = index_env; + lsm->env = lsm_env; - index->tree = malloc(sizeof(*index->tree)); - if (index->tree == NULL) { - diag_set(OutOfMemory, sizeof(*index->tree), + lsm->tree = malloc(sizeof(*lsm->tree)); + if (lsm->tree == NULL) { + diag_set(OutOfMemory, sizeof(*lsm->tree), "malloc", "vy_range_tree_t"); goto fail_tree; } @@ -164,105 +164,105 @@ vy_index_new(struct vy_index_env *index_env, struct vy_cache_env *cache_env, if (cmp_def == NULL) goto fail_cmp_def; - index->cmp_def = cmp_def; - index->key_def = key_def; + lsm->cmp_def = cmp_def; + lsm->key_def = key_def; if (index_def->iid == 0) { /* * Disk tuples can be returned to an user from a * primary key. And they must have field * definitions as well as space->format tuples. */ - index->disk_format = format; + lsm->disk_format = format; tuple_format_ref(format); } else { - index->disk_format = tuple_format_new(&vy_tuple_format_vtab, - &cmp_def, 1, 0, NULL, 0, - NULL); - if (index->disk_format == NULL) + lsm->disk_format = tuple_format_new(&vy_tuple_format_vtab, + &cmp_def, 1, 0, NULL, 0, + NULL); + if (lsm->disk_format == NULL) goto fail_format; for (uint32_t i = 0; i < cmp_def->part_count; ++i) { uint32_t fieldno = cmp_def->parts[i].fieldno; - index->disk_format->fields[fieldno].is_nullable = + lsm->disk_format->fields[fieldno].is_nullable = format->fields[fieldno].is_nullable; } } - tuple_format_ref(index->disk_format); + tuple_format_ref(lsm->disk_format); if (index_def->iid == 0) { - index->upsert_format = + lsm->upsert_format = vy_tuple_format_new_upsert(format); - if (index->upsert_format == NULL) + if (lsm->upsert_format == NULL) goto fail_upsert_format; - tuple_format_ref(index->upsert_format); + tuple_format_ref(lsm->upsert_format); - index->mem_format_with_colmask = + lsm->mem_format_with_colmask = vy_tuple_format_new_with_colmask(format); - if (index->mem_format_with_colmask == NULL) + if (lsm->mem_format_with_colmask == NULL) goto fail_mem_format_with_colmask; - tuple_format_ref(index->mem_format_with_colmask); + tuple_format_ref(lsm->mem_format_with_colmask); } else { - index->mem_format_with_colmask = pk->mem_format_with_colmask; - index->upsert_format = pk->upsert_format; - tuple_format_ref(index->mem_format_with_colmask); - tuple_format_ref(index->upsert_format); + lsm->mem_format_with_colmask = pk->mem_format_with_colmask; + lsm->upsert_format = pk->upsert_format; + tuple_format_ref(lsm->mem_format_with_colmask); + tuple_format_ref(lsm->upsert_format); } - if (vy_index_stat_create(&index->stat) != 0) + if (vy_lsm_stat_create(&lsm->stat) != 0) goto fail_stat; - index->run_hist = histogram_new(run_buckets, lengthof(run_buckets)); - if (index->run_hist == NULL) + lsm->run_hist = histogram_new(run_buckets, lengthof(run_buckets)); + if (lsm->run_hist == NULL) goto fail_run_hist; - index->mem = vy_mem_new(mem_env, *index->env->p_generation, - cmp_def, format, index->mem_format_with_colmask, - index->upsert_format, schema_version); - if (index->mem == NULL) + lsm->mem = vy_mem_new(mem_env, *lsm->env->p_generation, + cmp_def, format, lsm->mem_format_with_colmask, + lsm->upsert_format, schema_version); + if (lsm->mem == NULL) goto fail_mem; - index->id = -1; - index->refs = 1; - index->dump_lsn = -1; - vy_cache_create(&index->cache, cache_env, cmp_def); - rlist_create(&index->sealed); - vy_range_tree_new(index->tree); - vy_range_heap_create(&index->range_heap); - rlist_create(&index->runs); - index->pk = pk; + lsm->id = -1; + lsm->refs = 1; + lsm->dump_lsn = -1; + vy_cache_create(&lsm->cache, cache_env, cmp_def); + rlist_create(&lsm->sealed); + vy_range_tree_new(lsm->tree); + vy_range_heap_create(&lsm->range_heap); + rlist_create(&lsm->runs); + lsm->pk = pk; if (pk != NULL) - vy_index_ref(pk); - index->mem_format = format; - tuple_format_ref(index->mem_format); - index->in_dump.pos = UINT32_MAX; - index->in_compact.pos = UINT32_MAX; - index->space_id = index_def->space_id; - index->index_id = index_def->iid; - index->opts = index_def->opts; - index->check_is_unique = index->opts.is_unique; - vy_index_read_set_new(&index->read_set); - - index_env->index_count++; - vy_index_validate_formats(index); - return index; + vy_lsm_ref(pk); + lsm->mem_format = format; + tuple_format_ref(lsm->mem_format); + lsm->in_dump.pos = UINT32_MAX; + lsm->in_compact.pos = UINT32_MAX; + lsm->space_id = index_def->space_id; + lsm->index_id = index_def->iid; + lsm->opts = index_def->opts; + lsm->check_is_unique = lsm->opts.is_unique; + vy_lsm_read_set_new(&lsm->read_set); + + lsm_env->lsm_count++; + vy_lsm_validate_formats(lsm); + return lsm; fail_mem: - histogram_delete(index->run_hist); + histogram_delete(lsm->run_hist); fail_run_hist: - vy_index_stat_destroy(&index->stat); + vy_lsm_stat_destroy(&lsm->stat); fail_stat: - tuple_format_unref(index->mem_format_with_colmask); + tuple_format_unref(lsm->mem_format_with_colmask); fail_mem_format_with_colmask: - tuple_format_unref(index->upsert_format); + tuple_format_unref(lsm->upsert_format); fail_upsert_format: - tuple_format_unref(index->disk_format); + tuple_format_unref(lsm->disk_format); fail_format: key_def_delete(cmp_def); fail_cmp_def: key_def_delete(key_def); fail_key_def: - free(index->tree); + free(lsm->tree); fail_tree: - free(index); + free(lsm); fail: return NULL; } @@ -280,67 +280,67 @@ vy_range_tree_free_cb(vy_range_tree_t *t, struct vy_range *range, void *arg) } void -vy_index_delete(struct vy_index *index) +vy_lsm_delete(struct vy_lsm *lsm) { - assert(index->refs == 0); - assert(index->in_dump.pos == UINT32_MAX); - assert(index->in_compact.pos == UINT32_MAX); - assert(vy_index_read_set_empty(&index->read_set)); - assert(index->env->index_count > 0); + assert(lsm->refs == 0); + assert(lsm->in_dump.pos == UINT32_MAX); + assert(lsm->in_compact.pos == UINT32_MAX); + assert(vy_lsm_read_set_empty(&lsm->read_set)); + assert(lsm->env->lsm_count > 0); - index->env->index_count--; + lsm->env->lsm_count--; - if (index->pk != NULL) - vy_index_unref(index->pk); + if (lsm->pk != NULL) + vy_lsm_unref(lsm->pk); struct vy_mem *mem, *next_mem; - rlist_foreach_entry_safe(mem, &index->sealed, in_sealed, next_mem) + rlist_foreach_entry_safe(mem, &lsm->sealed, in_sealed, next_mem) vy_mem_delete(mem); - vy_mem_delete(index->mem); + vy_mem_delete(lsm->mem); struct vy_run *run, *next_run; - rlist_foreach_entry_safe(run, &index->runs, in_index, next_run) - vy_index_remove_run(index, run); - - vy_range_tree_iter(index->tree, NULL, vy_range_tree_free_cb, NULL); - vy_range_heap_destroy(&index->range_heap); - tuple_format_unref(index->disk_format); - tuple_format_unref(index->mem_format_with_colmask); - tuple_format_unref(index->upsert_format); - key_def_delete(index->cmp_def); - key_def_delete(index->key_def); - histogram_delete(index->run_hist); - vy_index_stat_destroy(&index->stat); - vy_cache_destroy(&index->cache); - tuple_format_unref(index->mem_format); - free(index->tree); - TRASH(index); - free(index); + rlist_foreach_entry_safe(run, &lsm->runs, in_lsm, next_run) + vy_lsm_remove_run(lsm, run); + + vy_range_tree_iter(lsm->tree, NULL, vy_range_tree_free_cb, NULL); + vy_range_heap_destroy(&lsm->range_heap); + tuple_format_unref(lsm->disk_format); + tuple_format_unref(lsm->mem_format_with_colmask); + tuple_format_unref(lsm->upsert_format); + key_def_delete(lsm->cmp_def); + key_def_delete(lsm->key_def); + histogram_delete(lsm->run_hist); + vy_lsm_stat_destroy(&lsm->stat); + vy_cache_destroy(&lsm->cache); + tuple_format_unref(lsm->mem_format); + free(lsm->tree); + TRASH(lsm); + free(lsm); } -/** Initialize the range tree of a new index. */ +/** Initialize the range tree of a new LSM tree. */ static int -vy_index_init_range_tree(struct vy_index *index) +vy_lsm_init_range_tree(struct vy_lsm *lsm) { struct vy_range *range = vy_range_new(vy_log_next_id(), NULL, NULL, - index->cmp_def); + lsm->cmp_def); if (range == NULL) return -1; - assert(index->range_count == 0); - vy_index_add_range(index, range); - vy_index_acct_range(index, range); + assert(lsm->range_count == 0); + vy_lsm_add_range(lsm, range); + vy_lsm_acct_range(lsm, range); return 0; } int -vy_index_create(struct vy_index *index) +vy_lsm_create(struct vy_lsm *lsm) { - /* Make index directory. */ + /* Make LSM tree directory. */ int rc; char path[PATH_MAX]; - vy_index_snprint_path(path, sizeof(path), index->env->path, - index->space_id, index->index_id); + vy_lsm_snprint_path(path, sizeof(path), lsm->env->path, + lsm->space_id, lsm->index_id); char *path_sep = path; while (*path_sep == '/') { /* Don't create root */ @@ -367,17 +367,16 @@ vy_index_create(struct vy_index *index) } /* Assign unique id. */ - assert(index->id < 0); - index->id = vy_log_next_id(); + assert(lsm->id < 0); + lsm->id = vy_log_next_id(); /* Allocate initial range. */ - return vy_index_init_range_tree(index); + return vy_lsm_init_range_tree(lsm); } static struct vy_run * -vy_index_recover_run(struct vy_index *index, - struct vy_run_recovery_info *run_info, - struct vy_run_env *run_env, bool force_recovery) +vy_lsm_recover_run(struct vy_lsm *lsm, struct vy_run_recovery_info *run_info, + struct vy_run_env *run_env, bool force_recovery) { assert(!run_info->is_dropped); assert(!run_info->is_incomplete); @@ -392,18 +391,18 @@ vy_index_recover_run(struct vy_index *index, return NULL; run->dump_lsn = run_info->dump_lsn; - if (vy_run_recover(run, index->env->path, - index->space_id, index->index_id) != 0 && + if (vy_run_recover(run, lsm->env->path, + lsm->space_id, lsm->index_id) != 0 && (!force_recovery || - vy_run_rebuild_index(run, index->env->path, - index->space_id, index->index_id, - index->cmp_def, index->key_def, - index->mem_format, index->upsert_format, - &index->opts) != 0)) { + vy_run_rebuild_index(run, lsm->env->path, + lsm->space_id, lsm->index_id, + lsm->cmp_def, lsm->key_def, + lsm->mem_format, lsm->upsert_format, + &lsm->opts) != 0)) { vy_run_unref(run); return NULL; } - vy_index_add_run(index, run); + vy_lsm_add_run(lsm, run); /* * The same run can be referenced by more than one slice @@ -411,48 +410,48 @@ vy_index_recover_run(struct vy_index *index, * the same run multiple times. * * Runs are stored with their reference counters elevated. - * We drop the extra references as soon as index recovery - * is complete (see vy_index_recover()). + * We drop the extra references as soon as LSM tree recovery + * is complete (see vy_lsm_recover()). */ run_info->data = run; return run; } static struct vy_slice * -vy_index_recover_slice(struct vy_index *index, struct vy_range *range, - struct vy_slice_recovery_info *slice_info, - struct vy_run_env *run_env, bool force_recovery) +vy_lsm_recover_slice(struct vy_lsm *lsm, struct vy_range *range, + struct vy_slice_recovery_info *slice_info, + struct vy_run_env *run_env, bool force_recovery) { struct tuple *begin = NULL, *end = NULL; struct vy_slice *slice = NULL; struct vy_run *run; if (slice_info->begin != NULL) { - begin = vy_key_from_msgpack(index->env->key_format, + begin = vy_key_from_msgpack(lsm->env->key_format, slice_info->begin); if (begin == NULL) goto out; } if (slice_info->end != NULL) { - end = vy_key_from_msgpack(index->env->key_format, + end = vy_key_from_msgpack(lsm->env->key_format, slice_info->end); if (end == NULL) goto out; } if (begin != NULL && end != NULL && - vy_key_compare(begin, end, index->cmp_def) >= 0) { + vy_key_compare(begin, end, lsm->cmp_def) >= 0) { diag_set(ClientError, ER_INVALID_VYLOG_FILE, tt_sprintf("begin >= end for slice %lld", (long long)slice_info->id)); goto out; } - run = vy_index_recover_run(index, slice_info->run, - run_env, force_recovery); + run = vy_lsm_recover_run(lsm, slice_info->run, + run_env, force_recovery); if (run == NULL) goto out; - slice = vy_slice_new(slice_info->id, run, begin, end, index->cmp_def); + slice = vy_slice_new(slice_info->id, run, begin, end, lsm->cmp_def); if (slice == NULL) goto out; @@ -466,34 +465,34 @@ out: } static struct vy_range * -vy_index_recover_range(struct vy_index *index, - struct vy_range_recovery_info *range_info, - struct vy_run_env *run_env, bool force_recovery) +vy_lsm_recover_range(struct vy_lsm *lsm, + struct vy_range_recovery_info *range_info, + struct vy_run_env *run_env, bool force_recovery) { struct tuple *begin = NULL, *end = NULL; struct vy_range *range = NULL; if (range_info->begin != NULL) { - begin = vy_key_from_msgpack(index->env->key_format, + begin = vy_key_from_msgpack(lsm->env->key_format, range_info->begin); if (begin == NULL) goto out; } if (range_info->end != NULL) { - end = vy_key_from_msgpack(index->env->key_format, + end = vy_key_from_msgpack(lsm->env->key_format, range_info->end); if (end == NULL) goto out; } if (begin != NULL && end != NULL && - vy_key_compare(begin, end, index->cmp_def) >= 0) { + vy_key_compare(begin, end, lsm->cmp_def) >= 0) { diag_set(ClientError, ER_INVALID_VYLOG_FILE, tt_sprintf("begin >= end for range %lld", (long long)range_info->id)); goto out; } - range = vy_range_new(range_info->id, begin, end, index->cmp_def); + range = vy_range_new(range_info->id, begin, end, lsm->cmp_def); if (range == NULL) goto out; @@ -504,14 +503,14 @@ vy_index_recover_range(struct vy_index *index, */ struct vy_slice_recovery_info *slice_info; rlist_foreach_entry_reverse(slice_info, &range_info->slices, in_range) { - if (vy_index_recover_slice(index, range, slice_info, - run_env, force_recovery) == NULL) { + if (vy_lsm_recover_slice(lsm, range, slice_info, + run_env, force_recovery) == NULL) { vy_range_delete(range); range = NULL; goto out; } } - vy_index_add_range(index, range); + vy_lsm_add_range(lsm, range); out: if (begin != NULL) tuple_unref(begin); @@ -521,13 +520,13 @@ out: } int -vy_index_recover(struct vy_index *index, struct vy_recovery *recovery, +vy_lsm_recover(struct vy_lsm *lsm, struct vy_recovery *recovery, struct vy_run_env *run_env, int64_t lsn, bool is_checkpoint_recovery, bool force_recovery) { - assert(index->id < 0); - assert(!index->is_committed); - assert(index->range_count == 0); + assert(lsm->id < 0); + assert(!lsm->is_committed); + assert(lsm->range_count == 0); /* * Backward compatibility fixup: historically, we used @@ -536,89 +535,90 @@ vy_index_recover(struct vy_index *index, struct vy_recovery *recovery, * index by 1. So for legacy indexes use the LSN from * index options. */ - if (index->opts.lsn != 0) - lsn = index->opts.lsn; + if (lsm->opts.lsn != 0) + lsn = lsm->opts.lsn; /* - * Look up the last incarnation of the index in vylog. + * Look up the last incarnation of the LSM tree in vylog. */ - struct vy_index_recovery_info *index_info; - index_info = vy_recovery_index_by_id(recovery, - index->space_id, index->index_id); + struct vy_lsm_recovery_info *lsm_info; + lsm_info = vy_recovery_lsm_by_index_id(recovery, + lsm->space_id, lsm->index_id); if (is_checkpoint_recovery) { - if (index_info == NULL) { + if (lsm_info == NULL) { /* - * All indexes created from snapshot rows must + * All LSM trees created from snapshot rows must * be present in vylog, because snapshot can * only succeed if vylog has been successfully * flushed. */ diag_set(ClientError, ER_INVALID_VYLOG_FILE, - tt_sprintf("Index %u/%u not found", - (unsigned)index->space_id, - (unsigned)index->index_id)); + tt_sprintf("LSM tree %u/%u not found", + (unsigned)lsm->space_id, + (unsigned)lsm->index_id)); return -1; } - if (lsn > index_info->commit_lsn) { + if (lsn > lsm_info->commit_lsn) { /* - * The last incarnation of the index was created - * before the last checkpoint, load it now. + * The last incarnation of the LSM tree was + * created before the last checkpoint, load + * it now. */ - lsn = index_info->commit_lsn; + lsn = lsm_info->commit_lsn; } } - if (index_info == NULL || lsn > index_info->commit_lsn) { + if (lsm_info == NULL || lsn > lsm_info->commit_lsn) { /* - * If we failed to log index creation before restart, - * we won't find it in the log on recovery. This is - * OK as the index doesn't have any runs in this case. - * We will retry to log index in vy_index_commit_create(). + * If we failed to log LSM tree creation before restart, + * we won't find it in the log on recovery. This is OK as + * the LSM tree doesn't have any runs in this case. We will + * retry to log LSM tree in vinyl_index_commit_create(). * For now, just create the initial range and assign id. */ - index->id = vy_log_next_id(); - return vy_index_init_range_tree(index); + lsm->id = vy_log_next_id(); + return vy_lsm_init_range_tree(lsm); } - index->id = index_info->id; - index->is_committed = true; + lsm->id = lsm_info->id; + lsm->is_committed = true; - if (lsn < index_info->commit_lsn || index_info->is_dropped) { + if (lsn < lsm_info->commit_lsn || lsm_info->is_dropped) { /* - * Loading a past incarnation of the index, i.e. - * the index is going to dropped during final + * Loading a past incarnation of the LSM tree, i.e. + * the LSM tree is going to dropped during final * recovery. Mark it as such. */ - index->is_dropped = true; + lsm->is_dropped = true; /* - * We need range tree initialized for all indexes, + * We need range tree initialized for all LSM trees, * even for dropped ones. */ - return vy_index_init_range_tree(index); + return vy_lsm_init_range_tree(lsm); } /* - * Loading the last incarnation of the index from vylog. + * Loading the last incarnation of the LSM tree from vylog. */ - index->dump_lsn = index_info->dump_lsn; + lsm->dump_lsn = lsm_info->dump_lsn; int rc = 0; struct vy_range_recovery_info *range_info; - rlist_foreach_entry(range_info, &index_info->ranges, in_index) { - if (vy_index_recover_range(index, range_info, - run_env, force_recovery) == NULL) { + rlist_foreach_entry(range_info, &lsm_info->ranges, in_lsm) { + if (vy_lsm_recover_range(lsm, range_info, run_env, + force_recovery) == NULL) { rc = -1; break; } } /* - * vy_index_recover_run() elevates reference counter + * vy_lsm_recover_run() elevates reference counter * of each recovered run. We need to drop the extra * references once we are done. */ struct vy_run *run; - rlist_foreach_entry(run, &index->runs, in_index) { + rlist_foreach_entry(run, &lsm->runs, in_lsm) { assert(run->refs > 1); vy_run_unref(run); } @@ -627,12 +627,12 @@ vy_index_recover(struct vy_index *index, struct vy_recovery *recovery, return -1; /* - * Account ranges to the index and check that the range tree + * Account ranges to the LSM tree and check that the range tree * does not have holes or overlaps. */ struct vy_range *range, *prev = NULL; - for (range = vy_range_tree_first(index->tree); range != NULL; - prev = range, range = vy_range_tree_next(index->tree, range)) { + for (range = vy_range_tree_first(lsm->tree); range != NULL; + prev = range, range = vy_range_tree_next(lsm->tree, range)) { if (prev == NULL && range->begin != NULL) { diag_set(ClientError, ER_INVALID_VYLOG_FILE, tt_sprintf("Range %lld is leftmost but " @@ -644,7 +644,7 @@ vy_index_recover(struct vy_index *index, struct vy_recovery *recovery, if (prev != NULL && (prev->end == NULL || range->begin == NULL || (cmp = vy_key_compare(prev->end, range->begin, - index->cmp_def)) != 0)) { + lsm->cmp_def)) != 0)) { const char *errmsg = cmp > 0 ? "Nearby ranges %lld and %lld overlap" : "Keys between ranges %lld and %lld not spanned"; @@ -654,12 +654,12 @@ vy_index_recover(struct vy_index *index, struct vy_recovery *recovery, (long long)range->id)); return -1; } - vy_index_acct_range(index, range); + vy_lsm_acct_range(lsm, range); } if (prev == NULL) { diag_set(ClientError, ER_INVALID_VYLOG_FILE, - tt_sprintf("Index %lld has empty range tree", - (long long)index->id)); + tt_sprintf("LSM tree %lld has empty range tree", + (long long)lsm->id)); return -1; } if (prev->end != NULL) { @@ -673,17 +673,17 @@ vy_index_recover(struct vy_index *index, struct vy_recovery *recovery, } int64_t -vy_index_generation(struct vy_index *index) +vy_lsm_generation(struct vy_lsm *lsm) { - struct vy_mem *oldest = rlist_empty(&index->sealed) ? index->mem : - rlist_last_entry(&index->sealed, struct vy_mem, in_sealed); + struct vy_mem *oldest = rlist_empty(&lsm->sealed) ? lsm->mem : + rlist_last_entry(&lsm->sealed, struct vy_mem, in_sealed); return oldest->generation; } int -vy_index_compact_priority(struct vy_index *index) +vy_lsm_compact_priority(struct vy_lsm *lsm) { - struct heap_node *n = vy_range_heap_top(&index->range_heap); + struct heap_node *n = vy_range_heap_top(&lsm->range_heap); if (n == NULL) return 0; struct vy_range *range = container_of(n, struct vy_range, heap_node); @@ -691,98 +691,98 @@ vy_index_compact_priority(struct vy_index *index) } void -vy_index_add_run(struct vy_index *index, struct vy_run *run) +vy_lsm_add_run(struct vy_lsm *lsm, struct vy_run *run) { - assert(rlist_empty(&run->in_index)); - rlist_add_entry(&index->runs, run, in_index); - index->run_count++; - vy_disk_stmt_counter_add(&index->stat.disk.count, &run->count); + assert(rlist_empty(&run->in_lsm)); + rlist_add_entry(&lsm->runs, run, in_lsm); + lsm->run_count++; + vy_disk_stmt_counter_add(&lsm->stat.disk.count, &run->count); - index->bloom_size += vy_run_bloom_size(run); - index->page_index_size += run->page_index_size; + lsm->bloom_size += vy_run_bloom_size(run); + lsm->page_index_size += run->page_index_size; - index->env->bloom_size += vy_run_bloom_size(run); - index->env->page_index_size += run->page_index_size; + lsm->env->bloom_size += vy_run_bloom_size(run); + lsm->env->page_index_size += run->page_index_size; } void -vy_index_remove_run(struct vy_index *index, struct vy_run *run) +vy_lsm_remove_run(struct vy_lsm *lsm, struct vy_run *run) { - assert(index->run_count > 0); - assert(!rlist_empty(&run->in_index)); - rlist_del_entry(run, in_index); - index->run_count--; - vy_disk_stmt_counter_sub(&index->stat.disk.count, &run->count); + assert(lsm->run_count > 0); + assert(!rlist_empty(&run->in_lsm)); + rlist_del_entry(run, in_lsm); + lsm->run_count--; + vy_disk_stmt_counter_sub(&lsm->stat.disk.count, &run->count); - index->bloom_size -= vy_run_bloom_size(run); - index->page_index_size -= run->page_index_size; + lsm->bloom_size -= vy_run_bloom_size(run); + lsm->page_index_size -= run->page_index_size; - index->env->bloom_size -= vy_run_bloom_size(run); - index->env->page_index_size -= run->page_index_size; + lsm->env->bloom_size -= vy_run_bloom_size(run); + lsm->env->page_index_size -= run->page_index_size; } void -vy_index_add_range(struct vy_index *index, struct vy_range *range) +vy_lsm_add_range(struct vy_lsm *lsm, struct vy_range *range) { assert(range->heap_node.pos == UINT32_MAX); - vy_range_heap_insert(&index->range_heap, &range->heap_node); - vy_range_tree_insert(index->tree, range); - index->range_count++; + vy_range_heap_insert(&lsm->range_heap, &range->heap_node); + vy_range_tree_insert(lsm->tree, range); + lsm->range_count++; } void -vy_index_remove_range(struct vy_index *index, struct vy_range *range) +vy_lsm_remove_range(struct vy_lsm *lsm, struct vy_range *range) { assert(range->heap_node.pos != UINT32_MAX); - vy_range_heap_delete(&index->range_heap, &range->heap_node); - vy_range_tree_remove(index->tree, range); - index->range_count--; + vy_range_heap_delete(&lsm->range_heap, &range->heap_node); + vy_range_tree_remove(lsm->tree, range); + lsm->range_count--; } void -vy_index_acct_range(struct vy_index *index, struct vy_range *range) +vy_lsm_acct_range(struct vy_lsm *lsm, struct vy_range *range) { - histogram_collect(index->run_hist, range->slice_count); + histogram_collect(lsm->run_hist, range->slice_count); } void -vy_index_unacct_range(struct vy_index *index, struct vy_range *range) +vy_lsm_unacct_range(struct vy_lsm *lsm, struct vy_range *range) { - histogram_discard(index->run_hist, range->slice_count); + histogram_discard(lsm->run_hist, range->slice_count); } int -vy_index_rotate_mem(struct vy_index *index) +vy_lsm_rotate_mem(struct vy_lsm *lsm) { struct vy_mem *mem; - assert(index->mem != NULL); - mem = vy_mem_new(index->mem->env, *index->env->p_generation, - index->cmp_def, index->mem_format, - index->mem_format_with_colmask, - index->upsert_format, schema_version); + assert(lsm->mem != NULL); + mem = vy_mem_new(lsm->mem->env, *lsm->env->p_generation, + lsm->cmp_def, lsm->mem_format, + lsm->mem_format_with_colmask, + lsm->upsert_format, schema_version); if (mem == NULL) return -1; - rlist_add_entry(&index->sealed, index->mem, in_sealed); - index->mem = mem; - index->mem_list_version++; + rlist_add_entry(&lsm->sealed, lsm->mem, in_sealed); + lsm->mem = mem; + lsm->mem_list_version++; return 0; } void -vy_index_delete_mem(struct vy_index *index, struct vy_mem *mem) +vy_lsm_delete_mem(struct vy_lsm *lsm, struct vy_mem *mem) { assert(!rlist_empty(&mem->in_sealed)); rlist_del_entry(mem, in_sealed); - vy_stmt_counter_sub(&index->stat.memory.count, &mem->count); + vy_stmt_counter_sub(&lsm->stat.memory.count, &mem->count); vy_mem_delete(mem); - index->mem_list_version++; + lsm->mem_list_version++; } int -vy_index_set(struct vy_index *index, struct vy_mem *mem, - const struct tuple *stmt, const struct tuple **region_stmt) +vy_lsm_set(struct vy_lsm *lsm, struct vy_mem *mem, + const struct tuple *stmt, const struct tuple **region_stmt) { assert(vy_stmt_is_refable(stmt)); assert(*region_stmt == NULL || !vy_stmt_is_refable(*region_stmt)); @@ -796,7 +796,7 @@ vy_index_set(struct vy_index *index, struct vy_mem *mem, } /* We can't free region_stmt below, so let's add it to the stats */ - index->stat.memory.count.bytes += tuple_size(stmt); + lsm->stat.memory.count.bytes += tuple_size(stmt); uint32_t format_id = stmt->format_id; if (vy_stmt_type(*region_stmt) != IPROTO_UPSERT) { @@ -820,15 +820,15 @@ vy_index_set(struct vy_index *index, struct vy_mem *mem, /** * Calculate and record the number of sequential upserts, squash * immediately or schedule upsert process if needed. - * Additional handler used in vy_index_commit_stmt() for UPSERT + * Additional handler used in vy_lsm_commit_stmt() for UPSERT * statements. * - * @param index Index the statement was committed to. + * @param lsm LSM tree the statement was committed to. * @param mem In-memory tree where the statement was saved. * @param stmt UPSERT statement to squash. */ static void -vy_index_commit_upsert(struct vy_index *index, struct vy_mem *mem, +vy_lsm_commit_upsert(struct vy_lsm *lsm, struct vy_mem *mem, const struct tuple *stmt) { assert(vy_stmt_type(stmt) == IPROTO_UPSERT); @@ -837,7 +837,7 @@ vy_index_commit_upsert(struct vy_index *index, struct vy_mem *mem, * UPSERT is enabled only for the spaces with the single * index. */ - assert(index->index_id == 0); + assert(lsm->index_id == 0); const struct tuple *older; int64_t lsn = vy_stmt_lsn(stmt); @@ -870,15 +870,15 @@ vy_index_commit_upsert(struct vy_index *index, struct vy_mem *mem, assert(older != NULL && vy_stmt_type(older) == IPROTO_UPSERT && vy_stmt_n_upserts(older) == VY_UPSERT_THRESHOLD - 1); #endif - if (index->env->upsert_thresh_cb == NULL) { + if (lsm->env->upsert_thresh_cb == NULL) { /* Squash callback is not installed. */ return; } - struct tuple *dup = vy_stmt_dup(stmt, index->upsert_format); + struct tuple *dup = vy_stmt_dup(stmt, lsm->upsert_format); if (dup != NULL) { - index->env->upsert_thresh_cb(index, dup, - index->env->upsert_thresh_arg); + lsm->env->upsert_thresh_cb(lsm, dup, + lsm->env->upsert_thresh_arg); tuple_unref(dup); } /* @@ -893,15 +893,15 @@ vy_index_commit_upsert(struct vy_index *index, struct vy_mem *mem, * then we can turn the UPSERT into the REPLACE. */ if (n_upserts == 0 && - index->stat.memory.count.rows == index->mem->count.rows && - index->run_count == 0) { + lsm->stat.memory.count.rows == lsm->mem->count.rows && + lsm->run_count == 0) { older = vy_mem_older_lsn(mem, stmt); assert(older == NULL || vy_stmt_type(older) != IPROTO_UPSERT); struct tuple *upserted = - vy_apply_upsert(stmt, older, index->cmp_def, - index->mem_format, - index->upsert_format, false); - index->stat.upsert.applied++; + vy_apply_upsert(stmt, older, lsm->cmp_def, + lsm->mem_format, + lsm->upsert_format, false); + lsm->stat.upsert.applied++; if (upserted == NULL) { /* OOM */ @@ -934,53 +934,53 @@ vy_index_commit_upsert(struct vy_index *index, struct vy_mem *mem, return; } - int rc = vy_index_set(index, mem, upserted, ®ion_stmt); + int rc = vy_lsm_set(lsm, mem, upserted, ®ion_stmt); /** * Since we have already allocated mem statement and * now we replacing one statement with another, the - * vy_index_set() cannot fail. + * vy_lsm_set() cannot fail. */ assert(rc == 0); (void)rc; tuple_unref(upserted); vy_mem_commit_stmt(mem, region_stmt); - index->stat.upsert.squashed++; + lsm->stat.upsert.squashed++; } } void -vy_index_commit_stmt(struct vy_index *index, struct vy_mem *mem, +vy_lsm_commit_stmt(struct vy_lsm *lsm, struct vy_mem *mem, const struct tuple *stmt) { vy_mem_commit_stmt(mem, stmt); - index->stat.memory.count.rows++; + lsm->stat.memory.count.rows++; if (vy_stmt_type(stmt) == IPROTO_UPSERT) - vy_index_commit_upsert(index, mem, stmt); + vy_lsm_commit_upsert(lsm, mem, stmt); - vy_stmt_counter_acct_tuple(&index->stat.put, stmt); + vy_stmt_counter_acct_tuple(&lsm->stat.put, stmt); /* Invalidate cache element. */ - vy_cache_on_write(&index->cache, stmt, NULL); + vy_cache_on_write(&lsm->cache, stmt, NULL); } void -vy_index_rollback_stmt(struct vy_index *index, struct vy_mem *mem, +vy_lsm_rollback_stmt(struct vy_lsm *lsm, struct vy_mem *mem, const struct tuple *stmt) { vy_mem_rollback_stmt(mem, stmt); /* Invalidate cache element. */ - vy_cache_on_write(&index->cache, stmt, NULL); + vy_cache_on_write(&lsm->cache, stmt, NULL); } bool -vy_index_split_range(struct vy_index *index, struct vy_range *range) +vy_lsm_split_range(struct vy_lsm *lsm, struct vy_range *range) { - struct tuple_format *key_format = index->env->key_format; + struct tuple_format *key_format = lsm->env->key_format; const char *split_key_raw; - if (!vy_range_needs_split(range, &index->opts, &split_key_raw)) + if (!vy_range_needs_split(range, &lsm->opts, &split_key_raw)) return false; /* Split a range in two parts. */ @@ -1007,7 +1007,7 @@ vy_index_split_range(struct vy_index *index, struct vy_range *range) struct vy_range *part, *parts[2] = {NULL, }; for (int i = 0; i < n_parts; i++) { part = vy_range_new(vy_log_next_id(), keys[i], keys[i + 1], - index->cmp_def); + lsm->cmp_def); if (part == NULL) goto fail; parts[i] = part; @@ -1018,7 +1018,7 @@ vy_index_split_range(struct vy_index *index, struct vy_range *range) */ rlist_foreach_entry_reverse(slice, &range->slices, in_range) { if (vy_slice_cut(slice, vy_log_next_id(), part->begin, - part->end, index->cmp_def, + part->end, lsm->cmp_def, &new_slice) != 0) goto fail; if (new_slice != NULL) @@ -1036,7 +1036,7 @@ vy_index_split_range(struct vy_index *index, struct vy_range *range) vy_log_delete_range(range->id); for (int i = 0; i < n_parts; i++) { part = parts[i]; - vy_log_insert_range(index->id, part->id, + vy_log_insert_range(lsm->id, part->id, tuple_data_or_null(part->begin), tuple_data_or_null(part->end)); rlist_foreach_entry(slice, &part->slices, in_range) @@ -1048,19 +1048,19 @@ vy_index_split_range(struct vy_index *index, struct vy_range *range) goto fail; /* - * Replace the old range in the index. + * Replace the old range in the LSM tree. */ - vy_index_unacct_range(index, range); - vy_index_remove_range(index, range); + vy_lsm_unacct_range(lsm, range); + vy_lsm_remove_range(lsm, range); for (int i = 0; i < n_parts; i++) { part = parts[i]; - vy_index_add_range(index, part); - vy_index_acct_range(index, part); + vy_lsm_add_range(lsm, part); + vy_lsm_acct_range(lsm, part); } - index->range_tree_version++; + lsm->range_tree_version++; - say_info("%s: split range %s by key %s", vy_index_name(index), + say_info("%s: split range %s by key %s", vy_lsm_name(lsm), vy_range_str(range), tuple_str(split_key)); rlist_foreach_entry(slice, &range->slices, in_range) @@ -1078,34 +1078,34 @@ fail: diag_log(); say_error("%s: failed to split range %s", - vy_index_name(index), vy_range_str(range)); + vy_lsm_name(lsm), vy_range_str(range)); return false; } bool -vy_index_coalesce_range(struct vy_index *index, struct vy_range *range) +vy_lsm_coalesce_range(struct vy_lsm *lsm, struct vy_range *range) { struct vy_range *first, *last; - if (!vy_range_needs_coalesce(range, index->tree, &index->opts, + if (!vy_range_needs_coalesce(range, lsm->tree, &lsm->opts, &first, &last)) return false; struct vy_range *result = vy_range_new(vy_log_next_id(), - first->begin, last->end, index->cmp_def); + first->begin, last->end, lsm->cmp_def); if (result == NULL) goto fail_range; struct vy_range *it; - struct vy_range *end = vy_range_tree_next(index->tree, last); + struct vy_range *end = vy_range_tree_next(lsm->tree, last); /* * Log change in metadata. */ vy_log_tx_begin(); - vy_log_insert_range(index->id, result->id, + vy_log_insert_range(lsm->id, result->id, tuple_data_or_null(result->begin), tuple_data_or_null(result->end)); - for (it = first; it != end; it = vy_range_tree_next(index->tree, it)) { + for (it = first; it != end; it = vy_range_tree_next(lsm->tree, it)) { struct vy_slice *slice; rlist_foreach_entry(slice, &it->slices, in_range) vy_log_delete_slice(slice->id); @@ -1125,9 +1125,9 @@ vy_index_coalesce_range(struct vy_index *index, struct vy_range *range) */ it = first; while (it != end) { - struct vy_range *next = vy_range_tree_next(index->tree, it); - vy_index_unacct_range(index, it); - vy_index_remove_range(index, it); + struct vy_range *next = vy_range_tree_next(lsm->tree, it); + vy_lsm_unacct_range(lsm, it); + vy_lsm_remove_range(lsm, it); rlist_splice(&result->slices, &it->slices); result->slice_count += it->slice_count; vy_disk_stmt_counter_add(&result->count, &it->count); @@ -1141,12 +1141,12 @@ vy_index_coalesce_range(struct vy_index *index, struct vy_range *range) * as soon as we can. */ result->compact_priority = result->slice_count; - vy_index_acct_range(index, result); - vy_index_add_range(index, result); - index->range_tree_version++; + vy_lsm_acct_range(lsm, result); + vy_lsm_add_range(lsm, result); + lsm->range_tree_version++; say_info("%s: coalesced ranges %s", - vy_index_name(index), vy_range_str(result)); + vy_lsm_name(lsm), vy_range_str(result)); return true; fail_commit: @@ -1154,6 +1154,6 @@ fail_commit: fail_range: diag_log(); say_error("%s: failed to coalesce range %s", - vy_index_name(index), vy_range_str(range)); + vy_lsm_name(lsm), vy_range_str(range)); return false; } diff --git a/src/box/vy_index.h b/src/box/vy_lsm.h similarity index 59% rename from src/box/vy_index.h rename to src/box/vy_lsm.h index 33d1da4a..dcfbcb7b 100644 --- a/src/box/vy_index.h +++ b/src/box/vy_lsm.h @@ -1,5 +1,5 @@ -#ifndef INCLUDES_TARANTOOL_BOX_VY_INDEX_H -#define INCLUDES_TARANTOOL_BOX_VY_INDEX_H +#ifndef INCLUDES_TARANTOOL_BOX_VY_LSM_H +#define INCLUDES_TARANTOOL_BOX_VY_LSM_H /* * Copyright 2010-2017, Tarantool AUTHORS, please see AUTHORS file. * @@ -52,7 +52,7 @@ extern "C" { struct histogram; struct tuple; struct tuple_format; -struct vy_index; +struct vy_lsm; struct vy_mem; struct vy_mem_env; struct vy_recovery; @@ -60,10 +60,10 @@ struct vy_run; struct vy_run_env; typedef void -(*vy_upsert_thresh_cb)(struct vy_index *index, struct tuple *stmt, void *arg); +(*vy_upsert_thresh_cb)(struct vy_lsm *lsm, struct tuple *stmt, void *arg); -/** Common index environment. */ -struct vy_index_env { +/** Common LSM tree environment. */ +struct vy_lsm_env { /** Path to the data directory. */ const char *path; /** Memory generation counter. */ @@ -84,27 +84,29 @@ struct vy_index_env { vy_upsert_thresh_cb upsert_thresh_cb; /** Argument passed to upsert_thresh_cb. */ void *upsert_thresh_arg; - /** Number of indexes in this environment. */ - int index_count; + /** Number of LSM trees in this environment. */ + int lsm_count; /** Size of memory used for bloom filters. */ size_t bloom_size; /** Size of memory used for page index. */ size_t page_index_size; }; -/** Create a common index environment. */ +/** Create a common LSM tree environment. */ int -vy_index_env_create(struct vy_index_env *env, const char *path, - int64_t *p_generation, - vy_upsert_thresh_cb upsert_thresh_cb, - void *upsert_thresh_arg); +vy_lsm_env_create(struct vy_lsm_env *env, const char *path, + int64_t *p_generation, + vy_upsert_thresh_cb upsert_thresh_cb, + void *upsert_thresh_arg); -/** Destroy a common index environment. */ +/** Destroy a common LSM tree environment. */ void -vy_index_env_destroy(struct vy_index_env *env); +vy_lsm_env_destroy(struct vy_lsm_env *env); /** * A struct for primary and secondary Vinyl indexes. + * Named after the data structure used for organizing + * data on disk - log-structured merge-tree (LSM tree). * * Vinyl primary and secondary indexes work differently: * @@ -125,7 +127,7 @@ vy_index_env_destroy(struct vy_index_env *env); * When a search in a secondary index is made, we first look up * the secondary index tuple, containing the primary key, and then * use this key to find the original tuple in the primary index. - + * * While the primary index has only one key_def that is * used for validating and comparing tuples, secondary index needs * two: @@ -140,19 +142,19 @@ vy_index_env_destroy(struct vy_index_env *env); * parts concatenated together construe the tuple of the * secondary key, i.e. the tuple stored. This is key_def. */ -struct vy_index { - /** Common index environment. */ - struct vy_index_env *env; +struct vy_lsm { + /** Common LSM tree environment. */ + struct vy_lsm_env *env; /** - * Reference counter. Used to postpone index deletion + * Reference counter. Used to postpone LSM tree deletion * until all pending operations have completed. */ int refs; - /** Unique ID of this index. */ + /** Unique ID of this LSM tree. */ int64_t id; - /** Ordinal index number in the index array. */ + /** ID of the index this LSM tree is for. */ uint32_t index_id; - /** ID of the space this index belongs to. */ + /** ID of the space this LSM tree is for. */ uint32_t space_id; /** Index options. */ struct index_opts opts; @@ -161,14 +163,15 @@ struct vy_index { /** Key definition passed by the user. */ struct key_def *key_def; /** - * If the following flag is set the index is unique and - * it must be checked for duplicates on INSERT. Otherwise, - * the check can be skipped, either because this index - * is not unique or it is a part of another unique index. + * If the following flag is set, the index this LSM tree + * is created for is unique and it must be checked for + * duplicates on INSERT. Otherwise, the check can be skipped, + * either because the index is not unique or it is a part + * of another unique index. */ bool check_is_unique; /** - * Tuple format for tuples of this index created when + * Tuple format for tuples of this LSM tree created when * reading pages from disk. * Is distinct from mem_format only for secondary keys, * whose tuples have MP_NIL in all "gap" positions between @@ -180,7 +183,7 @@ struct vy_index { * tuples. */ struct tuple_format *disk_format; - /** Tuple format of the space this index belongs to. */ + /** Tuple format of the space this LSM tree belongs to. */ struct tuple_format *mem_format; /** * Format for tuples of type REPLACE or DELETE which @@ -196,14 +199,16 @@ struct vy_index { */ struct tuple_format *upsert_format; /** - * Primary index of the same space or NULL if this index - * is primary. Referenced by each secondary index. + * If this LSM tree is for a secondary index, the following + * variable points to the LSM tree of the primary index of + * the same space, otherwise it is set to NULL. Referenced + * by each secondary index. */ - struct vy_index *pk; - /** Index statistics. */ - struct vy_index_stat stat; + struct vy_lsm *pk; + /** LSM tree statistics. */ + struct vy_lsm_stat stat; /** - * Merge cache of this index. Contains hottest tuples + * Merge cache of this LSM tree. Contains hottest tuples * with continuation markers. */ struct vy_cache cache; @@ -216,23 +221,23 @@ struct vy_index { */ struct rlist sealed; /** - * Tree of all ranges of this index, linked by + * Tree of all ranges of this LSM tree, linked by * vy_range->tree_node, ordered by vy_range->begin. */ vy_range_tree_t *tree; - /** Number of ranges in this index. */ + /** Number of ranges in this LSM tree. */ int range_count; /** Heap of ranges, prioritized by compact_priority. */ heap_t range_heap; /** - * List of all runs created for this index, - * linked by vy_run->in_index. + * List of all runs created for this LSM tree, + * linked by vy_run->in_lsm. */ struct rlist runs; /** Number of entries in all ranges. */ int run_count; /** - * Histogram accounting how many ranges of the index + * Histogram accounting how many ranges of the LSM tree * have a particular number of runs. */ struct histogram *run_hist; @@ -251,182 +256,182 @@ struct vy_index { */ uint32_t range_tree_version; /** - * LSN of the last dump or -1 if the index has not + * LSN of the last dump or -1 if the LSM tree has not * been dumped yet. */ int64_t dump_lsn; /* - * This flag is set if the index creation was + * This flag is set if the LSM tree creation was * committed to the metadata log. */ bool is_committed; /** - * This flag is set if the index was dropped. - * It is also set on local recovery if the index + * This flag is set if the LSM tree was dropped. + * It is also set on local recovery if the LSM tree * will be dropped when WAL is replayed. */ bool is_dropped; /** - * If pin_count > 0 the index can't be scheduled for dump. + * If pin_count > 0 the LSM tree can't be scheduled for dump. * Used to make sure that the primary index is dumped last. */ int pin_count; - /** Set if the index is currently being dumped. */ + /** Set if the LSM tree is currently being dumped. */ bool is_dumping; /** Link in vy_scheduler->dump_heap. */ struct heap_node in_dump; /** Link in vy_scheduler->compact_heap. */ struct heap_node in_compact; /** - * Interval tree containing reads from this index done by all - * active transactions. Linked by vy_tx_interval->in_index. + * Interval tree containing reads from this LSM tree done by + * all active transactions. Linked by vy_tx_interval->in_lsm. * Used to abort transactions that conflict with a write to - * the index. + * this LSM tree. */ - vy_index_read_set_t read_set; + vy_lsm_read_set_t read_set; }; /** - * Assert if an index formats are inconsistent. - * @param index Index to validate. + * Assert if an LSM tree formats are inconsistent. + * @param lsm LSM tree to validate. */ void -vy_index_validate_formats(const struct vy_index *index); +vy_lsm_validate_formats(const struct vy_lsm *lsm); -/** Return index name. Used for logging. */ +/** Return LSM tree name. Used for logging. */ const char * -vy_index_name(struct vy_index *index); +vy_lsm_name(struct vy_lsm *lsm); /** Return sum size of memory tree extents. */ size_t -vy_index_mem_tree_size(struct vy_index *index); +vy_lsm_mem_tree_size(struct vy_lsm *lsm); -/** Allocate a new index object. */ -struct vy_index * -vy_index_new(struct vy_index_env *index_env, struct vy_cache_env *cache_env, +/** Allocate a new LSM tree object. */ +struct vy_lsm * +vy_lsm_new(struct vy_lsm_env *lsm_env, struct vy_cache_env *cache_env, struct vy_mem_env *mem_env, struct index_def *index_def, - struct tuple_format *format, struct vy_index *pk); + struct tuple_format *format, struct vy_lsm *pk); -/** Free an index object. */ +/** Free an LSM tree object. */ void -vy_index_delete(struct vy_index *index); +vy_lsm_delete(struct vy_lsm *lsm); /** - * Increment the reference counter of a vinyl index. - * An index cannot be deleted if its reference counter - * is elevated. + * Increment the reference counter of an LSM tree. + * An LSM tree cannot be deleted if its reference + * counter is elevated. */ static inline void -vy_index_ref(struct vy_index *index) +vy_lsm_ref(struct vy_lsm *lsm) { - assert(index->refs >= 0); - index->refs++; + assert(lsm->refs >= 0); + lsm->refs++; } /** - * Decrement the reference counter of a vinyl index. - * If the reference counter reaches 0, the index is - * deleted with vy_index_delete(). + * Decrement the reference counter of an LSM tree. + * If the reference counter reaches 0, the LSM tree + * is deleted with vy_lsm_delete(). */ static inline void -vy_index_unref(struct vy_index *index) +vy_lsm_unref(struct vy_lsm *lsm) { - assert(index->refs > 0); - if (--index->refs == 0) - vy_index_delete(index); + assert(lsm->refs > 0); + if (--lsm->refs == 0) + vy_lsm_delete(lsm); } /** - * Create a new vinyl index. + * Create a new LSM tree. * - * This function is called when an index is created after recovery - * is complete or during remote recovery. It initializes the range - * tree and makes the index directory. + * This function is called when an LSM tree is created + * after recovery is complete or during remote recovery. + * It initializes the range tree and makes the LSM tree + * directory. */ int -vy_index_create(struct vy_index *index); +vy_lsm_create(struct vy_lsm *lsm); /** - * Load a vinyl index from disk. Called on local recovery. + * Load an LSM tree from disk. Called on local recovery. * - * This function retrieves the index structure from the - * metadata log, rebuilds the range tree, and opens run - * files. + * This function retrieves the LSM tree structure from the + * metadata log, rebuilds the range tree, and opens run files. * - * If @is_checkpoint_recovery is set, the index is recovered from - * the last snapshot. In particular, this means that the index - * must have been logged in the metadata log and so if the + * If @is_checkpoint_recovery is set, the LSM tree is recovered + * from the last snapshot. In particular, this means that the LSM + * tree must have been logged in the metadata log and so if the * function does not find it in the recovery context, it will - * fail. If the flag is unset, the index is recovered from a - * WAL, in which case a missing index is OK - it just means we + * fail. If the flag is unset, the LSM tree is recovered from a + * WAL, in which case a missing LSM tree is OK - it just means we * failed to log it before restart and have to retry during * WAL replay. * - * @lsn is the LSN of the row that created the index. - * If the index is recovered from a snapshot, it is set + * @lsn is the LSN of the WAL row that created the LSM tree. + * If the LSM tree is recovered from a snapshot, it is set * to the snapshot signature. */ int -vy_index_recover(struct vy_index *index, struct vy_recovery *recovery, +vy_lsm_recover(struct vy_lsm *lsm, struct vy_recovery *recovery, struct vy_run_env *run_env, int64_t lsn, bool is_checkpoint_recovery, bool force_recovery); /** - * Return generation of in-memory data stored in an index + * Return generation of in-memory data stored in an LSM tree * (min over vy_mem->generation). */ int64_t -vy_index_generation(struct vy_index *index); +vy_lsm_generation(struct vy_lsm *lsm); -/** Return max compact_priority among ranges of an index. */ +/** Return max compact_priority among ranges of an LSM tree. */ int -vy_index_compact_priority(struct vy_index *index); +vy_lsm_compact_priority(struct vy_lsm *lsm); -/** Add a run to the list of runs of an index. */ +/** Add a run to the list of runs of an LSM tree. */ void -vy_index_add_run(struct vy_index *index, struct vy_run *run); +vy_lsm_add_run(struct vy_lsm *lsm, struct vy_run *run); -/** Remove a run from the list of runs of an index. */ +/** Remove a run from the list of runs of an LSM tree. */ void -vy_index_remove_run(struct vy_index *index, struct vy_run *run); +vy_lsm_remove_run(struct vy_lsm *lsm, struct vy_run *run); /** * Add a range to both the range tree and the range heap - * of an index. + * of an LSM tree. */ void -vy_index_add_range(struct vy_index *index, struct vy_range *range); +vy_lsm_add_range(struct vy_lsm *lsm, struct vy_range *range); /** * Remove a range from both the range tree and the range - * heap of an index. + * heap of an LSM tree. */ void -vy_index_remove_range(struct vy_index *index, struct vy_range *range); +vy_lsm_remove_range(struct vy_lsm *lsm, struct vy_range *range); -/** Account a range to the run histogram of an index. */ +/** Account a range to the run histogram of an LSM tree. */ void -vy_index_acct_range(struct vy_index *index, struct vy_range *range); +vy_lsm_acct_range(struct vy_lsm *lsm, struct vy_range *range); -/** Unaccount a range from the run histogram of an index. */ +/** Unaccount a range from the run histogram of an LSM tree. */ void -vy_index_unacct_range(struct vy_index *index, struct vy_range *range); +vy_lsm_unacct_range(struct vy_lsm *lsm, struct vy_range *range); /** - * Allocate a new active in-memory index for an index while moving - * the old one to the sealed list. Used by the dump task in order - * not to bother about synchronization with concurrent insertions - * while an index is being dumped. + * Allocate a new active in-memory index for an LSM tree while + * moving the old one to the sealed list. Used by the dump task + * in order not to bother about synchronization with concurrent + * insertions while an LSM tree is being dumped. */ int -vy_index_rotate_mem(struct vy_index *index); +vy_lsm_rotate_mem(struct vy_lsm *lsm); /** - * Remove an in-memory tree from the sealed list of a vinyl index, + * Remove an in-memory tree from the sealed list of an LSM tree, * unaccount and delete it. */ void -vy_index_delete_mem(struct vy_index *index, struct vy_mem *mem); +vy_lsm_delete_mem(struct vy_lsm *lsm, struct vy_mem *mem); /** * Split a range if it has grown too big, return true if the range @@ -436,7 +441,7 @@ vy_index_delete_mem(struct vy_index *index, struct vy_mem *mem); * operations, like writing a run file, and is done immediately. */ bool -vy_index_split_range(struct vy_index *index, struct vy_range *range); +vy_lsm_split_range(struct vy_lsm *lsm, struct vy_range *range); /** * Coalesce a range with one or more its neighbors if it is too small, @@ -449,16 +454,16 @@ vy_index_split_range(struct vy_index *index, struct vy_range *range); * case of merging key ranges. */ bool -vy_index_coalesce_range(struct vy_index *index, struct vy_range *range); +vy_lsm_coalesce_range(struct vy_lsm *lsm, struct vy_range *range); /** - * Insert a statement into the index's in-memory tree. If the - * region_stmt is NULL and the statement is successfully inserted + * Insert a statement into the in-memory index of an LSM tree. If + * the region_stmt is NULL and the statement is successfully inserted * then the new lsregion statement is returned via @a region_stmt. - * Either vy_index_commit_stmt() or vy_index_rollback_stmt() must + * Either vy_lsm_commit_stmt() or vy_lsm_rollback_stmt() must * be called on success. * - * @param index Index the statement is for. + * @param lsm LSM tree the statement is for. * @param mem In-memory tree to insert the statement into. * @param stmt Statement, allocated on malloc(). * @param region_stmt NULL or the same statement, allocated on @@ -468,33 +473,34 @@ vy_index_coalesce_range(struct vy_index *index, struct vy_range *range); * @retval -1 Memory error. */ int -vy_index_set(struct vy_index *index, struct vy_mem *mem, - const struct tuple *stmt, const struct tuple **region_stmt); +vy_lsm_set(struct vy_lsm *lsm, struct vy_mem *mem, + const struct tuple *stmt, const struct tuple **region_stmt); /** - * Confirm that the statement stays in the index's in-memory tree. + * Confirm that the statement stays in the in-memory index of + * an LSM tree. * - * @param index Index the statement is for. + * @param lsm LSM tree the statement is for. * @param mem In-memory tree where the statement was saved. * @param stmt Statement allocated from lsregion. */ void -vy_index_commit_stmt(struct vy_index *index, struct vy_mem *mem, - const struct tuple *stmt); +vy_lsm_commit_stmt(struct vy_lsm *lsm, struct vy_mem *mem, + const struct tuple *stmt); /** - * Erase a statement from the index's in-memory tree. + * Erase a statement from the in-memory index of an LSM tree. * - * @param index Index to erase from. + * @param lsm LSM tree to erase from. * @param mem In-memory tree where the statement was saved. * @param stmt Statement allocated from lsregion. */ void -vy_index_rollback_stmt(struct vy_index *index, struct vy_mem *mem, - const struct tuple *stmt); +vy_lsm_rollback_stmt(struct vy_lsm *lsm, struct vy_mem *mem, + const struct tuple *stmt); #if defined(__cplusplus) } /* extern "C" */ #endif /* defined(__cplusplus) */ -#endif /* INCLUDES_TARANTOOL_BOX_VY_INDEX_H */ +#endif /* INCLUDES_TARANTOOL_BOX_VY_LSM_H */ diff --git a/src/box/vy_mem.c b/src/box/vy_mem.c index 629634bb..1105340c 100644 --- a/src/box/vy_mem.c +++ b/src/box/vy_mem.c @@ -212,7 +212,7 @@ vy_mem_insert_upsert(struct vy_mem *mem, const struct tuple *stmt) * UPSERT, n = threshold + 1, * UPSERT, n = threshold + 1, all following ones have * ... threshold + 1. - * These values are used by vy_index_commit to squash + * These values are used by vy_lsm_commit_upsert to squash * UPSERTs subsequence. */ vy_mem_tree_iterator_next(&mem->tree, &inserted); diff --git a/src/box/vy_point_lookup.c b/src/box/vy_point_lookup.c index d92cb94f..c5aa9719 100644 --- a/src/box/vy_point_lookup.c +++ b/src/box/vy_point_lookup.c @@ -39,7 +39,7 @@ #include "fiber.h" -#include "vy_index.h" +#include "vy_lsm.h" #include "vy_stmt.h" #include "vy_tx.h" #include "vy_mem.h" @@ -123,18 +123,18 @@ vy_stmt_history_is_terminal(struct rlist *history) * Add one or no statement to the history list. */ static int -vy_point_lookup_scan_txw(struct vy_index *index, struct vy_tx *tx, +vy_point_lookup_scan_txw(struct vy_lsm *lsm, struct vy_tx *tx, struct tuple *key, struct rlist *history) { if (tx == NULL) return 0; - index->stat.txw.iterator.lookup++; + lsm->stat.txw.iterator.lookup++; struct txv *txv = - write_set_search_key(&tx->write_set, index, key); - assert(txv == NULL || txv->index == index); + write_set_search_key(&tx->write_set, lsm, key); + assert(txv == NULL || txv->lsm == lsm); if (txv == NULL) return 0; - vy_stmt_counter_acct_tuple(&index->stat.txw.iterator.get, + vy_stmt_counter_acct_tuple(&lsm->stat.txw.iterator.get, txv->stmt); struct vy_stmt_history_node *node = vy_stmt_history_node_new(); if (node == NULL) @@ -146,21 +146,21 @@ vy_point_lookup_scan_txw(struct vy_index *index, struct vy_tx *tx, } /** - * Scan index cache for given key. + * Scan LSM tree cache for given key. * Add one or no statement to the history list. */ static int -vy_point_lookup_scan_cache(struct vy_index *index, +vy_point_lookup_scan_cache(struct vy_lsm *lsm, const struct vy_read_view **rv, struct tuple *key, struct rlist *history) { - index->cache.stat.lookup++; - struct tuple *stmt = vy_cache_get(&index->cache, key); + lsm->cache.stat.lookup++; + struct tuple *stmt = vy_cache_get(&lsm->cache, key); if (stmt == NULL || vy_stmt_lsn(stmt) > (*rv)->vlsn) return 0; - vy_stmt_counter_acct_tuple(&index->cache.stat.get, stmt); + vy_stmt_counter_acct_tuple(&lsm->cache.stat.get, stmt); struct vy_stmt_history_node *node = vy_stmt_history_node_new(); if (node == NULL) return -1; @@ -176,7 +176,7 @@ vy_point_lookup_scan_cache(struct vy_index *index, * Add found statements to the history list up to terminal statement. */ static int -vy_point_lookup_scan_mem(struct vy_index *index, struct vy_mem *mem, +vy_point_lookup_scan_mem(struct vy_lsm *lsm, struct vy_mem *mem, const struct vy_read_view **rv, struct tuple *key, struct rlist *history) { @@ -186,7 +186,7 @@ vy_point_lookup_scan_mem(struct vy_index *index, struct vy_mem *mem, bool exact; struct vy_mem_tree_iterator mem_itr = vy_mem_tree_lower_bound(&mem->tree, &tree_key, &exact); - index->stat.memory.iterator.lookup++; + lsm->stat.memory.iterator.lookup++; const struct tuple *stmt = NULL; if (!vy_mem_tree_iterator_is_invalid(&mem_itr)) { stmt = *vy_mem_tree_iterator_get_elem(&mem->tree, &mem_itr); @@ -202,7 +202,7 @@ vy_point_lookup_scan_mem(struct vy_index *index, struct vy_mem *mem, if (node == NULL) return -1; - vy_stmt_counter_acct_tuple(&index->stat.memory.iterator.get, + vy_stmt_counter_acct_tuple(&lsm->stat.memory.iterator.get, stmt); node->src_type = ITER_SRC_MEM; @@ -226,22 +226,21 @@ vy_point_lookup_scan_mem(struct vy_index *index, struct vy_mem *mem, } /** - * Scan all mems that belongs to the index. + * Scan all mems that belongs to the LSM tree. * Add found statements to the history list up to terminal statement. */ static int -vy_point_lookup_scan_mems(struct vy_index *index, - const struct vy_read_view **rv, +vy_point_lookup_scan_mems(struct vy_lsm *lsm, const struct vy_read_view **rv, struct tuple *key, struct rlist *history) { - assert(index->mem != NULL); - int rc = vy_point_lookup_scan_mem(index, index->mem, rv, key, history); + assert(lsm->mem != NULL); + int rc = vy_point_lookup_scan_mem(lsm, lsm->mem, rv, key, history); struct vy_mem *mem; - rlist_foreach_entry(mem, &index->sealed, in_sealed) { + rlist_foreach_entry(mem, &lsm->sealed, in_sealed) { if (rc != 0 || vy_stmt_history_is_terminal(history)) return rc; - rc = vy_point_lookup_scan_mem(index, mem, rv, key, history); + rc = vy_point_lookup_scan_mem(lsm, mem, rv, key, history); } return 0; } @@ -253,7 +252,7 @@ vy_point_lookup_scan_mems(struct vy_index *index, * was found. */ static int -vy_point_lookup_scan_slice(struct vy_index *index, struct vy_slice *slice, +vy_point_lookup_scan_slice(struct vy_lsm *lsm, struct vy_slice *slice, const struct vy_read_view **rv, struct tuple *key, struct rlist *history, bool *terminal_found) { @@ -264,10 +263,10 @@ vy_point_lookup_scan_slice(struct vy_index *index, struct vy_slice *slice, * format in vy_mem. */ struct vy_run_iterator run_itr; - vy_run_iterator_open(&run_itr, &index->stat.disk.iterator, slice, - ITER_EQ, key, rv, index->cmp_def, index->key_def, - index->disk_format, index->upsert_format, - index->index_id == 0); + vy_run_iterator_open(&run_itr, &lsm->stat.disk.iterator, slice, + ITER_EQ, key, rv, lsm->cmp_def, lsm->key_def, + lsm->disk_format, lsm->upsert_format, + lsm->index_id == 0); struct tuple *stmt; rc = vy_run_iterator_next_key(&run_itr, &stmt); while (rc == 0 && stmt != NULL) { @@ -297,11 +296,10 @@ vy_point_lookup_scan_slice(struct vy_index *index, struct vy_slice *slice, * that complete history from runs will be extracted. */ static int -vy_point_lookup_scan_slices(struct vy_index *index, - const struct vy_read_view **rv, +vy_point_lookup_scan_slices(struct vy_lsm *lsm, const struct vy_read_view **rv, struct tuple *key, struct rlist *history) { - struct vy_range *range = vy_range_tree_find_by_key(index->tree, + struct vy_range *range = vy_range_tree_find_by_key(lsm->tree, ITER_EQ, key); assert(range != NULL); int slice_count = range->slice_count; @@ -323,7 +321,7 @@ vy_point_lookup_scan_slices(struct vy_index *index, bool terminal_found = false; for (i = 0; i < slice_count; i++) { if (rc == 0 && !terminal_found) - rc = vy_point_lookup_scan_slice(index, slices[i], + rc = vy_point_lookup_scan_slice(lsm, slices[i], rv, key, history, &terminal_found); vy_slice_unpin(slices[i]); } @@ -334,7 +332,7 @@ vy_point_lookup_scan_slices(struct vy_index *index, * Get a resultant statement from collected history. Add to cache if possible. */ static int -vy_point_lookup_apply_history(struct vy_index *index, +vy_point_lookup_apply_history(struct vy_lsm *lsm, const struct vy_read_view **rv, struct tuple *key, struct rlist *history, struct tuple **ret) @@ -365,9 +363,9 @@ vy_point_lookup_apply_history(struct vy_index *index, vy_stmt_lsn(node->stmt) <= (*rv)->vlsn); struct tuple *stmt = vy_apply_upsert(node->stmt, curr_stmt, - index->cmp_def, index->mem_format, - index->upsert_format, true); - index->stat.upsert.applied++; + lsm->cmp_def, lsm->mem_format, + lsm->upsert_format, true); + lsm->stat.upsert.applied++; if (stmt == NULL) return -1; if (curr_stmt != NULL) @@ -376,62 +374,62 @@ vy_point_lookup_apply_history(struct vy_index *index, node = rlist_prev_entry_safe(node, history, link); } if (curr_stmt != NULL) { - vy_stmt_counter_acct_tuple(&index->stat.get, curr_stmt); + vy_stmt_counter_acct_tuple(&lsm->stat.get, curr_stmt); *ret = curr_stmt; } /** * Add a statement to the cache */ if ((*rv)->vlsn == INT64_MAX) /* Do not store non-latest data */ - vy_cache_add(&index->cache, curr_stmt, NULL, key, ITER_EQ); + vy_cache_add(&lsm->cache, curr_stmt, NULL, key, ITER_EQ); return 0; } int -vy_point_lookup(struct vy_index *index, struct vy_tx *tx, +vy_point_lookup(struct vy_lsm *lsm, struct vy_tx *tx, const struct vy_read_view **rv, struct tuple *key, struct tuple **ret) { - assert(tuple_field_count(key) >= index->cmp_def->part_count); + assert(tuple_field_count(key) >= lsm->cmp_def->part_count); *ret = NULL; size_t region_svp = region_used(&fiber()->gc); double start_time = ev_monotonic_now(loop()); int rc = 0; - index->stat.lookup++; + lsm->stat.lookup++; /* History list */ struct rlist history; restart: rlist_create(&history); - rc = vy_point_lookup_scan_txw(index, tx, key, &history); + rc = vy_point_lookup_scan_txw(lsm, tx, key, &history); if (rc != 0 || vy_stmt_history_is_terminal(&history)) goto done; - rc = vy_point_lookup_scan_cache(index, rv, key, &history); + rc = vy_point_lookup_scan_cache(lsm, rv, key, &history); if (rc != 0 || vy_stmt_history_is_terminal(&history)) goto done; - rc = vy_point_lookup_scan_mems(index, rv, key, &history); + rc = vy_point_lookup_scan_mems(lsm, rv, key, &history); if (rc != 0 || vy_stmt_history_is_terminal(&history)) goto done; /* Save version before yield */ - uint32_t mem_list_version = index->mem_list_version; + uint32_t mem_list_version = lsm->mem_list_version; - rc = vy_point_lookup_scan_slices(index, rv, key, &history); + rc = vy_point_lookup_scan_slices(lsm, rv, key, &history); if (rc != 0) goto done; ERROR_INJECT(ERRINJ_VY_POINT_ITER_WAIT, { - while (mem_list_version == index->mem_list_version) + while (mem_list_version == lsm->mem_list_version) fiber_sleep(0.01); /* Turn of the injection to avoid infinite loop */ errinj(ERRINJ_VY_POINT_ITER_WAIT, ERRINJ_BOOL)->bparam = false; }); - if (mem_list_version != index->mem_list_version) { + if (mem_list_version != lsm->mem_list_version) { /* * Mem list was changed during yield. This could be rotation * or a dump. In case of dump the memory referenced by @@ -445,7 +443,7 @@ restart: done: if (rc == 0) { - rc = vy_point_lookup_apply_history(index, rv, key, + rc = vy_point_lookup_apply_history(lsm, rv, key, &history, ret); } vy_stmt_history_cleanup(&history, region_svp); @@ -454,11 +452,11 @@ done: return -1; double latency = ev_monotonic_now(loop()) - start_time; - latency_collect(&index->stat.latency, latency); + latency_collect(&lsm->stat.latency, latency); - if (latency > index->env->too_long_threshold) { + if (latency > lsm->env->too_long_threshold) { say_warn("%s: get(%s) => %s took too long: %.3f sec", - vy_index_name(index), tuple_str(key), + vy_lsm_name(lsm), tuple_str(key), vy_stmt_str(*ret), latency); } return 0; diff --git a/src/box/vy_point_lookup.h b/src/box/vy_point_lookup.h index a4dbe77e..d74be9a9 100644 --- a/src/box/vy_point_lookup.h +++ b/src/box/vy_point_lookup.h @@ -33,7 +33,7 @@ /** * Point lookup is a special case of read iterator that is designed for - * retrieving one value from index by a full key (all parts are present). + * retrieving one value from an LSM tree by a full key (all parts are present). * * Iterator collects necessary history of the given key from different sources * (txw, cache, mems, runs) that consists of some number of sequential upserts @@ -51,7 +51,7 @@ extern "C" { #endif /* defined(__cplusplus) */ -struct vy_index; +struct vy_lsm; struct vy_tx; struct vy_read_view; struct tuple; @@ -59,7 +59,7 @@ struct tuple; /** * Given a key that has all index parts (including primary index * parts in case of a secondary index), lookup the corresponding - * tuple in the index. The tuple is returned in @ret with its + * tuple in the LSM tree. The tuple is returned in @ret with its * reference counter elevated. * * The caller must guarantee that if the tuple looked up by this @@ -70,7 +70,7 @@ struct tuple; * the tuple is already tracked in a secondary index. */ int -vy_point_lookup(struct vy_index *index, struct vy_tx *tx, +vy_point_lookup(struct vy_lsm *lsm, struct vy_tx *tx, const struct vy_read_view **rv, struct tuple *key, struct tuple **ret); diff --git a/src/box/vy_range.h b/src/box/vy_range.h index c6d3a0ad..3a451fb4 100644 --- a/src/box/vy_range.h +++ b/src/box/vy_range.h @@ -54,7 +54,7 @@ struct tuple; struct vy_slice; /** - * Range of keys in an index stored on disk. + * Range of keys in an LSM tree stored on disk. */ struct vy_range { /** Unique ID of this range. */ @@ -108,20 +108,19 @@ struct vy_range { int compact_priority; /** Number of times the range was compacted. */ int n_compactions; - /** Link in vy_index->tree. */ + /** Link in vy_lsm->tree. */ rb_node(struct vy_range) tree_node; - /** Link in vy_index->range_heap. */ + /** Link in vy_lsm->range_heap. */ struct heap_node heap_node; /** - * Incremented whenever an in-memory index or on disk - * run is added to or deleted from this range. Used to - * invalidate iterators. + * Incremented whenever a run is added to or deleted + * from this range. Used invalidate read iterators. */ uint32_t version; }; /** - * Heap of all ranges of the same index, prioritized by + * Heap of all ranges of the same LSM tree, prioritized by * vy_range->compact_priority. */ #define HEAP_NAME vy_range_heap @@ -145,7 +144,7 @@ vy_range_is_scheduled(struct vy_range *range) } /** - * Search tree of all ranges of the same index, sorted by + * Search tree of all ranges of the same LSM tree, sorted by * vy_range->begin. Ranges in a tree are supposed to span * all possible keys without overlaps. */ diff --git a/src/box/vy_read_iterator.c b/src/box/vy_read_iterator.c index 3b5e34fc..37493e19 100644 --- a/src/box/vy_read_iterator.c +++ b/src/box/vy_read_iterator.c @@ -35,7 +35,7 @@ #include "vy_tx.h" #include "fiber.h" #include "vy_upsert.h" -#include "vy_index.h" +#include "vy_lsm.h" #include "vy_stat.h" /** @@ -141,7 +141,7 @@ vy_read_iterator_range_is_done(struct vy_read_iterator *itr) { struct tuple *stmt = itr->curr_stmt; struct vy_range *range = itr->curr_range; - struct key_def *cmp_def = itr->index->cmp_def; + struct key_def *cmp_def = itr->lsm->cmp_def; int dir = iterator_direction(itr->iterator_type); if (dir > 0 && range->end != NULL && @@ -182,7 +182,7 @@ vy_read_iterator_cmp_stmt(struct vy_read_iterator *itr, if (a == NULL && b == NULL) return 0; return iterator_direction(itr->iterator_type) * - vy_tuple_compare(a, b, itr->index->cmp_def); + vy_tuple_compare(a, b, itr->lsm->cmp_def); } /** @@ -195,7 +195,7 @@ vy_read_iterator_is_exact_match(struct vy_read_iterator *itr, { struct tuple *key = itr->key; enum iterator_type type = itr->iterator_type; - struct key_def *cmp_def = itr->index->cmp_def; + struct key_def *cmp_def = itr->lsm->cmp_def; /* * If the index is unique and the search key is full, @@ -442,7 +442,7 @@ vy_read_iterator_next_key(struct vy_read_iterator *itr, struct tuple **ret) if (itr->last_stmt != NULL && (itr->iterator_type == ITER_EQ || itr->iterator_type == ITER_REQ) && - tuple_field_count(itr->key) >= itr->index->cmp_def->part_count) { + tuple_field_count(itr->key) >= itr->lsm->cmp_def->part_count) { /* * There may be one statement at max satisfying * EQ with a full key. @@ -451,11 +451,11 @@ vy_read_iterator_next_key(struct vy_read_iterator *itr, struct tuple **ret) return 0; } /* - * Restore the iterator position if the index has changed + * Restore the iterator position if the LSM tree has changed * since the last iteration. */ - if (itr->mem_list_version != itr->index->mem_list_version || - itr->range_tree_version != itr->index->range_tree_version || + if (itr->mem_list_version != itr->lsm->mem_list_version || + itr->range_tree_version != itr->lsm->range_tree_version || itr->range_version != itr->curr_range->version) { vy_read_iterator_restore(itr); } @@ -501,8 +501,8 @@ rescan_disk: * because all slices were pinned and hence could not be * removed. */ - if (itr->mem_list_version != itr->index->mem_list_version || - itr->range_tree_version != itr->index->range_tree_version) { + if (itr->mem_list_version != itr->lsm->mem_list_version || + itr->range_tree_version != itr->lsm->range_tree_version) { vy_read_iterator_restore(itr); goto restart; } @@ -528,7 +528,7 @@ done: if (itr->need_check_eq && itr->curr_stmt != NULL && vy_stmt_compare(itr->curr_stmt, itr->key, - itr->index->cmp_def) != 0) + itr->lsm->cmp_def) != 0) itr->curr_stmt = NULL; if (vy_read_iterator_track_read(itr, itr->curr_stmt) != 0) @@ -592,7 +592,7 @@ vy_read_iterator_next_lsn(struct vy_read_iterator *itr, struct tuple **ret) /* * Look up the older statement in on-disk runs. * - * Note, we don't need to check the index version after the yield + * Note, we don't need to check the LSM tree version after the yield * caused by the disk read, because once we've come to this point, * we won't read any source except run slices, which are pinned * and hence cannot be removed during the yield. @@ -645,11 +645,11 @@ vy_read_iterator_squash_upsert(struct vy_read_iterator *itr, struct tuple **ret) { *ret = NULL; - struct vy_index *index = itr->index; + struct vy_lsm *lsm = itr->lsm; struct tuple *t = itr->curr_stmt; - /* Upserts enabled only in the primary index. */ - assert(vy_stmt_type(t) != IPROTO_UPSERT || index->index_id == 0); + /* Upserts enabled only in the primary index LSM tree. */ + assert(vy_stmt_type(t) != IPROTO_UPSERT || lsm->index_id == 0); tuple_ref(t); while (vy_stmt_type(t) == IPROTO_UPSERT) { struct tuple *next; @@ -659,9 +659,9 @@ vy_read_iterator_squash_upsert(struct vy_read_iterator *itr, return rc; } struct tuple *applied = vy_apply_upsert(t, next, - index->cmp_def, index->mem_format, - index->upsert_format, true); - index->stat.upsert.applied++; + lsm->cmp_def, lsm->mem_format, + lsm->upsert_format, true); + lsm->stat.upsert.applied++; tuple_unref(t); if (applied == NULL) return -1; @@ -679,9 +679,9 @@ vy_read_iterator_add_tx(struct vy_read_iterator *itr) assert(itr->tx != NULL); enum iterator_type iterator_type = (itr->iterator_type != ITER_REQ ? itr->iterator_type : ITER_LE); - struct vy_txw_iterator_stat *stat = &itr->index->stat.txw.iterator; + struct vy_txw_iterator_stat *stat = &itr->lsm->stat.txw.iterator; struct vy_read_src *sub_src = vy_read_iterator_add_src(itr); - vy_txw_iterator_open(&sub_src->txw_iterator, stat, itr->tx, itr->index, + vy_txw_iterator_open(&sub_src->txw_iterator, stat, itr->tx, itr->lsm, iterator_type, itr->key); } @@ -692,7 +692,7 @@ vy_read_iterator_add_cache(struct vy_read_iterator *itr) itr->iterator_type : ITER_LE); struct vy_read_src *sub_src = vy_read_iterator_add_src(itr); vy_cache_iterator_open(&sub_src->cache_iterator, - &itr->index->cache, iterator_type, + &itr->lsm->cache, iterator_type, itr->key, itr->read_view); } @@ -701,22 +701,20 @@ vy_read_iterator_add_mem(struct vy_read_iterator *itr) { enum iterator_type iterator_type = (itr->iterator_type != ITER_REQ ? itr->iterator_type : ITER_LE); - struct vy_index *index = itr->index; + struct vy_lsm *lsm = itr->lsm; struct vy_read_src *sub_src; /* Add the active in-memory index. */ - assert(index->mem != NULL); + assert(lsm->mem != NULL); sub_src = vy_read_iterator_add_src(itr); - vy_mem_iterator_open(&sub_src->mem_iterator, - &index->stat.memory.iterator, - index->mem, iterator_type, itr->key, - itr->read_view); + vy_mem_iterator_open(&sub_src->mem_iterator, &lsm->stat.memory.iterator, + lsm->mem, iterator_type, itr->key, itr->read_view); /* Add sealed in-memory indexes. */ struct vy_mem *mem; - rlist_foreach_entry(mem, &index->sealed, in_sealed) { + rlist_foreach_entry(mem, &lsm->sealed, in_sealed) { sub_src = vy_read_iterator_add_src(itr); vy_mem_iterator_open(&sub_src->mem_iterator, - &index->stat.memory.iterator, + &lsm->stat.memory.iterator, mem, iterator_type, itr->key, itr->read_view); } @@ -728,7 +726,7 @@ vy_read_iterator_add_disk(struct vy_read_iterator *itr) assert(itr->curr_range != NULL); enum iterator_type iterator_type = (itr->iterator_type != ITER_REQ ? itr->iterator_type : ITER_LE); - struct vy_index *index = itr->index; + struct vy_lsm *lsm = itr->lsm; struct vy_slice *slice; /* * The format of the statement must be exactly the space @@ -742,21 +740,20 @@ vy_read_iterator_add_disk(struct vy_read_iterator *itr) * dumped in-memory trees. We must not add both * the slice and the trees in this case, because * the read iterator can't deal with duplicates. - * Since index->dump_lsn is bumped after deletion + * Since lsm->dump_lsn is bumped after deletion * of dumped in-memory trees, we can filter out * the run slice containing duplicates by LSN. */ - if (slice->run->info.min_lsn > index->dump_lsn) + if (slice->run->info.min_lsn > lsm->dump_lsn) continue; - assert(slice->run->info.max_lsn <= index->dump_lsn); + assert(slice->run->info.max_lsn <= lsm->dump_lsn); struct vy_read_src *sub_src = vy_read_iterator_add_src(itr); vy_run_iterator_open(&sub_src->run_iterator, - &index->stat.disk.iterator, slice, + &lsm->stat.disk.iterator, slice, iterator_type, itr->key, - itr->read_view, index->cmp_def, - index->key_def, index->disk_format, - index->upsert_format, - index->index_id == 0); + itr->read_view, lsm->cmp_def, + lsm->key_def, lsm->disk_format, + lsm->upsert_format, lsm->index_id == 0); } } @@ -799,13 +796,13 @@ vy_read_iterator_cleanup(struct vy_read_iterator *itr) } void -vy_read_iterator_open(struct vy_read_iterator *itr, struct vy_index *index, +vy_read_iterator_open(struct vy_read_iterator *itr, struct vy_lsm *lsm, struct vy_tx *tx, enum iterator_type iterator_type, struct tuple *key, const struct vy_read_view **rv) { memset(itr, 0, sizeof(*itr)); - itr->index = index; + itr->lsm = lsm; itr->tx = tx; itr->iterator_type = iterator_type; itr->key = key; @@ -851,9 +848,9 @@ vy_read_iterator_restore(struct vy_read_iterator *itr) { vy_read_iterator_cleanup(itr); - itr->mem_list_version = itr->index->mem_list_version; - itr->range_tree_version = itr->index->range_tree_version; - itr->curr_range = vy_range_tree_find_by_key(itr->index->tree, + itr->mem_list_version = itr->lsm->mem_list_version; + itr->range_tree_version = itr->lsm->range_tree_version; + itr->curr_range = vy_range_tree_find_by_key(itr->lsm->tree, itr->iterator_type, itr->last_stmt ?: itr->key); itr->range_version = itr->curr_range->version; @@ -879,13 +876,13 @@ static void vy_read_iterator_next_range(struct vy_read_iterator *itr) { struct vy_range *range = itr->curr_range; - struct key_def *cmp_def = itr->index->cmp_def; + struct key_def *cmp_def = itr->lsm->cmp_def; int dir = iterator_direction(itr->iterator_type); assert(range != NULL); while (true) { - range = dir > 0 ? vy_range_tree_next(itr->index->tree, range) : - vy_range_tree_prev(itr->index->tree, range); + range = dir > 0 ? vy_range_tree_next(itr->lsm->tree, range) : + vy_range_tree_prev(itr->lsm->tree, range); assert(range != NULL); if (itr->last_stmt == NULL) @@ -927,16 +924,16 @@ vy_read_iterator_track_read(struct vy_read_iterator *itr, struct tuple *stmt) if (stmt == NULL) { stmt = (itr->iterator_type == ITER_EQ || itr->iterator_type == ITER_REQ ? - itr->key : itr->index->env->empty_key); + itr->key : itr->lsm->env->empty_key); } int rc; if (iterator_direction(itr->iterator_type) >= 0) { - rc = vy_tx_track(itr->tx, itr->index, itr->key, + rc = vy_tx_track(itr->tx, itr->lsm, itr->key, itr->iterator_type != ITER_GT, stmt, true); } else { - rc = vy_tx_track(itr->tx, itr->index, stmt, true, + rc = vy_tx_track(itr->tx, itr->lsm, stmt, true, itr->key, itr->iterator_type != ITER_LT); } return rc; @@ -951,7 +948,7 @@ vy_read_iterator_next(struct vy_read_iterator *itr, struct tuple **result) if (!itr->search_started) { itr->search_started = true; - itr->index->stat.lookup++; + itr->lsm->stat.lookup++; vy_read_iterator_restore(itr); } @@ -961,7 +958,7 @@ vy_read_iterator_next(struct vy_read_iterator *itr, struct tuple **result) bool skipped_txw_delete = false; struct tuple *t = NULL; - struct vy_index *index = itr->index; + struct vy_lsm *lsm = itr->lsm; int rc = 0; while (true) { rc = vy_read_iterator_next_key(itr, &t); @@ -993,7 +990,7 @@ vy_read_iterator_next(struct vy_read_iterator *itr, struct tuple **result) vy_stmt_type(*result) == IPROTO_INSERT || vy_stmt_type(*result) == IPROTO_REPLACE); if (*result != NULL) - vy_stmt_counter_acct_tuple(&index->stat.get, *result); + vy_stmt_counter_acct_tuple(&lsm->stat.get, *result); #ifndef NDEBUG /* Check constraints. */ @@ -1005,18 +1002,18 @@ vy_read_iterator_next(struct vy_read_iterator *itr, struct tuple **result) */ if (itr->last_stmt != NULL && tuple_field_count(itr->key) > 0) { int cmp = dir * vy_stmt_compare(*result, itr->key, - itr->index->cmp_def); + itr->lsm->cmp_def); assert(cmp >= 0); } /* * Ensure the read iterator does not return duplicates - * and respects statements order (index->cmp_def includes + * and respects statements order (lsm->cmp_def includes * primary parts, so prev_key != itr->last_stmt for any - * index). + * LSM tree). */ if (prev_key != NULL && itr->last_stmt != NULL) { assert(dir * vy_tuple_compare(prev_key, itr->last_stmt, - index->cmp_def) < 0); + lsm->cmp_def) < 0); } #endif @@ -1034,7 +1031,7 @@ vy_read_iterator_next(struct vy_read_iterator *itr, struct tuple **result) */ cache_prev = NULL; } - vy_cache_add(&itr->index->cache, *result, cache_prev, + vy_cache_add(&itr->lsm->cache, *result, cache_prev, itr->key, itr->iterator_type); } clear: @@ -1042,11 +1039,11 @@ clear: tuple_unref(prev_key); ev_tstamp latency = ev_monotonic_now(loop()) - start_time; - latency_collect(&index->stat.latency, latency); + latency_collect(&lsm->stat.latency, latency); - if (latency > index->env->too_long_threshold) { + if (latency > lsm->env->too_long_threshold) { say_warn("%s: select(%s, %s) => %s took too long: %.3f sec", - vy_index_name(index), tuple_str(itr->key), + vy_lsm_name(lsm), tuple_str(itr->key), iterator_type_strs[itr->iterator_type], vy_stmt_str(itr->last_stmt), latency); } diff --git a/src/box/vy_read_iterator.h b/src/box/vy_read_iterator.h index 5726b042..4f9d3d4b 100644 --- a/src/box/vy_read_iterator.h +++ b/src/box/vy_read_iterator.h @@ -44,11 +44,11 @@ extern "C" { /** * Vinyl read iterator. * - * Used for executing a SELECT request over a Vinyl index. + * Used for executing a SELECT request over an LSM tree. */ struct vy_read_iterator { - /** Index to iterate over. */ - struct vy_index *index; + /** LSM tree to iterate over. */ + struct vy_lsm *lsm; /** Active transaction or NULL. */ struct vy_tx *tx; /** Iterator type. */ @@ -67,12 +67,12 @@ struct vy_read_iterator { /** Last statement returned by vy_read_iterator_next(). */ struct tuple *last_stmt; /** - * Copy of index->range_tree_version. + * Copy of lsm->range_tree_version. * Used for detecting range tree changes. */ uint32_t range_tree_version; /** - * Copy of index->mem_list_version. + * Copy of lsm->mem_list_version. * Used for detecting memory level changes. */ uint32_t mem_list_version; @@ -94,7 +94,7 @@ struct vy_read_iterator { uint32_t src_count; /** Maximal capacity of the src array. */ uint32_t src_capacity; - /** Index of the current merge source. */ + /** Offset of the current merge source. */ uint32_t curr_src; /** Statement returned by the current merge source. */ struct tuple *curr_stmt; @@ -122,7 +122,7 @@ struct vy_read_iterator { /** * Open the read iterator. * @param itr Read iterator. - * @param index Vinyl index to iterate. + * @param lsm LSM tree to iterate. * @param tx Current transaction, if exists. * @param iterator_type Type of the iterator that determines order * of the iteration. @@ -130,7 +130,7 @@ struct vy_read_iterator { * @param rv Read view. */ void -vy_read_iterator_open(struct vy_read_iterator *itr, struct vy_index *index, +vy_read_iterator_open(struct vy_read_iterator *itr, struct vy_lsm *lsm, struct vy_tx *tx, enum iterator_type iterator_type, struct tuple *key, const struct vy_read_view **rv); diff --git a/src/box/vy_read_set.c b/src/box/vy_read_set.c index bb54a4a6..0f3fab61 100644 --- a/src/box/vy_read_set.c +++ b/src/box/vy_read_set.c @@ -37,15 +37,15 @@ #include "trivia/util.h" #include "tuple.h" -#include "vy_index.h" +#include "vy_lsm.h" #include "vy_stmt.h" int vy_read_interval_cmpl(const struct vy_read_interval *a, const struct vy_read_interval *b) { - assert(a->index == b->index); - struct key_def *cmp_def = a->index->cmp_def; + assert(a->lsm == b->lsm); + struct key_def *cmp_def = a->lsm->cmp_def; int cmp = vy_stmt_compare(a->left, b->left, cmp_def); if (cmp != 0) return cmp; @@ -67,8 +67,8 @@ int vy_read_interval_cmpr(const struct vy_read_interval *a, const struct vy_read_interval *b) { - assert(a->index == b->index); - struct key_def *cmp_def = a->index->cmp_def; + assert(a->lsm == b->lsm); + struct key_def *cmp_def = a->lsm->cmp_def; int cmp = vy_stmt_compare(a->right, b->right, cmp_def); if (cmp != 0) return cmp; @@ -90,9 +90,9 @@ bool vy_read_interval_should_merge(const struct vy_read_interval *l, const struct vy_read_interval *r) { - assert(l->index == r->index); + assert(l->lsm == r->lsm); assert(vy_read_interval_cmpl(l, r) <= 0); - struct key_def *cmp_def = l->index->cmp_def; + struct key_def *cmp_def = l->lsm->cmp_def; int cmp = vy_stmt_compare(l->right, r->left, cmp_def); if (cmp > 0) return true; @@ -116,13 +116,13 @@ struct vy_tx * vy_tx_conflict_iterator_next(struct vy_tx_conflict_iterator *it) { struct vy_read_interval *curr, *left, *right; - while ((curr = vy_index_read_set_walk_next(&it->tree_walk, it->tree_dir, - &left, &right)) != NULL) { - struct key_def *cmp_def = curr->index->cmp_def; + while ((curr = vy_lsm_read_set_walk_next(&it->tree_walk, it->tree_dir, + &left, &right)) != NULL) { + struct key_def *cmp_def = curr->lsm->cmp_def; const struct vy_read_interval *last = curr->subtree_last; - assert(left == NULL || left->index == curr->index); - assert(right == NULL || right->index == curr->index); + assert(left == NULL || left->lsm == curr->lsm); + assert(right == NULL || right->lsm == curr->lsm); int cmp_right = vy_stmt_compare(it->stmt, last->right, cmp_def); if (cmp_right == 0 && !last->right_belongs) diff --git a/src/box/vy_read_set.h b/src/box/vy_read_set.h index 272da63a..1b139ccf 100644 --- a/src/box/vy_read_set.h +++ b/src/box/vy_read_set.h @@ -48,7 +48,7 @@ extern "C" { struct tuple; struct vy_tx; -struct vy_index; +struct vy_lsm; /** * A tuple interval read by a transaction. @@ -56,8 +56,8 @@ struct vy_index; struct vy_read_interval { /** Transaction. */ struct vy_tx *tx; - /** Index that the transaction read from. */ - struct vy_index *index; + /** LSM tree that the transaction read from. */ + struct vy_lsm *lsm; /** Left boundary of the interval. */ struct tuple *left; /** Right boundary of the interval. */ @@ -73,8 +73,8 @@ struct vy_read_interval { const struct vy_read_interval *subtree_last; /** Link in vy_tx->read_set. */ rb_node(struct vy_read_interval) in_tx; - /** Link in vy_index->read_set. */ - rb_node(struct vy_read_interval) in_index; + /** Link in vy_lsm->read_set. */ + rb_node(struct vy_read_interval) in_lsm; /** * Auxiliary list node. Used by vy_tx_track() to * link intervals to be merged. @@ -125,7 +125,7 @@ vy_read_interval_should_merge(const struct vy_read_interval *l, /** * Tree that contains tuple intervals read by a transactions. - * Linked by vy_read_interval->in_tx. Sorted by vy_index, then + * Linked by vy_read_interval->in_tx. Sorted by vy_lsm, then * by vy_read_interval->left. Intervals stored in this tree * must not intersect. */ @@ -136,7 +136,7 @@ vy_tx_read_set_cmp(const struct vy_read_interval *a, const struct vy_read_interval *b) { assert(a->tx == b->tx); - int rc = a->index < b->index ? -1 : a->index > b->index; + int rc = a->lsm < b->lsm ? -1 : a->lsm > b->lsm; if (rc == 0) rc = vy_read_interval_cmpl(a, b); return rc; @@ -146,18 +146,18 @@ rb_gen(MAYBE_UNUSED static inline, vy_tx_read_set_, vy_tx_read_set_t, struct vy_read_interval, in_tx, vy_tx_read_set_cmp); /** - * Interval tree used for tracking reads done from an index by - * all active transactions. Linked by vy_read_interval->in_index. + * Interval tree used for tracking reads done from an LSM tree by + * all active transactions. Linked by vy_read_interval->in_lsm. * Sorted by vy_read_interval->left, then by vy_tx. Intervals that * belong to different transactions may intersect. */ -typedef rb_tree(struct vy_read_interval) vy_index_read_set_t; +typedef rb_tree(struct vy_read_interval) vy_lsm_read_set_t; static inline int -vy_index_read_set_cmp(const struct vy_read_interval *a, - const struct vy_read_interval *b) +vy_lsm_read_set_cmp(const struct vy_read_interval *a, + const struct vy_read_interval *b) { - assert(a->index == b->index); + assert(a->lsm == b->lsm); int rc = vy_read_interval_cmpl(a, b); if (rc == 0) rc = a->tx < b->tx ? -1 : a->tx > b->tx; @@ -165,9 +165,9 @@ vy_index_read_set_cmp(const struct vy_read_interval *a, } static inline void -vy_index_read_set_aug(struct vy_read_interval *node, - const struct vy_read_interval *left, - const struct vy_read_interval *right) +vy_lsm_read_set_aug(struct vy_read_interval *node, + const struct vy_read_interval *left, + const struct vy_read_interval *right) { node->subtree_last = node; if (left != NULL && @@ -178,9 +178,9 @@ vy_index_read_set_aug(struct vy_read_interval *node, node->subtree_last = right->subtree_last; } -rb_gen_aug(MAYBE_UNUSED static inline, vy_index_read_set_, vy_index_read_set_t, - struct vy_read_interval, in_index, vy_index_read_set_cmp, - vy_index_read_set_aug); +rb_gen_aug(MAYBE_UNUSED static inline, vy_lsm_read_set_, vy_lsm_read_set_t, + struct vy_read_interval, in_lsm, vy_lsm_read_set_cmp, + vy_lsm_read_set_aug); /** * Iterator over transactions that conflict with a statement. @@ -189,10 +189,10 @@ struct vy_tx_conflict_iterator { /** The statement. */ const struct tuple *stmt; /** - * Iterator over the index interval tree checked + * Iterator over the interval tree checked * for intersections with the statement. */ - struct vy_index_read_set_walk tree_walk; + struct vy_lsm_read_set_walk tree_walk; /** * Direction of tree traversal to be used on the * next iteration. @@ -202,10 +202,10 @@ struct vy_tx_conflict_iterator { static inline void vy_tx_conflict_iterator_init(struct vy_tx_conflict_iterator *it, - vy_index_read_set_t *read_set, + vy_lsm_read_set_t *read_set, const struct tuple *stmt) { - vy_index_read_set_walk_init(&it->tree_walk, read_set); + vy_lsm_read_set_walk_init(&it->tree_walk, read_set); it->tree_dir = 0; it->stmt = stmt; } diff --git a/src/box/vy_run.c b/src/box/vy_run.c index f8d96f33..7f792c13 100644 --- a/src/box/vy_run.c +++ b/src/box/vy_run.c @@ -236,7 +236,7 @@ vy_run_new(struct vy_run_env *env, int64_t id) run->dump_lsn = -1; run->fd = -1; run->refs = 1; - rlist_create(&run->in_index); + rlist_create(&run->in_lsm); rlist_create(&run->in_unused); TRASH(&run->info.bloom); return run; @@ -719,8 +719,7 @@ vy_page_xrow(struct vy_page *page, uint32_t stmt_no, * Read raw stmt data from the page * @param page Page. * @param stmt_no Statement position in the page. - * @param cmp_def Key definition of an index, including - * primary key parts. + * @param cmp_def Key definition, including primary key parts. * @param format Format for REPLACE/DELETE tuples. * @param upsert_format Format for UPSERT tuples. * @param is_primary True if the index is primary. diff --git a/src/box/vy_run.h b/src/box/vy_run.h index 6973ee2d..ecf55350 100644 --- a/src/box/vy_run.h +++ b/src/box/vy_run.h @@ -144,8 +144,8 @@ struct vy_run { * after compaction. */ struct rlist in_unused; - /** Link in vy_index::runs list. */ - struct rlist in_index; + /** Link in vy_lsm::runs list. */ + struct rlist in_lsm; }; /** @@ -214,9 +214,9 @@ struct vy_run_iterator { struct vy_run_iterator_stat *stat; /* Members needed for memory allocation and disk access */ - /** Index key definition used for storing statements on disk. */ + /** Key definition used for comparing statements on disk. */ const struct key_def *cmp_def; - /** Index key definition defined by the user. */ + /** Key definition provided by the user. */ const struct key_def *key_def; /** * Format ot allocate REPLACE and DELETE tuples read from @@ -382,8 +382,8 @@ enum vy_file_type { extern const char *vy_file_suffix[]; static inline int -vy_index_snprint_path(char *buf, int size, const char *dir, - uint32_t space_id, uint32_t iid) +vy_lsm_snprint_path(char *buf, int size, const char *dir, + uint32_t space_id, uint32_t iid) { return snprintf(buf, size, "%s/%u/%u", dir, (unsigned)space_id, (unsigned)iid); @@ -403,7 +403,7 @@ vy_run_snprint_path(char *buf, int size, const char *dir, int64_t run_id, enum vy_file_type type) { int total = 0; - SNPRINT(total, vy_index_snprint_path, buf, size, + SNPRINT(total, vy_lsm_snprint_path, buf, size, dir, (unsigned)space_id, (unsigned)iid); SNPRINT(total, snprintf, buf, size, "/"); SNPRINT(total, vy_run_snprint_filename, buf, size, run_id, type); diff --git a/src/box/vy_scheduler.c b/src/box/vy_scheduler.c index 2ae0d8ca..27961155 100644 --- a/src/box/vy_scheduler.c +++ b/src/box/vy_scheduler.c @@ -48,7 +48,7 @@ #include "fiber_cond.h" #include "salad/stailq.h" #include "say.h" -#include "vy_index.h" +#include "vy_lsm.h" #include "vy_log.h" #include "vy_mem.h" #include "vy_range.h" @@ -93,7 +93,7 @@ struct vy_task_ops { /** * This function is called by the scheduler if either ->execute * or ->complete failed. It may be used to undo changes done to - * the index when preparing the task. + * the LSM tree when preparing the task. * * If @in_shutdown is set, the callback is invoked from the * engine destructor. @@ -108,10 +108,10 @@ struct vy_task { int status; /** If ->execute fails, the error is stored here. */ struct diag diag; - /** Index this task is for. */ - struct vy_index *index; + /** LSM tree this task is for. */ + struct vy_lsm *lsm; /** - * Copies of index->key/cmp_def to protect from + * Copies of lsm->key/cmp_def to protect from * multithread read/write on alter. */ struct key_def *cmp_def; @@ -154,11 +154,11 @@ struct vy_task { * Allocate a new task to be executed by a worker thread. * When preparing an asynchronous task, this function must * be called before yielding the current fiber in order to - * pin the index the task is for so that a concurrent fiber + * pin the LSM tree the task is for so that a concurrent fiber * does not free it from under us. */ static struct vy_task * -vy_task_new(struct mempool *pool, struct vy_index *index, +vy_task_new(struct mempool *pool, struct vy_lsm *lsm, const struct vy_task_ops *ops) { struct vy_task *task = mempool_alloc(pool); @@ -169,19 +169,19 @@ vy_task_new(struct mempool *pool, struct vy_index *index, } memset(task, 0, sizeof(*task)); task->ops = ops; - task->index = index; - task->cmp_def = key_def_dup(index->cmp_def); + task->lsm = lsm; + task->cmp_def = key_def_dup(lsm->cmp_def); if (task->cmp_def == NULL) { mempool_free(pool, task); return NULL; } - task->key_def = key_def_dup(index->key_def); + task->key_def = key_def_dup(lsm->key_def); if (task->key_def == NULL) { key_def_delete(task->cmp_def); mempool_free(pool, task); return NULL; } - vy_index_ref(index); + vy_lsm_ref(lsm); diag_create(&task->diag); return task; } @@ -192,7 +192,7 @@ vy_task_delete(struct mempool *pool, struct vy_task *task) { key_def_delete(task->cmp_def); key_def_delete(task->key_def); - vy_index_unref(task->index); + vy_lsm_unref(task->lsm); diag_destroy(&task->diag); TRASH(task); mempool_free(pool, task); @@ -201,21 +201,22 @@ vy_task_delete(struct mempool *pool, struct vy_task *task) static bool vy_dump_heap_less(struct heap_node *a, struct heap_node *b) { - struct vy_index *i1 = container_of(a, struct vy_index, in_dump); - struct vy_index *i2 = container_of(b, struct vy_index, in_dump); + struct vy_lsm *i1 = container_of(a, struct vy_lsm, in_dump); + struct vy_lsm *i2 = container_of(b, struct vy_lsm, in_dump); /* - * Indexes that are currently being dumped or can't be scheduled - * for dump right now are moved off the top of the heap. + * LSM trees that are currently being dumped or can't be + * scheduled for dump right now are moved off the top of + * the heap. */ if (i1->is_dumping != i2->is_dumping) return i1->is_dumping < i2->is_dumping; if (i1->pin_count != i2->pin_count) return i1->pin_count < i2->pin_count; - /* Older indexes are dumped first. */ - int64_t i1_generation = vy_index_generation(i1); - int64_t i2_generation = vy_index_generation(i2); + /* Older LSM trees are dumped first. */ + int64_t i1_generation = vy_lsm_generation(i1); + int64_t i2_generation = vy_lsm_generation(i2); if (i1_generation != i2_generation) return i1_generation < i2_generation; /* @@ -240,13 +241,13 @@ vy_dump_heap_less(struct heap_node *a, struct heap_node *b) static bool vy_compact_heap_less(struct heap_node *a, struct heap_node *b) { - struct vy_index *i1 = container_of(a, struct vy_index, in_compact); - struct vy_index *i2 = container_of(b, struct vy_index, in_compact); + struct vy_lsm *i1 = container_of(a, struct vy_lsm, in_compact); + struct vy_lsm *i2 = container_of(b, struct vy_lsm, in_compact); /* - * Prefer indexes whose read amplification will be reduced + * Prefer LSM trees whose read amplification will be reduced * most as a result of compaction. */ - return vy_index_compact_priority(i1) > vy_index_compact_priority(i2); + return vy_lsm_compact_priority(i1) > vy_lsm_compact_priority(i2); } #define HEAP_NAME vy_compact_heap @@ -388,58 +389,55 @@ vy_scheduler_destroy(struct vy_scheduler *scheduler) } void -vy_scheduler_add_index(struct vy_scheduler *scheduler, - struct vy_index *index) +vy_scheduler_add_lsm(struct vy_scheduler *scheduler, struct vy_lsm *lsm) { - assert(index->in_dump.pos == UINT32_MAX); - assert(index->in_compact.pos == UINT32_MAX); - vy_dump_heap_insert(&scheduler->dump_heap, &index->in_dump); - vy_compact_heap_insert(&scheduler->compact_heap, &index->in_compact); + assert(lsm->in_dump.pos == UINT32_MAX); + assert(lsm->in_compact.pos == UINT32_MAX); + vy_dump_heap_insert(&scheduler->dump_heap, &lsm->in_dump); + vy_compact_heap_insert(&scheduler->compact_heap, &lsm->in_compact); } void -vy_scheduler_remove_index(struct vy_scheduler *scheduler, - struct vy_index *index) +vy_scheduler_remove_lsm(struct vy_scheduler *scheduler, struct vy_lsm *lsm) { - assert(index->in_dump.pos != UINT32_MAX); - assert(index->in_compact.pos != UINT32_MAX); - vy_dump_heap_delete(&scheduler->dump_heap, &index->in_dump); - vy_compact_heap_delete(&scheduler->compact_heap, &index->in_compact); - index->in_dump.pos = UINT32_MAX; - index->in_compact.pos = UINT32_MAX; + assert(lsm->in_dump.pos != UINT32_MAX); + assert(lsm->in_compact.pos != UINT32_MAX); + vy_dump_heap_delete(&scheduler->dump_heap, &lsm->in_dump); + vy_compact_heap_delete(&scheduler->compact_heap, &lsm->in_compact); + lsm->in_dump.pos = UINT32_MAX; + lsm->in_compact.pos = UINT32_MAX; } static void -vy_scheduler_update_index(struct vy_scheduler *scheduler, - struct vy_index *index) +vy_scheduler_update_lsm(struct vy_scheduler *scheduler, struct vy_lsm *lsm) { - if (index->is_dropped) { - /* Dropped indexes are exempted from scheduling. */ - assert(index->in_dump.pos == UINT32_MAX); - assert(index->in_compact.pos == UINT32_MAX); + if (lsm->is_dropped) { + /* Dropped LSM trees are exempted from scheduling. */ + assert(lsm->in_dump.pos == UINT32_MAX); + assert(lsm->in_compact.pos == UINT32_MAX); return; } - assert(index->in_dump.pos != UINT32_MAX); - assert(index->in_compact.pos != UINT32_MAX); - vy_dump_heap_update(&scheduler->dump_heap, &index->in_dump); - vy_compact_heap_update(&scheduler->compact_heap, &index->in_compact); + assert(lsm->in_dump.pos != UINT32_MAX); + assert(lsm->in_compact.pos != UINT32_MAX); + vy_dump_heap_update(&scheduler->dump_heap, &lsm->in_dump); + vy_compact_heap_update(&scheduler->compact_heap, &lsm->in_compact); } static void -vy_scheduler_pin_index(struct vy_scheduler *scheduler, struct vy_index *index) +vy_scheduler_pin_lsm(struct vy_scheduler *scheduler, struct vy_lsm *lsm) { - assert(!index->is_dumping); - if (index->pin_count++ == 0) - vy_scheduler_update_index(scheduler, index); + assert(!lsm->is_dumping); + if (lsm->pin_count++ == 0) + vy_scheduler_update_lsm(scheduler, lsm); } static void -vy_scheduler_unpin_index(struct vy_scheduler *scheduler, struct vy_index *index) +vy_scheduler_unpin_lsm(struct vy_scheduler *scheduler, struct vy_lsm *lsm) { - assert(!index->is_dumping); - assert(index->pin_count > 0); - if (--index->pin_count == 0) - vy_scheduler_update_index(scheduler, index); + assert(!lsm->is_dumping); + assert(lsm->pin_count > 0); + if (--lsm->pin_count == 0) + vy_scheduler_update_lsm(scheduler, lsm); } void @@ -486,22 +484,21 @@ vy_scheduler_complete_dump(struct vy_scheduler *scheduler) int64_t min_generation = scheduler->generation; struct heap_node *pn = vy_dump_heap_top(&scheduler->dump_heap); if (pn != NULL) { - struct vy_index *index; - index = container_of(pn, struct vy_index, in_dump); - min_generation = vy_index_generation(index); + struct vy_lsm *lsm = container_of(pn, struct vy_lsm, in_dump); + min_generation = vy_lsm_generation(lsm); } if (min_generation == scheduler->dump_generation) { /* - * There are still indexes that must be dumped + * There are still LSM trees that must be dumped * during the current dump round. */ return; } /* - * The oldest index data is newer than @dump_generation, - * so the current dump round has been finished. Notify - * about dump completion. + * The oldest LSM tree data is newer than @dump_generation, + * so the current dump round has been finished. Notify about + * dump completion. */ double now = ev_monotonic_now(loop()); double dump_duration = now - scheduler->dump_start; @@ -590,19 +587,19 @@ vy_scheduler_end_checkpoint(struct vy_scheduler *scheduler) } /** - * Allocate a new run for an index and write the information + * Allocate a new run for an LSM tree and write the information * about it to the metadata log so that we could still find * and delete it in case a write error occured. This function * is called from dump/compaction task constructor. */ static struct vy_run * -vy_run_prepare(struct vy_run_env *run_env, struct vy_index *index) +vy_run_prepare(struct vy_run_env *run_env, struct vy_lsm *lsm) { struct vy_run *run = vy_run_new(run_env, vy_log_next_id()); if (run == NULL) return NULL; vy_log_tx_begin(); - vy_log_prepare_run(index->id, run->id); + vy_log_prepare_run(lsm->id, run->id); if (vy_log_tx_commit() < 0) { vy_run_unref(run); return NULL; @@ -643,7 +640,7 @@ vy_run_discard(struct vy_run *run) static int vy_task_write_run(struct vy_scheduler *scheduler, struct vy_task *task) { - struct vy_index *index = task->index; + struct vy_lsm *lsm = task->lsm; struct vy_stmt_stream *wi = task->wi; ERROR_INJECT(ERRINJ_VY_RUN_WRITE, @@ -655,8 +652,8 @@ vy_task_write_run(struct vy_scheduler *scheduler, struct vy_task *task) usleep(inj->dparam * 1000000); struct vy_run_writer writer; - if (vy_run_writer_create(&writer, task->new_run, index->env->path, - index->space_id, index->index_id, + if (vy_run_writer_create(&writer, task->new_run, lsm->env->path, + lsm->space_id, lsm->index_id, task->cmp_def, task->key_def, task->page_size, task->bloom_fpr, task->max_output_count) != 0) @@ -705,34 +702,34 @@ vy_task_dump_execute(struct vy_scheduler *scheduler, struct vy_task *task) static int vy_task_dump_complete(struct vy_scheduler *scheduler, struct vy_task *task) { - struct vy_index *index = task->index; + struct vy_lsm *lsm = task->lsm; struct vy_run *new_run = task->new_run; int64_t dump_lsn = new_run->dump_lsn; - struct tuple_format *key_format = index->env->key_format; + 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, loops = 0; - assert(index->is_dumping); + assert(lsm->is_dumping); if (vy_run_is_empty(new_run)) { /* * In case the run is empty, we can discard the run * and delete dumped in-memory trees right away w/o * inserting slices into ranges. However, we need - * to log index dump anyway. + * to log LSM tree dump anyway. */ vy_log_tx_begin(); - vy_log_dump_index(index->id, dump_lsn); + vy_log_dump_lsm(lsm->id, dump_lsn); if (vy_log_tx_commit() < 0) goto fail; vy_run_discard(new_run); goto delete_mems; } - assert(new_run->info.min_lsn > index->dump_lsn); + assert(new_run->info.min_lsn > lsm->dump_lsn); assert(new_run->info.max_lsn <= dump_lsn); /* @@ -750,28 +747,28 @@ vy_task_dump_complete(struct vy_scheduler *scheduler, struct vy_task *task) tuple_unref(min_key); goto fail; } - begin_range = vy_range_tree_psearch(index->tree, min_key); - end_range = vy_range_tree_nsearch(index->tree, max_key); + begin_range = vy_range_tree_psearch(lsm->tree, min_key); + end_range = vy_range_tree_nsearch(lsm->tree, max_key); tuple_unref(min_key); tuple_unref(max_key); /* * For each intersected range allocate a slice of the new run. */ - new_slices = calloc(index->range_count, sizeof(*new_slices)); + new_slices = calloc(lsm->range_count, sizeof(*new_slices)); if (new_slices == NULL) { - diag_set(OutOfMemory, index->range_count * sizeof(*new_slices), + diag_set(OutOfMemory, lsm->range_count * sizeof(*new_slices), "malloc", "struct vy_slice *"); goto fail; } for (range = begin_range, i = 0; range != end_range; - range = vy_range_tree_next(index->tree, range), i++) { + range = vy_range_tree_next(lsm->tree, range), i++) { slice = vy_slice_new(vy_log_next_id(), new_run, - range->begin, range->end, index->cmp_def); + range->begin, range->end, lsm->cmp_def); if (slice == NULL) goto fail_free_slices; - assert(i < index->range_count); + assert(i < lsm->range_count); new_slices[i] = slice; /* * It's OK to yield here for the range tree can only @@ -785,10 +782,10 @@ vy_task_dump_complete(struct vy_scheduler *scheduler, struct vy_task *task) * Log change in metadata. */ vy_log_tx_begin(); - vy_log_create_run(index->id, new_run->id, dump_lsn); + vy_log_create_run(lsm->id, new_run->id, dump_lsn); for (range = begin_range, i = 0; range != end_range; - range = vy_range_tree_next(index->tree, range), i++) { - assert(i < index->range_count); + range = vy_range_tree_next(lsm->tree, range), i++) { + assert(i < lsm->range_count); slice = new_slices[i]; vy_log_insert_slice(range->id, new_run->id, slice->id, tuple_data_or_null(slice->begin), @@ -797,15 +794,15 @@ vy_task_dump_complete(struct vy_scheduler *scheduler, struct vy_task *task) if (++loops % VY_YIELD_LOOPS == 0) fiber_sleep(0); /* see comment above */ } - vy_log_dump_index(index->id, dump_lsn); + vy_log_dump_lsm(lsm->id, dump_lsn); if (vy_log_tx_commit() < 0) goto fail_free_slices; /* * Account the new run. */ - vy_index_add_run(index, new_run); - vy_stmt_counter_add_disk(&index->stat.disk.dump.out, &new_run->count); + vy_lsm_add_run(lsm, new_run); + vy_stmt_counter_add_disk(&lsm->stat.disk.dump.out, &new_run->count); /* Drop the reference held by the task. */ vy_run_unref(new_run); @@ -814,23 +811,23 @@ vy_task_dump_complete(struct vy_scheduler *scheduler, struct vy_task *task) * Add new slices to ranges. */ for (range = begin_range, i = 0; range != end_range; - range = vy_range_tree_next(index->tree, range), i++) { - assert(i < index->range_count); + range = vy_range_tree_next(lsm->tree, range), i++) { + assert(i < lsm->range_count); slice = new_slices[i]; - vy_index_unacct_range(index, range); + vy_lsm_unacct_range(lsm, range); vy_range_add_slice(range, slice); - vy_index_acct_range(index, range); - vy_range_update_compact_priority(range, &index->opts); + vy_lsm_acct_range(lsm, range); + vy_range_update_compact_priority(range, &lsm->opts); if (!vy_range_is_scheduled(range)) - vy_range_heap_update(&index->range_heap, + vy_range_heap_update(&lsm->range_heap, &range->heap_node); range->version++; /* * If we yield here, a concurrent fiber will see * a range with a run slice containing statements - * present in the in-memory trees of the index. + * present in the in-memory indexes of the LSM tree. * This is OK, because read iterator won't use the - * new run slice until index->dump_lsn is bumped, + * new run slice until lsm->dump_lsn is bumped, * which is only done after in-memory trees are * removed (see vy_read_iterator_add_disk()). */ @@ -843,34 +840,34 @@ delete_mems: /* * Delete dumped in-memory trees. */ - rlist_foreach_entry_safe(mem, &index->sealed, in_sealed, next_mem) { + rlist_foreach_entry_safe(mem, &lsm->sealed, in_sealed, next_mem) { if (mem->generation > scheduler->dump_generation) continue; - vy_stmt_counter_add(&index->stat.disk.dump.in, &mem->count); - vy_index_delete_mem(index, mem); + vy_stmt_counter_add(&lsm->stat.disk.dump.in, &mem->count); + vy_lsm_delete_mem(lsm, mem); } - index->dump_lsn = dump_lsn; - index->stat.disk.dump.count++; + lsm->dump_lsn = dump_lsn; + lsm->stat.disk.dump.count++; /* The iterator has been cleaned up in a worker thread. */ task->wi->iface->close(task->wi); - index->is_dumping = false; - vy_scheduler_update_index(scheduler, index); + lsm->is_dumping = false; + vy_scheduler_update_lsm(scheduler, lsm); - if (index->index_id != 0) - vy_scheduler_unpin_index(scheduler, index->pk); + if (lsm->index_id != 0) + vy_scheduler_unpin_lsm(scheduler, lsm->pk); assert(scheduler->dump_task_count > 0); scheduler->dump_task_count--; - say_info("%s: dump completed", vy_index_name(index)); + say_info("%s: dump completed", vy_lsm_name(lsm)); vy_scheduler_complete_dump(scheduler); return 0; fail_free_slices: - for (i = 0; i < index->range_count; i++) { + for (i = 0; i < lsm->range_count; i++) { slice = new_slices[i]; if (slice != NULL) vy_slice_delete(slice); @@ -886,21 +883,21 @@ static void vy_task_dump_abort(struct vy_scheduler *scheduler, struct vy_task *task, bool in_shutdown) { - struct vy_index *index = task->index; + struct vy_lsm *lsm = task->lsm; - assert(index->is_dumping); + assert(lsm->is_dumping); /* The iterator has been cleaned up in a worker thread. */ task->wi->iface->close(task->wi); /* * It's no use alerting the user if the server is - * shutting down or the index was dropped. + * shutting down or the LSM tree was dropped. */ - if (!in_shutdown && !index->is_dropped) { + if (!in_shutdown && !lsm->is_dropped) { struct error *e = diag_last_error(&task->diag); error_log(e); - say_error("%s: dump failed", vy_index_name(index)); + say_error("%s: dump failed", vy_lsm_name(lsm)); } /* The metadata log is unavailable on shutdown. */ @@ -909,36 +906,36 @@ vy_task_dump_abort(struct vy_scheduler *scheduler, struct vy_task *task, else vy_run_unref(task->new_run); - index->is_dumping = false; - vy_scheduler_update_index(scheduler, index); + lsm->is_dumping = false; + vy_scheduler_update_lsm(scheduler, lsm); - if (index->index_id != 0) - vy_scheduler_unpin_index(scheduler, index->pk); + if (lsm->index_id != 0) + vy_scheduler_unpin_lsm(scheduler, lsm->pk); assert(scheduler->dump_task_count > 0); scheduler->dump_task_count--; /* - * If the index was dropped during dump, we abort the - * dump task, but we should still poke the scheduler + * If the LSM tree was dropped during dump, we abort + * the dump task, but we should still poke the scheduler * to check if the current dump round is complete. - * If we don't and this index happens to be the last + * If we don't and this LSM tree happens to be the last * one of the current generation, the scheduler will * never be notified about dump completion and hence * memory will never be released. */ - if (index->is_dropped) + if (lsm->is_dropped) vy_scheduler_complete_dump(scheduler); } /** - * Create a task to dump an index. + * Create a task to dump an LSM tree. * * On success the task is supposed to dump all in-memory * trees created at @scheduler->dump_generation. */ static int -vy_task_dump_new(struct vy_scheduler *scheduler, struct vy_index *index, +vy_task_dump_new(struct vy_scheduler *scheduler, struct vy_lsm *lsm, struct vy_task **p_task) { static struct vy_task_ops dump_ops = { @@ -947,21 +944,21 @@ vy_task_dump_new(struct vy_scheduler *scheduler, struct vy_index *index, .abort = vy_task_dump_abort, }; - assert(!index->is_dropped); - assert(!index->is_dumping); - assert(index->pin_count == 0); - assert(vy_index_generation(index) == scheduler->dump_generation); + assert(!lsm->is_dropped); + assert(!lsm->is_dumping); + assert(lsm->pin_count == 0); + assert(vy_lsm_generation(lsm) == scheduler->dump_generation); assert(scheduler->dump_generation < scheduler->generation); struct errinj *inj = errinj(ERRINJ_VY_INDEX_DUMP, ERRINJ_INT); - if (inj != NULL && inj->iparam == (int)index->index_id) { + if (inj != NULL && inj->iparam == (int)lsm->index_id) { diag_set(ClientError, ER_INJECTION, "vinyl index dump"); goto err; } /* Rotate the active tree if it needs to be dumped. */ - if (index->mem->generation == scheduler->dump_generation && - vy_index_rotate_mem(index) != 0) + if (lsm->mem->generation == scheduler->dump_generation && + vy_lsm_rotate_mem(lsm) != 0) goto err; /* @@ -971,7 +968,7 @@ vy_task_dump_new(struct vy_scheduler *scheduler, struct vy_index *index, int64_t dump_lsn = -1; size_t max_output_count = 0; struct vy_mem *mem, *next_mem; - rlist_foreach_entry_safe(mem, &index->sealed, in_sealed, next_mem) { + rlist_foreach_entry_safe(mem, &lsm->sealed, in_sealed, next_mem) { if (mem->generation > scheduler->dump_generation) continue; vy_mem_wait_pinned(mem); @@ -980,7 +977,7 @@ vy_task_dump_new(struct vy_scheduler *scheduler, struct vy_index *index, * The tree is empty so we can delete it * right away, without involving a worker. */ - vy_index_delete_mem(index, mem); + vy_lsm_delete_mem(lsm, mem); continue; } dump_lsn = MAX(dump_lsn, mem->max_lsn); @@ -988,18 +985,18 @@ vy_task_dump_new(struct vy_scheduler *scheduler, struct vy_index *index, } if (max_output_count == 0) { - /* Nothing to do, pick another index. */ - vy_scheduler_update_index(scheduler, index); + /* Nothing to do, pick another LSM tree. */ + vy_scheduler_update_lsm(scheduler, lsm); vy_scheduler_complete_dump(scheduler); return 0; } struct vy_task *task = vy_task_new(&scheduler->task_pool, - index, &dump_ops); + lsm, &dump_ops); if (task == NULL) goto err; - struct vy_run *new_run = vy_run_prepare(scheduler->run_env, index); + struct vy_run *new_run = vy_run_prepare(scheduler->run_env, lsm); if (new_run == NULL) goto err_run; @@ -1007,13 +1004,13 @@ vy_task_dump_new(struct vy_scheduler *scheduler, struct vy_index *index, new_run->dump_lsn = dump_lsn; struct vy_stmt_stream *wi; - bool is_last_level = (index->run_count == 0); - wi = vy_write_iterator_new(task->cmp_def, index->disk_format, - index->upsert_format, index->index_id == 0, + bool is_last_level = (lsm->run_count == 0); + wi = vy_write_iterator_new(task->cmp_def, lsm->disk_format, + lsm->upsert_format, lsm->index_id == 0, is_last_level, scheduler->read_views); if (wi == NULL) goto err_wi; - rlist_foreach_entry(mem, &index->sealed, in_sealed) { + rlist_foreach_entry(mem, &lsm->sealed, in_sealed) { if (mem->generation > scheduler->dump_generation) continue; if (vy_write_iterator_new_mem(wi, mem) != 0) @@ -1023,27 +1020,27 @@ vy_task_dump_new(struct vy_scheduler *scheduler, struct vy_index *index, task->new_run = new_run; task->wi = wi; task->max_output_count = max_output_count; - task->bloom_fpr = index->opts.bloom_fpr; - task->page_size = index->opts.page_size; + task->bloom_fpr = lsm->opts.bloom_fpr; + task->page_size = lsm->opts.page_size; - index->is_dumping = true; - vy_scheduler_update_index(scheduler, index); + lsm->is_dumping = true; + vy_scheduler_update_lsm(scheduler, lsm); - if (index->index_id != 0) { + if (lsm->index_id != 0) { /* - * The primary index must be dumped after all - * secondary indexes of the same space - see - * vy_dump_heap_less(). To make sure it isn't - * picked by the scheduler while all secondary - * indexes are being dumped, temporarily remove + * The primary index LSM tree must be dumped after + * all secondary index LSM trees of the same space, + * see vy_dump_heap_less(). To make sure it isn't + * picked by the scheduler while all secondary index + * LSM trees are being dumped, temporarily remove * it from the dump heap. */ - vy_scheduler_pin_index(scheduler, index->pk); + vy_scheduler_pin_lsm(scheduler, lsm->pk); } scheduler->dump_task_count++; - say_info("%s: dump started", vy_index_name(index)); + say_info("%s: dump started", vy_lsm_name(lsm)); *p_task = task; return 0; @@ -1055,7 +1052,7 @@ err_run: vy_task_delete(&scheduler->task_pool, task); err: diag_log(); - say_error("%s: could not start dump", vy_index_name(index)); + say_error("%s: could not start dump", vy_lsm_name(lsm)); return -1; } @@ -1068,7 +1065,7 @@ vy_task_compact_execute(struct vy_scheduler *scheduler, struct vy_task *task) static int vy_task_compact_complete(struct vy_scheduler *scheduler, struct vy_task *task) { - struct vy_index *index = task->index; + struct vy_lsm *lsm = task->lsm; struct vy_range *range = task->range; struct vy_run *new_run = task->new_run; struct vy_slice *first_slice = task->first_slice; @@ -1084,8 +1081,8 @@ vy_task_compact_complete(struct vy_scheduler *scheduler, struct vy_task *task) * compacted runs. */ if (!vy_run_is_empty(new_run)) { - new_slice = vy_slice_new(vy_log_next_id(), new_run, NULL, NULL, - index->cmp_def); + new_slice = vy_slice_new(vy_log_next_id(), new_run, + NULL, NULL, lsm->cmp_def); if (new_slice == NULL) return -1; } @@ -1122,8 +1119,7 @@ vy_task_compact_complete(struct vy_scheduler *scheduler, struct vy_task *task) rlist_foreach_entry(run, &unused_runs, in_unused) vy_log_drop_run(run->id, gc_lsn); if (new_slice != NULL) { - vy_log_create_run(index->id, new_run->id, - new_run->dump_lsn); + vy_log_create_run(lsm->id, new_run->id, new_run->dump_lsn); vy_log_insert_slice(range->id, new_run->id, new_slice->id, tuple_data_or_null(new_slice->begin), tuple_data_or_null(new_slice->end)); @@ -1142,10 +1138,8 @@ vy_task_compact_complete(struct vy_scheduler *scheduler, struct vy_task *task) */ vy_log_tx_begin(); rlist_foreach_entry(run, &unused_runs, in_unused) { - if (vy_run_remove_files(index->env->path, - index->space_id, - index->index_id, - run->id) == 0) { + if (vy_run_remove_files(lsm->env->path, lsm->space_id, + lsm->index_id, run->id) == 0) { vy_log_forget_run(run->id); } } @@ -1157,8 +1151,8 @@ vy_task_compact_complete(struct vy_scheduler *scheduler, struct vy_task *task) * otherwise discard it. */ if (new_slice != NULL) { - vy_index_add_run(index, new_run); - vy_stmt_counter_add_disk(&index->stat.disk.compact.out, + vy_lsm_add_run(lsm, new_run); + vy_stmt_counter_add_disk(&lsm->stat.disk.compact.out, &new_run->count); /* Drop the reference held by the task. */ vy_run_unref(new_run); @@ -1174,29 +1168,29 @@ vy_task_compact_complete(struct vy_scheduler *scheduler, struct vy_task *task) * the compacted slices were. */ RLIST_HEAD(compacted_slices); - vy_index_unacct_range(index, range); + vy_lsm_unacct_range(lsm, range); if (new_slice != NULL) vy_range_add_slice_before(range, new_slice, first_slice); for (slice = first_slice; ; slice = next_slice) { next_slice = rlist_next_entry(slice, in_range); vy_range_remove_slice(range, slice); rlist_add_entry(&compacted_slices, slice, in_range); - vy_stmt_counter_add_disk(&index->stat.disk.compact.in, + vy_stmt_counter_add_disk(&lsm->stat.disk.compact.in, &slice->count); if (slice == last_slice) break; } range->n_compactions++; range->version++; - vy_index_acct_range(index, range); - vy_range_update_compact_priority(range, &index->opts); - index->stat.disk.compact.count++; + vy_lsm_acct_range(lsm, range); + vy_range_update_compact_priority(range, &lsm->opts); + lsm->stat.disk.compact.count++; /* * Unaccount unused runs and delete compacted slices. */ rlist_foreach_entry(run, &unused_runs, in_unused) - vy_index_remove_run(index, run); + vy_lsm_remove_run(lsm, run); rlist_foreach_entry_safe(slice, &compacted_slices, in_range, next_slice) { vy_slice_wait_pinned(slice); @@ -1207,11 +1201,11 @@ vy_task_compact_complete(struct vy_scheduler *scheduler, struct vy_task *task) task->wi->iface->close(task->wi); assert(range->heap_node.pos == UINT32_MAX); - vy_range_heap_insert(&index->range_heap, &range->heap_node); - vy_scheduler_update_index(scheduler, index); + vy_range_heap_insert(&lsm->range_heap, &range->heap_node); + vy_scheduler_update_lsm(scheduler, lsm); say_info("%s: completed compacting range %s", - vy_index_name(index), vy_range_str(range)); + vy_lsm_name(lsm), vy_range_str(range)); return 0; } @@ -1219,7 +1213,7 @@ static void vy_task_compact_abort(struct vy_scheduler *scheduler, struct vy_task *task, bool in_shutdown) { - struct vy_index *index = task->index; + struct vy_lsm *lsm = task->lsm; struct vy_range *range = task->range; /* The iterator has been cleaned up in worker. */ @@ -1227,13 +1221,13 @@ vy_task_compact_abort(struct vy_scheduler *scheduler, struct vy_task *task, /* * It's no use alerting the user if the server is - * shutting down or the index was dropped. + * shutting down or the LSM tree was dropped. */ - if (!in_shutdown && !index->is_dropped) { + if (!in_shutdown && !lsm->is_dropped) { struct error *e = diag_last_error(&task->diag); error_log(e); say_error("%s: failed to compact range %s", - vy_index_name(index), vy_range_str(range)); + vy_lsm_name(lsm), vy_range_str(range)); } /* The metadata log is unavailable on shutdown. */ @@ -1243,12 +1237,12 @@ vy_task_compact_abort(struct vy_scheduler *scheduler, struct vy_task *task, vy_run_unref(task->new_run); assert(range->heap_node.pos == UINT32_MAX); - vy_range_heap_insert(&index->range_heap, &range->heap_node); - vy_scheduler_update_index(scheduler, index); + vy_range_heap_insert(&lsm->range_heap, &range->heap_node); + vy_scheduler_update_lsm(scheduler, lsm); } static int -vy_task_compact_new(struct vy_scheduler *scheduler, struct vy_index *index, +vy_task_compact_new(struct vy_scheduler *scheduler, struct vy_lsm *lsm, struct vy_task **p_task) { static struct vy_task_ops compact_ops = { @@ -1260,32 +1254,32 @@ vy_task_compact_new(struct vy_scheduler *scheduler, struct vy_index *index, struct heap_node *range_node; struct vy_range *range; - assert(!index->is_dropped); + assert(!lsm->is_dropped); - range_node = vy_range_heap_top(&index->range_heap); + range_node = vy_range_heap_top(&lsm->range_heap); assert(range_node != NULL); range = container_of(range_node, struct vy_range, heap_node); assert(range->compact_priority > 1); - if (vy_index_split_range(index, range) || - vy_index_coalesce_range(index, range)) { - vy_scheduler_update_index(scheduler, index); + if (vy_lsm_split_range(lsm, range) || + vy_lsm_coalesce_range(lsm, range)) { + vy_scheduler_update_lsm(scheduler, lsm); return 0; } struct vy_task *task = vy_task_new(&scheduler->task_pool, - index, &compact_ops); + lsm, &compact_ops); if (task == NULL) goto err_task; - struct vy_run *new_run = vy_run_prepare(scheduler->run_env, index); + struct vy_run *new_run = vy_run_prepare(scheduler->run_env, lsm); if (new_run == NULL) goto err_run; struct vy_stmt_stream *wi; bool is_last_level = (range->compact_priority == range->slice_count); - wi = vy_write_iterator_new(task->cmp_def, index->disk_format, - index->upsert_format, index->index_id == 0, + wi = vy_write_iterator_new(task->cmp_def, lsm->disk_format, + lsm->upsert_format, lsm->index_id == 0, is_last_level, scheduler->read_views); if (wi == NULL) goto err_wi; @@ -1314,19 +1308,19 @@ vy_task_compact_new(struct vy_scheduler *scheduler, struct vy_index *index, task->range = range; task->new_run = new_run; task->wi = wi; - task->bloom_fpr = index->opts.bloom_fpr; - task->page_size = index->opts.page_size; + task->bloom_fpr = lsm->opts.bloom_fpr; + task->page_size = lsm->opts.page_size; /* * Remove the range we are going to compact from the heap * so that it doesn't get selected again. */ - vy_range_heap_delete(&index->range_heap, range_node); + vy_range_heap_delete(&lsm->range_heap, range_node); range_node->pos = UINT32_MAX; - vy_scheduler_update_index(scheduler, index); + vy_scheduler_update_lsm(scheduler, lsm); say_info("%s: started compacting range %s, runs %d/%d", - vy_index_name(index), vy_range_str(range), + vy_lsm_name(lsm), vy_range_str(range), range->compact_priority, range->slice_count); *p_task = task; return 0; @@ -1340,17 +1334,17 @@ err_run: err_task: diag_log(); say_error("%s: could not start compacting range %s: %s", - vy_index_name(index), vy_range_str(range)); + vy_lsm_name(lsm), vy_range_str(range)); return -1; } /** - * Create a task for dumping an index. The new task is returned - * in @ptask. If there's no index that needs to be dumped @ptask + * Create a task for dumping an LSM tree. The new task is returned + * in @ptask. If there's no LSM tree that needs to be dumped @ptask * is set to NULL. * - * We only dump an index if it needs to be snapshotted or the quota - * on memory usage is exceeded. In either case, the oldest index + * We only dump an LSM tree if it needs to be snapshotted or the quota + * on memory usage is exceeded. In either case, the oldest LSM tree * is selected, because dumping it will free the maximal amount of * memory due to log structured design of the memory allocator. * @@ -1370,38 +1364,38 @@ retry: return 0; } /* - * Look up the oldest index eligible for dump. + * Look up the oldest LSM tree eligible for dump. */ struct heap_node *pn = vy_dump_heap_top(&scheduler->dump_heap); if (pn == NULL) { /* - * There is no vinyl index and so no task to schedule. + * There is no LSM tree and so no task to schedule. * Complete the current dump round. */ vy_scheduler_complete_dump(scheduler); return 0; } - struct vy_index *index = container_of(pn, struct vy_index, in_dump); - if (!index->is_dumping && index->pin_count == 0 && - vy_index_generation(index) == scheduler->dump_generation) { + struct vy_lsm *lsm = container_of(pn, struct vy_lsm, in_dump); + if (!lsm->is_dumping && lsm->pin_count == 0 && + vy_lsm_generation(lsm) == scheduler->dump_generation) { /* - * Dump is in progress and there is an index that + * Dump is in progress and there is an LSM tree that * contains data that must be dumped at the current * round. Try to create a task for it. */ - if (vy_task_dump_new(scheduler, index, ptask) != 0) + if (vy_task_dump_new(scheduler, lsm, ptask) != 0) return -1; if (*ptask != NULL) return 0; /* new task */ /* * All in-memory trees eligible for dump were empty * and so were deleted without involving a worker - * thread. Check another index. + * thread. Check another LSM tree. */ goto retry; } /* - * Dump is in progress, but all eligible indexes are + * Dump is in progress, but all eligible LSM trees are * already being dumped. Wait until the current round * is complete. */ @@ -1430,13 +1424,13 @@ retry: struct heap_node *pn = vy_compact_heap_top(&scheduler->compact_heap); if (pn == NULL) return 0; /* nothing to do */ - struct vy_index *index = container_of(pn, struct vy_index, in_compact); - if (vy_index_compact_priority(index) <= 1) + struct vy_lsm *lsm = container_of(pn, struct vy_lsm, in_compact); + if (vy_lsm_compact_priority(lsm) <= 1) return 0; /* nothing to do */ - if (vy_task_compact_new(scheduler, index, ptask) != 0) + if (vy_task_compact_new(scheduler, lsm, ptask) != 0) return -1; if (*ptask == NULL) - goto retry; /* index dropped or range split/coalesced */ + goto retry; /* LSM tree dropped or range split/coalesced */ return 0; /* new task */ } @@ -1480,7 +1474,7 @@ static int vy_scheduler_complete_task(struct vy_scheduler *scheduler, struct vy_task *task) { - if (task->index->is_dropped) { + if (task->lsm->is_dropped) { if (task->ops->abort) task->ops->abort(scheduler, task, false); return 0; diff --git a/src/box/vy_scheduler.h b/src/box/vy_scheduler.h index 6724c01b..4db86152 100644 --- a/src/box/vy_scheduler.h +++ b/src/box/vy_scheduler.h @@ -50,7 +50,7 @@ extern "C" { struct cord; struct fiber; -struct vy_index; +struct vy_lsm; struct vy_run_env; struct vy_scheduler; @@ -97,13 +97,13 @@ struct vy_scheduler { */ pthread_mutex_t mutex; /** - * Heap of indexes, ordered by dump priority, - * linked by vy_index::in_dump. + * Heap of LSM trees, ordered by dump priority, + * linked by vy_lsm::in_dump. */ heap_t dump_heap; /** - * Heap of indexes, ordered by compaction priority, - * linked by vy_index::in_compact. + * Heap of LSM trees, ordered by compaction priority, + * linked by vy_lsm::in_compact. */ heap_t compact_heap; /** Last error seen by the scheduler. */ @@ -184,16 +184,16 @@ void vy_scheduler_destroy(struct vy_scheduler *scheduler); /** - * Add an index to scheduler dump/compaction queues. + * Add an LSM tree to scheduler dump/compaction queues. */ void -vy_scheduler_add_index(struct vy_scheduler *, struct vy_index *); +vy_scheduler_add_lsm(struct vy_scheduler *, struct vy_lsm *); /** - * Remove an index from scheduler dump/compaction queues. + * Remove an LSM tree from scheduler dump/compaction queues. */ void -vy_scheduler_remove_index(struct vy_scheduler *, struct vy_index *); +vy_scheduler_remove_lsm(struct vy_scheduler *, struct vy_lsm *); /** * Trigger dump of all currently existing in-memory trees. diff --git a/src/box/vy_stat.h b/src/box/vy_stat.h index 35442629..ca52c4d3 100644 --- a/src/box/vy_stat.h +++ b/src/box/vy_stat.h @@ -110,13 +110,13 @@ struct vy_compact_stat { struct vy_stmt_counter out; }; -/** Vinyl index statistics. */ -struct vy_index_stat { - /** Number of lookups in the index. */ +/** LSM tree statistics. */ +struct vy_lsm_stat { + /** Number of lookups in the LSM tree. */ int64_t lookup; - /** Number of statements read from this index. */ + /** Number of statements read from this LSM tree. */ struct vy_stmt_counter get; - /** Number of statements written to this index. */ + /** Number of statements written to this LSM tree. */ struct vy_stmt_counter put; /** Read latency. */ struct latency latency; @@ -187,13 +187,13 @@ struct vy_tx_stat { }; static inline int -vy_index_stat_create(struct vy_index_stat *stat) +vy_lsm_stat_create(struct vy_lsm_stat *stat) { return latency_create(&stat->latency); } static inline void -vy_index_stat_destroy(struct vy_index_stat *stat) +vy_lsm_stat_destroy(struct vy_lsm_stat *stat) { latency_destroy(&stat->latency); } diff --git a/src/box/vy_tx.c b/src/box/vy_tx.c index 1b583240..ed423ba3 100644 --- a/src/box/vy_tx.c +++ b/src/box/vy_tx.c @@ -50,7 +50,7 @@ #include "trivia/util.h" #include "tuple.h" #include "vy_cache.h" -#include "vy_index.h" +#include "vy_lsm.h" #include "vy_mem.h" #include "vy_stat.h" #include "vy_stmt.h" @@ -61,18 +61,18 @@ int write_set_cmp(struct txv *a, struct txv *b) { - int rc = a->index < b->index ? -1 : a->index > b->index; + int rc = a->lsm < b->lsm ? -1 : a->lsm > b->lsm; if (rc == 0) - return vy_tuple_compare(a->stmt, b->stmt, a->index->cmp_def); + return vy_tuple_compare(a->stmt, b->stmt, a->lsm->cmp_def); return rc; } int write_set_key_cmp(struct write_set_key *a, struct txv *b) { - int rc = a->index < b->index ? -1 : a->index > b->index; + int rc = a->lsm < b->lsm ? -1 : a->lsm > b->lsm; if (rc == 0) - return vy_stmt_compare(a->stmt, b->stmt, a->index->cmp_def); + return vy_stmt_compare(a->stmt, b->stmt, a->lsm->cmp_def); return rc; } @@ -204,7 +204,7 @@ tx_manager_vlsn(struct tx_manager *xm) } static struct txv * -txv_new(struct vy_tx *tx, struct vy_index *index, struct tuple *stmt) +txv_new(struct vy_tx *tx, struct vy_lsm *lsm, struct tuple *stmt) { struct tx_manager *xm = tx->xm; struct txv *v = mempool_alloc(&xm->txv_mempool); @@ -212,8 +212,8 @@ txv_new(struct vy_tx *tx, struct vy_index *index, struct tuple *stmt) diag_set(OutOfMemory, sizeof(*v), "mempool", "struct txv"); return NULL; } - v->index = index; - vy_index_ref(v->index); + v->lsm = lsm; + vy_lsm_ref(v->lsm); v->mem = NULL; v->stmt = stmt; tuple_ref(stmt); @@ -232,12 +232,12 @@ txv_delete(struct txv *v) struct tx_manager *xm = v->tx->xm; xm->write_set_size -= tuple_size(v->stmt); tuple_unref(v->stmt); - vy_index_unref(v->index); + vy_lsm_unref(v->lsm); mempool_free(&xm->txv_mempool, v); } static struct vy_read_interval * -vy_read_interval_new(struct vy_tx *tx, struct vy_index *index, +vy_read_interval_new(struct vy_tx *tx, struct vy_lsm *lsm, struct tuple *left, bool left_belongs, struct tuple *right, bool right_belongs) { @@ -250,8 +250,8 @@ vy_read_interval_new(struct vy_tx *tx, struct vy_index *index, return NULL; } interval->tx = tx; - vy_index_ref(index); - interval->index = index; + vy_lsm_ref(lsm); + interval->lsm = lsm; tuple_ref(left); interval->left = left; interval->left_belongs = left_belongs; @@ -272,7 +272,7 @@ vy_read_interval_delete(struct vy_read_interval *interval) xm->read_set_size -= tuple_size(interval->left); if (interval->left != interval->right) xm->read_set_size -= tuple_size(interval->right); - vy_index_unref(interval->index); + vy_lsm_unref(interval->lsm); tuple_unref(interval->left); tuple_unref(interval->right); mempool_free(&xm->read_interval_mempool, interval); @@ -284,7 +284,7 @@ vy_tx_read_set_free_cb(vy_tx_read_set_t *read_set, { (void)arg; (void)read_set; - vy_index_read_set_remove(&interval->index->read_set, interval); + vy_lsm_read_set_remove(&interval->lsm->read_set, interval); vy_read_interval_delete(interval); return NULL; } @@ -314,7 +314,7 @@ vy_tx_destroy(struct vy_tx *tx) struct txv *v, *tmp; stailq_foreach_entry_safe(v, tmp, &tx->log, next_in_log) { - vy_stmt_counter_unacct_tuple(&v->index->stat.txw.count, + vy_stmt_counter_unacct_tuple(&v->lsm->stat.txw.count, v->stmt); txv_delete(v); } @@ -344,7 +344,7 @@ static int vy_tx_send_to_read_view(struct vy_tx *tx, struct txv *v) { struct vy_tx_conflict_iterator it; - vy_tx_conflict_iterator_init(&it, &v->index->read_set, v->stmt); + vy_tx_conflict_iterator_init(&it, &v->lsm->read_set, v->stmt); struct vy_tx *abort; while ((abort = vy_tx_conflict_iterator_next(&it)) != NULL) { /* Don't abort self. */ @@ -372,7 +372,7 @@ static void vy_tx_abort_readers(struct vy_tx *tx, struct txv *v) { struct vy_tx_conflict_iterator it; - vy_tx_conflict_iterator_init(&it, &v->index->read_set, v->stmt); + vy_tx_conflict_iterator_init(&it, &v->lsm->read_set, v->stmt); struct vy_tx *abort; while ((abort = vy_tx_conflict_iterator_next(&it)) != NULL) { /* Don't abort self. */ @@ -404,7 +404,7 @@ vy_tx_begin(struct tx_manager *xm) static int vy_tx_write_prepare(struct txv *v) { - struct vy_index *index = v->index; + struct vy_lsm *lsm = v->lsm; /* * Allocate a new in-memory tree if either of the following @@ -418,21 +418,21 @@ vy_tx_write_prepare(struct txv *v) * We have to seal the tree, because we don't support mixing * statements of different formats in the same tree. */ - if (unlikely(index->mem->schema_version != schema_version || - index->mem->generation != *index->env->p_generation)) { - if (vy_index_rotate_mem(index) != 0) + if (unlikely(lsm->mem->schema_version != schema_version || + lsm->mem->generation != *lsm->env->p_generation)) { + if (vy_lsm_rotate_mem(lsm) != 0) return -1; } - vy_mem_pin(index->mem); - v->mem = index->mem; + vy_mem_pin(lsm->mem); + v->mem = lsm->mem; return 0; } /** - * Write a single statement into an index. If the statement has + * Write a single statement into an LSM tree. If the statement has * an lsregion copy then use it, else create it. * - * @param index Index to write to. + * @param lsm LSM tree to write to. * @param mem In-memory tree to write to. * @param stmt Statement allocated with malloc(). * @param region_stmt NULL or the same statement as stmt, @@ -442,7 +442,7 @@ vy_tx_write_prepare(struct txv *v) * @retval -1 Memory error. */ static int -vy_tx_write(struct vy_index *index, struct vy_mem *mem, +vy_tx_write(struct vy_lsm *lsm, struct vy_mem *mem, struct tuple *stmt, const struct tuple **region_stmt) { assert(vy_stmt_is_refable(stmt)); @@ -458,7 +458,7 @@ vy_tx_write(struct vy_index *index, struct vy_mem *mem, if (vy_stmt_type(stmt) == IPROTO_UPSERT) { struct tuple *deleted = NULL; /* Invalidate cache element. */ - vy_cache_on_write(&index->cache, stmt, &deleted); + vy_cache_on_write(&lsm->cache, stmt, &deleted); if (deleted != NULL) { struct tuple *applied = vy_apply_upsert(stmt, deleted, mem->cmp_def, @@ -467,8 +467,8 @@ vy_tx_write(struct vy_index *index, struct vy_mem *mem, tuple_unref(deleted); if (applied != NULL) { assert(vy_stmt_type(applied) == IPROTO_REPLACE); - int rc = vy_index_set(index, mem, applied, - region_stmt); + int rc = vy_lsm_set(lsm, mem, applied, + region_stmt); tuple_unref(applied); return rc; } @@ -479,9 +479,9 @@ vy_tx_write(struct vy_index *index, struct vy_mem *mem, } } else { /* Invalidate cache element. */ - vy_cache_on_write(&index->cache, stmt, NULL); + vy_cache_on_write(&lsm->cache, stmt, NULL); } - return vy_index_set(index, mem, stmt, region_stmt); + return vy_lsm_set(lsm, mem, stmt, region_stmt); } int @@ -517,21 +517,21 @@ vy_tx_prepare(struct vy_tx *tx) } /* - * Flush transactional changes to the index. + * Flush transactional changes to the LSM tree. * Sic: the loop below must not yield after recovery. */ /* repsert - REPLACE/UPSERT */ const struct tuple *delete = NULL, *repsert = NULL; MAYBE_UNUSED uint32_t current_space_id = 0; stailq_foreach_entry(v, &tx->log, next_in_log) { - struct vy_index *index = v->index; - if (index->index_id == 0) { + struct vy_lsm *lsm = v->lsm; + if (lsm->index_id == 0) { /* The beginning of the new txn_stmt is met. */ - current_space_id = index->space_id; + current_space_id = lsm->space_id; repsert = NULL; delete = NULL; } - assert(index->space_id == current_space_id); + assert(lsm->space_id == current_space_id); /* Do not save statements that was overwritten by the same tx */ if (v->is_overwritten) @@ -570,7 +570,7 @@ vy_tx_prepare(struct vy_tx *tx) vy_stmt_set_lsn(v->stmt, MAX_LSN + tx->psn); const struct tuple **region_stmt = (type == IPROTO_DELETE) ? &delete : &repsert; - if (vy_tx_write(index, v->mem, v->stmt, region_stmt) != 0) + if (vy_tx_write(lsm, v->mem, v->stmt, region_stmt) != 0) return -1; v->region_stmt = *region_stmt; } @@ -600,7 +600,7 @@ vy_tx_commit(struct vy_tx *tx, int64_t lsn) stailq_foreach_entry(v, &tx->log, next_in_log) { if (v->region_stmt != NULL) { vy_stmt_set_lsn((struct tuple *)v->region_stmt, lsn); - vy_index_commit_stmt(v->index, v->mem, v->region_stmt); + vy_lsm_commit_stmt(v->lsm, v->mem, v->region_stmt); } if (v->mem != NULL) vy_mem_unpin(v->mem); @@ -645,8 +645,8 @@ vy_tx_rollback_after_prepare(struct vy_tx *tx) struct txv *v; stailq_foreach_entry(v, &tx->log, next_in_log) { if (v->region_stmt != NULL) - vy_index_rollback_stmt(v->index, v->mem, - v->region_stmt); + vy_lsm_rollback_stmt(v->lsm, v->mem, + v->region_stmt); if (v->mem != NULL) vy_mem_unpin(v->mem); } @@ -699,7 +699,7 @@ vy_tx_rollback_to_savepoint(struct vy_tx *tx, void *svp) } int -vy_tx_track(struct vy_tx *tx, struct vy_index *index, +vy_tx_track(struct vy_tx *tx, struct vy_lsm *lsm, struct tuple *left, bool left_belongs, struct tuple *right, bool right_belongs) { @@ -709,7 +709,7 @@ vy_tx_track(struct vy_tx *tx, struct vy_index *index, } struct vy_read_interval *new_interval; - new_interval = vy_read_interval_new(tx, index, left, left_belongs, + new_interval = vy_read_interval_new(tx, lsm, left, left_belongs, right, right_belongs); if (new_interval == NULL) return -1; @@ -725,7 +725,7 @@ vy_tx_track(struct vy_tx *tx, struct vy_index *index, struct vy_read_interval *interval; interval = vy_tx_read_set_inext(&it); - if (interval != NULL && interval->index == index) { + if (interval != NULL && interval->lsm == lsm) { if (vy_read_interval_cmpr(interval, new_interval) >= 0) { /* * There is an interval in the tree spanning @@ -742,13 +742,13 @@ vy_tx_track(struct vy_tx *tx, struct vy_index *index, vy_tx_read_set_isearch_gt(&tx->read_set, new_interval, &it); while ((interval = vy_tx_read_set_inext(&it)) != NULL && - interval->index == index && + interval->lsm == lsm && vy_read_interval_should_merge(new_interval, interval)) stailq_add_tail_entry(&merge, interval, in_merge); /* * Merge intersecting intervals with the new interval and - * remove them from the transaction and index read sets. + * remove them from the transaction and LSM tree read sets. */ if (!stailq_empty(&merge)) { interval = stailq_first_entry(&merge, struct vy_read_interval, @@ -771,38 +771,37 @@ vy_tx_track(struct vy_tx *tx, struct vy_index *index, stailq_foreach_entry_safe(interval, next_interval, &merge, in_merge) { vy_tx_read_set_remove(&tx->read_set, interval); - vy_index_read_set_remove(&index->read_set, interval); + vy_lsm_read_set_remove(&lsm->read_set, interval); vy_read_interval_delete(interval); } } vy_tx_read_set_insert(&tx->read_set, new_interval); - vy_index_read_set_insert(&index->read_set, new_interval); + vy_lsm_read_set_insert(&lsm->read_set, new_interval); return 0; } int -vy_tx_track_point(struct vy_tx *tx, struct vy_index *index, - struct tuple *stmt) +vy_tx_track_point(struct vy_tx *tx, struct vy_lsm *lsm, struct tuple *stmt) { - assert(tuple_field_count(stmt) >= index->cmp_def->part_count); + assert(tuple_field_count(stmt) >= lsm->cmp_def->part_count); if (vy_tx_is_in_read_view(tx)) { /* No point in tracking reads. */ return 0; } - struct txv *v = write_set_search_key(&tx->write_set, index, stmt); + struct txv *v = write_set_search_key(&tx->write_set, lsm, stmt); if (v != NULL && vy_stmt_type(v->stmt) != IPROTO_UPSERT) { /* Reading from own write set is serializable. */ return 0; } - return vy_tx_track(tx, index, stmt, true, stmt, true); + return vy_tx_track(tx, lsm, stmt, true, stmt, true); } int -vy_tx_set(struct vy_tx *tx, struct vy_index *index, struct tuple *stmt) +vy_tx_set(struct vy_tx *tx, struct vy_lsm *lsm, struct tuple *stmt) { assert(vy_stmt_type(stmt) != 0); /** @@ -812,11 +811,10 @@ vy_tx_set(struct vy_tx *tx, struct vy_index *index, struct tuple *stmt) vy_stmt_set_lsn(stmt, INT64_MAX); struct tuple *applied = NULL; - /* Update concurrent index */ - struct txv *old = write_set_search_key(&tx->write_set, index, stmt); + struct txv *old = write_set_search_key(&tx->write_set, lsm, stmt); /* Found a match of the previous action of this transaction */ if (old != NULL && vy_stmt_type(stmt) == IPROTO_UPSERT) { - assert(index->index_id == 0); + assert(lsm->index_id == 0); uint8_t old_type = vy_stmt_type(old->stmt); assert(old_type == IPROTO_UPSERT || old_type == IPROTO_INSERT || @@ -824,19 +822,19 @@ vy_tx_set(struct vy_tx *tx, struct vy_index *index, struct tuple *stmt) old_type == IPROTO_DELETE); (void) old_type; - applied = vy_apply_upsert(stmt, old->stmt, index->cmp_def, - index->mem_format, - index->upsert_format, true); - index->stat.upsert.applied++; + applied = vy_apply_upsert(stmt, old->stmt, lsm->cmp_def, + lsm->mem_format, + lsm->upsert_format, true); + lsm->stat.upsert.applied++; if (applied == NULL) return -1; stmt = applied; assert(vy_stmt_type(stmt) != 0); - index->stat.upsert.squashed++; + lsm->stat.upsert.squashed++; } /* Allocate a MVCC container. */ - struct txv *v = txv_new(tx, index, stmt); + struct txv *v = txv_new(tx, lsm, stmt); if (applied != NULL) tuple_unref(applied); if (v == NULL) @@ -869,7 +867,7 @@ vy_tx_set(struct vy_tx *tx, struct vy_index *index, struct tuple *stmt) write_set_insert(&tx->write_set, v); tx->write_set_version++; tx->write_size += tuple_size(stmt); - vy_stmt_counter_acct_tuple(&index->stat.txw.count, stmt); + vy_stmt_counter_acct_tuple(&lsm->stat.txw.count, stmt); stailq_add_tail_entry(&tx->log, v, next_in_log); return 0; } @@ -877,13 +875,13 @@ vy_tx_set(struct vy_tx *tx, struct vy_index *index, struct tuple *stmt) void vy_txw_iterator_open(struct vy_txw_iterator *itr, struct vy_txw_iterator_stat *stat, - struct vy_tx *tx, struct vy_index *index, + struct vy_tx *tx, struct vy_lsm *lsm, enum iterator_type iterator_type, const struct tuple *key) { itr->stat = stat; itr->tx = tx; - itr->index = index; + itr->lsm = lsm; itr->iterator_type = iterator_type; itr->key = key; itr->version = UINT32_MAX; @@ -904,8 +902,8 @@ vy_txw_iterator_seek(struct vy_txw_iterator *itr, itr->stat->lookup++; itr->version = itr->tx->write_set_version; itr->curr_txv = NULL; - struct vy_index *index = itr->index; - struct write_set_key k = { index, key }; + struct vy_lsm *lsm = itr->lsm; + struct write_set_key k = { lsm, key }; struct txv *txv; if (tuple_field_count(key) > 0) { if (iterator_type == ITER_EQ) @@ -914,9 +912,9 @@ vy_txw_iterator_seek(struct vy_txw_iterator *itr, txv = write_set_nsearch(&itr->tx->write_set, &k); else txv = write_set_psearch(&itr->tx->write_set, &k); - if (txv == NULL || txv->index != index) + if (txv == NULL || txv->lsm != lsm) return; - if (vy_stmt_compare(key, txv->stmt, index->cmp_def) == 0) { + if (vy_stmt_compare(key, txv->stmt, lsm->cmp_def) == 0) { while (true) { struct txv *next; if (iterator_type == ITER_LE || @@ -924,10 +922,10 @@ vy_txw_iterator_seek(struct vy_txw_iterator *itr, next = write_set_next(&itr->tx->write_set, txv); else next = write_set_prev(&itr->tx->write_set, txv); - if (next == NULL || next->index != index) + if (next == NULL || next->lsm != lsm) break; if (vy_stmt_compare(key, next->stmt, - index->cmp_def) != 0) + lsm->cmp_def) != 0) break; txv = next; } @@ -942,7 +940,7 @@ vy_txw_iterator_seek(struct vy_txw_iterator *itr, assert(iterator_type == ITER_GE); txv = write_set_psearch(&itr->tx->write_set, &k); } - if (txv == NULL || txv->index != index) + if (txv == NULL || txv->lsm != lsm) return; itr->curr_txv = txv; } @@ -963,11 +961,11 @@ vy_txw_iterator_next(struct vy_txw_iterator *itr, struct tuple **ret) itr->curr_txv = write_set_prev(&itr->tx->write_set, itr->curr_txv); else itr->curr_txv = write_set_next(&itr->tx->write_set, itr->curr_txv); - if (itr->curr_txv != NULL && itr->curr_txv->index != itr->index) + if (itr->curr_txv != NULL && itr->curr_txv->lsm != itr->lsm) itr->curr_txv = NULL; if (itr->curr_txv != NULL && itr->iterator_type == ITER_EQ && vy_stmt_compare(itr->key, itr->curr_txv->stmt, - itr->index->cmp_def) != 0) + itr->lsm->cmp_def) != 0) itr->curr_txv = NULL; out: if (itr->curr_txv != NULL) { @@ -992,7 +990,7 @@ vy_txw_iterator_skip(struct vy_txw_iterator *itr, (itr->curr_txv == NULL || last_stmt == NULL || iterator_direction(itr->iterator_type) * vy_tuple_compare(itr->curr_txv->stmt, last_stmt, - itr->index->cmp_def) > 0)) { + itr->lsm->cmp_def) > 0)) { if (itr->curr_txv != NULL) *ret = itr->curr_txv->stmt; return; @@ -1011,7 +1009,7 @@ vy_txw_iterator_skip(struct vy_txw_iterator *itr, if (itr->iterator_type == ITER_EQ && last_stmt != NULL && itr->curr_txv != NULL && vy_stmt_compare(itr->key, - itr->curr_txv->stmt, itr->index->cmp_def) != 0) + itr->curr_txv->stmt, itr->lsm->cmp_def) != 0) itr->curr_txv = NULL; if (itr->curr_txv != NULL) { @@ -1040,7 +1038,7 @@ vy_txw_iterator_restore(struct vy_txw_iterator *itr, if (itr->iterator_type == ITER_EQ && itr->curr_txv != NULL && vy_stmt_compare(itr->key, itr->curr_txv->stmt, - itr->index->cmp_def) != 0) + itr->lsm->cmp_def) != 0) itr->curr_txv = NULL; if (prev_txv == itr->curr_txv) diff --git a/src/box/vy_tx.h b/src/box/vy_tx.h index 33238ed7..a59145be 100644 --- a/src/box/vy_tx.h +++ b/src/box/vy_tx.h @@ -42,7 +42,7 @@ #include "iterator_type.h" #include "salad/stailq.h" #include "trivia/util.h" -#include "vy_index.h" +#include "vy_lsm.h" #include "vy_stat.h" #include "vy_read_set.h" #include "vy_read_view.h" @@ -76,8 +76,8 @@ enum tx_state { struct txv { /** Transaction. */ struct vy_tx *tx; - /** Index this operation is for. */ - struct vy_index *index; + /** LSM tree this operation is for. */ + struct vy_lsm *lsm; /** In-memory tree to insert the statement into. */ struct vy_mem *mem; /** Statement of this operation. */ @@ -106,10 +106,10 @@ struct txv { /** * Index of all modifications made by a transaction. - * Ordered by index, then by key in the index. + * Ordered by LSM tree, then by key. */ struct write_set_key { - struct vy_index *index; + struct vy_lsm *lsm; const struct tuple *stmt; }; @@ -123,10 +123,10 @@ rb_gen_ext_key(MAYBE_UNUSED static inline, write_set_, write_set_t, struct txv, in_set, write_set_cmp, struct write_set_key *, write_set_key_cmp); static inline struct txv * -write_set_search_key(write_set_t *tree, struct vy_index *index, +write_set_search_key(write_set_t *tree, struct vy_lsm *lsm, const struct tuple *stmt) { - struct write_set_key key = { .index = index, .stmt = stmt }; + struct write_set_key key = { .lsm = lsm, .stmt = stmt }; return write_set_search(tree, &key); } @@ -141,7 +141,7 @@ struct vy_tx { struct stailq log; /** * Writes of the transaction segregated by the changed - * vy_index object. + * vy_lsm object. */ write_set_t write_set; /** @@ -326,7 +326,7 @@ vy_tx_rollback_to_savepoint(struct vy_tx *tx, void *svp); * to will be aborted. * * @param tx Transaction that invoked the read. - * @param index Index that was read from. + * @param lsm LSM tree that was read from. * @param left Left boundary of the read interval. * @param left_belongs Set if the left boundary belongs to * the interval. @@ -338,7 +338,7 @@ vy_tx_rollback_to_savepoint(struct vy_tx *tx, void *svp); * @retval -1 Memory error. */ int -vy_tx_track(struct vy_tx *tx, struct vy_index *index, +vy_tx_track(struct vy_tx *tx, struct vy_lsm *lsm, struct tuple *left, bool left_belongs, struct tuple *right, bool right_belongs); @@ -346,7 +346,7 @@ vy_tx_track(struct vy_tx *tx, struct vy_index *index, * Remember a point read in the conflict manager index. * * @param tx Transaction that invoked the read. - * @param index Index that was read from. + * @param lsm LSM tree that was read from. * @param stmt Key that was read. * * @retval 0 Success. @@ -359,12 +359,11 @@ vy_tx_track(struct vy_tx *tx, struct vy_index *index, * transaction read it from its own write set. */ int -vy_tx_track_point(struct vy_tx *tx, struct vy_index *index, - struct tuple *stmt); +vy_tx_track_point(struct vy_tx *tx, struct vy_lsm *lsm, struct tuple *stmt); /** Add a statement to a transaction. */ int -vy_tx_set(struct vy_tx *tx, struct vy_index *index, struct tuple *stmt); +vy_tx_set(struct vy_tx *tx, struct vy_lsm *lsm, struct tuple *stmt); /** * Iterator over the write set of a transaction. @@ -374,8 +373,8 @@ struct vy_txw_iterator { struct vy_txw_iterator_stat *stat; /** Transaction whose write set is iterated. */ struct vy_tx *tx; - /** Index of interest. */ - struct vy_index *index; + /** LSM tree of interest. */ + struct vy_lsm *lsm; /** * Iterator type. * @@ -399,7 +398,7 @@ struct vy_txw_iterator { void vy_txw_iterator_open(struct vy_txw_iterator *itr, struct vy_txw_iterator_stat *stat, - struct vy_tx *tx, struct vy_index *index, + struct vy_tx *tx, struct vy_lsm *lsm, enum iterator_type iterator_type, const struct tuple *key); diff --git a/test/unit/CMakeLists.txt b/test/unit/CMakeLists.txt index 943788b9..7e1c95ed 100644 --- a/test/unit/CMakeLists.txt +++ b/test/unit/CMakeLists.txt @@ -160,7 +160,7 @@ add_executable(vy_point_lookup.test ${PROJECT_SOURCE_DIR}/src/box/vy_tx.c ${PROJECT_SOURCE_DIR}/src/box/vy_read_set.c ${PROJECT_SOURCE_DIR}/src/box/vy_upsert.c - ${PROJECT_SOURCE_DIR}/src/box/vy_index.c + ${PROJECT_SOURCE_DIR}/src/box/vy_lsm.c ${PROJECT_SOURCE_DIR}/src/box/vy_cache.c ${PROJECT_SOURCE_DIR}/src/box/index_def.c ${PROJECT_SOURCE_DIR}/src/box/schema_def.c diff --git a/test/unit/vy_log_stub.c b/test/unit/vy_log_stub.c index 7cfaff84..d4668408 100644 --- a/test/unit/vy_log_stub.c +++ b/test/unit/vy_log_stub.c @@ -51,9 +51,9 @@ vy_log_tx_commit(void) void vy_log_write(const struct vy_log_record *record) {} -struct vy_index_recovery_info * -vy_recovery_index_by_id(struct vy_recovery *recovery, - uint32_t space_id, uint32_t index_id) +struct vy_lsm_recovery_info * +vy_recovery_lsm_by_index_id(struct vy_recovery *recovery, + uint32_t space_id, uint32_t index_id) { unreachable(); } diff --git a/test/unit/vy_point_lookup.c b/test/unit/vy_point_lookup.c index 30a61040..ec9b214e 100644 --- a/test/unit/vy_point_lookup.c +++ b/test/unit/vy_point_lookup.c @@ -1,6 +1,6 @@ #include "trivia/util.h" #include "unit.h" -#include "vy_index.h" +#include "vy_lsm.h" #include "vy_cache.h" #include "vy_run.h" #include "fiber.h" @@ -15,12 +15,12 @@ uint32_t schema_version; static int write_run(struct vy_run *run, const char *dir_name, - struct vy_index *index, struct vy_stmt_stream *wi) + struct vy_lsm *lsm, struct vy_stmt_stream *wi) { struct vy_run_writer writer; if (vy_run_writer_create(&writer, run, dir_name, - index->space_id, index->index_id, - index->cmp_def, index->key_def, + lsm->space_id, lsm->index_id, + lsm->cmp_def, lsm->key_def, 4096, 0.1, 100500) != 0) goto fail; @@ -62,10 +62,9 @@ test_basic() struct slab_cache *slab_cache = cord_slab_cache(); int rc; - struct vy_index_env index_env; - rc = vy_index_env_create(&index_env, ".", &generation, - NULL, NULL); - is(rc, 0, "vy_index_env_create"); + struct vy_lsm_env lsm_env; + rc = vy_lsm_env_create(&lsm_env, ".", &generation, NULL, NULL); + is(rc, 0, "vy_lsm_env_create"); struct vy_run_env run_env; vy_run_env_create(&run_env); @@ -92,14 +91,14 @@ test_basic() index_def_new(512, 0, "primary", sizeof("primary") - 1, TREE, &index_opts, key_def, NULL); - struct vy_index *pk = vy_index_new(&index_env, &cache_env, &mem_env, - index_def, format, NULL); - isnt(pk, NULL, "index is not NULL") + struct vy_lsm *pk = vy_lsm_new(&lsm_env, &cache_env, &mem_env, + index_def, format, NULL); + isnt(pk, NULL, "lsm is not NULL") struct vy_range *range = vy_range_new(1, NULL, NULL, pk->cmp_def); isnt(pk, NULL, "range is not NULL") - vy_index_add_range(pk, range); + vy_lsm_add_range(pk, range); struct rlist read_views = RLIST_HEAD_INITIALIZER(read_views); @@ -115,7 +114,7 @@ test_basic() rc = mkdir(path, 0777); is(rc, 0, "temp dir create (3)"); - /* Filling the index with test data */ + /* Filling the LSM tree with test data */ /* Prepare variants */ const size_t num_of_keys = 100; bool in_mem1[num_of_keys]; /* UPSERT value += 1, lsn 4 */ @@ -161,8 +160,8 @@ test_basic() vy_mem_insert_template(pk->mem, &tmpl_val); } - rc = vy_index_rotate_mem(pk); - is(rc, 0, "vy_index_rotate_mem"); + rc = vy_lsm_rotate_mem(pk); + is(rc, 0, "vy_lsm_rotate_mem"); /* create first mem */ for (size_t i = 0; i < num_of_keys; i++) { @@ -205,7 +204,7 @@ test_basic() write_stream->iface->close(write_stream); vy_mem_delete(run_mem); - vy_index_add_run(pk, run); + vy_lsm_add_run(pk, run); struct vy_slice *slice = vy_slice_new(1, run, NULL, NULL, pk->cmp_def); vy_range_add_slice(range, slice); vy_run_unref(run); @@ -240,7 +239,7 @@ test_basic() write_stream->iface->close(write_stream); vy_mem_delete(run_mem); - vy_index_add_run(pk, run); + vy_lsm_add_run(pk, run); slice = vy_slice_new(1, run, NULL, NULL, pk->cmp_def); vy_range_add_slice(range, slice); vy_run_unref(run); @@ -308,14 +307,14 @@ test_basic() is(results_ok, true, "select results"); is(has_errors, false, "no errors happened"); - vy_index_unref(pk); + vy_lsm_unref(pk); index_def_delete(index_def); tuple_format_unref(format); vy_cache_destroy(&cache); key_def_delete(key_def); vy_cache_env_destroy(&cache_env); vy_run_env_destroy(&run_env); - vy_index_env_destroy(&index_env); + vy_lsm_env_destroy(&lsm_env); strcpy(path, "rm -rf "); strcat(path, dir_name); diff --git a/test/unit/vy_point_lookup.result b/test/unit/vy_point_lookup.result index 6b8dcdef..4e68dda6 100644 --- a/test/unit/vy_point_lookup.result +++ b/test/unit/vy_point_lookup.result @@ -1,15 +1,15 @@ 1..1 *** test_basic *** 1..15 - ok 1 - vy_index_env_create + ok 1 - vy_lsm_env_create ok 2 - key_def is not NULL ok 3 - tuple_format_new is not NULL - ok 4 - index is not NULL + ok 4 - lsm is not NULL ok 5 - range is not NULL ok 6 - temp dir name is not NULL ok 7 - temp dir create (2) ok 8 - temp dir create (3) - ok 9 - vy_index_rotate_mem + ok 9 - vy_lsm_rotate_mem ok 10 - vy_run_new ok 11 - vy_run_write ok 12 - vy_run_new -- 2.11.0