[PATCH 4/8] memtx: move all global variables to engine
Vladimir Davydov
vdavydov.dev at gmail.com
Tue May 22 14:46:12 MSK 2018
All functions that need them are now explicitly passed engine so we can
consolidate all variables related to memtx engine state in one place.
---
src/box/lua/slab.c | 35 ++++++++-------
src/box/memtx_engine.c | 114 ++++++++++++++++---------------------------------
src/box/memtx_engine.h | 32 ++++++++++++++
3 files changed, 89 insertions(+), 92 deletions(-)
diff --git a/src/box/lua/slab.c b/src/box/lua/slab.c
index 1367a4eb..9f5e7e95 100644
--- a/src/box/lua/slab.c
+++ b/src/box/lua/slab.c
@@ -41,9 +41,8 @@
#include "small/small.h"
#include "small/quota.h"
#include "memory.h"
-
-extern struct small_alloc memtx_alloc;
-extern struct mempool memtx_index_extent_pool;
+#include "box/engine.h"
+#include "box/memtx_engine.h"
static int
small_stats_noop_cb(const struct mempool_stats *stats, void *cb_ctx)
@@ -106,15 +105,18 @@ small_stats_lua_cb(const struct mempool_stats *stats, void *cb_ctx)
static int
lbox_slab_stats(struct lua_State *L)
{
+ struct memtx_engine *memtx;
+ memtx = (struct memtx_engine *)engine_by_name("memtx");
+
struct small_stats totals;
lua_newtable(L);
/*
* List all slabs used for tuples and slabs used for
* indexes, with their stats.
*/
- small_stats(&memtx_alloc, &totals, small_stats_lua_cb, L);
+ small_stats(&memtx->alloc, &totals, small_stats_lua_cb, L);
struct mempool_stats index_stats;
- mempool_stats(&memtx_index_extent_pool, &index_stats);
+ mempool_stats(&memtx->index_extent_pool, &index_stats);
small_stats_lua_cb(&index_stats, L);
return 1;
@@ -123,6 +125,9 @@ lbox_slab_stats(struct lua_State *L)
static int
lbox_slab_info(struct lua_State *L)
{
+ struct memtx_engine *memtx;
+ memtx = (struct memtx_engine *)engine_by_name("memtx");
+
struct small_stats totals;
/*
@@ -130,12 +135,10 @@ lbox_slab_info(struct lua_State *L)
* indexes, with their stats.
*/
lua_newtable(L);
- small_stats(&memtx_alloc, &totals, small_stats_noop_cb, L);
+ small_stats(&memtx->alloc, &totals, small_stats_noop_cb, L);
struct mempool_stats index_stats;
- mempool_stats(&memtx_index_extent_pool, &index_stats);
+ mempool_stats(&memtx->index_extent_pool, &index_stats);
- struct slab_arena *tuple_arena = memtx_alloc.cache->arena;
- struct quota *memtx_quota = tuple_arena->quota;
double ratio;
char ratio_buf[32];
@@ -176,7 +179,7 @@ lbox_slab_info(struct lua_State *L)
* quota_used_ratio > 0.9 work as an indicator
* for reaching Tarantool memory limit.
*/
- size_t arena_size = tuple_arena->used;
+ size_t arena_size = memtx->arena.used;
luaL_pushuint64(L, arena_size);
lua_settable(L, -3);
/**
@@ -200,7 +203,7 @@ lbox_slab_info(struct lua_State *L)
* box.cfg.slab_alloc_arena, but in bytes
*/
lua_pushstring(L, "quota_size");
- luaL_pushuint64(L, quota_total(memtx_quota));
+ luaL_pushuint64(L, quota_total(&memtx->quota));
lua_settable(L, -3);
/*
@@ -208,7 +211,7 @@ lbox_slab_info(struct lua_State *L)
* size of slabs in various slab caches.
*/
lua_pushstring(L, "quota_used");
- luaL_pushuint64(L, quota_used(memtx_quota));
+ luaL_pushuint64(L, quota_used(&memtx->quota));
lua_settable(L, -3);
/**
@@ -217,8 +220,8 @@ lbox_slab_info(struct lua_State *L)
* factor, it's the quota that give you OOM error in the
* end of the day.
*/
- ratio = 100 * ((double) quota_used(memtx_quota) /
- ((double) quota_total(memtx_quota) + 0.0001));
+ ratio = 100 * ((double) quota_used(&memtx->quota) /
+ ((double) quota_total(&memtx->quota) + 0.0001));
snprintf(ratio_buf, sizeof(ratio_buf), "%0.2lf%%", ratio);
lua_pushstring(L, "quota_used_ratio");
@@ -254,7 +257,9 @@ lbox_runtime_info(struct lua_State *L)
static int
lbox_slab_check(MAYBE_UNUSED struct lua_State *L)
{
- slab_cache_check(memtx_alloc.cache);
+ struct memtx_engine *memtx;
+ memtx = (struct memtx_engine *)engine_by_name("memtx");
+ slab_cache_check(memtx->alloc.cache);
return 0;
}
diff --git a/src/box/memtx_engine.c b/src/box/memtx_engine.c
index 70478d75..b1a9b157 100644
--- a/src/box/memtx_engine.c
+++ b/src/box/memtx_engine.c
@@ -50,41 +50,6 @@
#include "schema.h"
#include "gc.h"
-/*
- * If you decide to use memtx_arena for anything other than
- * memtx_alloc or memtx_index_extent_pool, make sure this
- * is reflected in box.slab.info(), @sa lua/slab.c.
- */
-
-/** Common quota for memtx tuples and indexes. */
-static struct quota memtx_quota;
-/** Common slab arena for memtx tuples and indexes. */
-static struct slab_arena memtx_arena;
-/** Slab cache for allocating memtx tuples. */
-static struct slab_cache memtx_slab_cache;
-/** Memtx tuple allocator. */
-struct small_alloc memtx_alloc; /* used by box.slab.info() */
-/** Slab cache for allocating memtx index extents. */
-static struct slab_cache memtx_index_slab_cache;
-/** Memtx index extent allocator. */
-struct mempool memtx_index_extent_pool; /* used by box.slab.info() */
-
-/**
- * To ensure proper statement-level rollback in case
- * of out of memory conditions, we maintain a number
- * of slack memory extents reserved before a statement
- * is begun. If there isn't enough slack memory,
- * we don't begin the statement.
- */
-static int memtx_index_num_reserved_extents;
-static void *memtx_index_reserved_extents;
-
-/** Maximal allowed tuple size, box.cfg.memtx_max_tuple_size. */
-static size_t memtx_max_tuple_size = 1 * 1024 * 1024;
-
-/** Incremented with each next snapshot. */
-uint32_t snapshot_version;
-
static void
txn_on_yield_or_stop(struct trigger *trigger, void *event)
{
@@ -108,6 +73,7 @@ struct memtx_tuple {
enum {
OBJSIZE_MIN = 16,
SLAB_SIZE = 16 * 1024 * 1024,
+ MAX_TUPLE_SIZE = 1 * 1024 * 1024,
};
static int
@@ -701,8 +667,8 @@ memtx_engine_begin_checkpoint(struct engine *engine)
}
/* increment snapshot version; set tuple deletion to delayed mode */
- snapshot_version++;
- small_alloc_setopt(&memtx_alloc, SMALL_DELAYED_FREE_MODE, true);
+ memtx->snapshot_version++;
+ small_alloc_setopt(&memtx->alloc, SMALL_DELAYED_FREE_MODE, true);
return 0;
}
@@ -748,7 +714,7 @@ memtx_engine_commit_checkpoint(struct engine *engine, struct vclock *vclock)
/* waitCheckpoint() must have been done. */
assert(!memtx->checkpoint->waiting_for_snap_thread);
- small_alloc_setopt(&memtx_alloc, SMALL_DELAYED_FREE_MODE, false);
+ small_alloc_setopt(&memtx->alloc, SMALL_DELAYED_FREE_MODE, false);
if (!memtx->checkpoint->touch) {
int64_t lsn = vclock_sum(memtx->checkpoint->vclock);
@@ -791,7 +757,7 @@ memtx_engine_abort_checkpoint(struct engine *engine)
memtx->checkpoint->waiting_for_snap_thread = false;
}
- small_alloc_setopt(&memtx_alloc, SMALL_DELAYED_FREE_MODE, false);
+ small_alloc_setopt(&memtx->alloc, SMALL_DELAYED_FREE_MODE, false);
/** Remove garbage .inprogress file. */
char *filename =
@@ -915,11 +881,11 @@ small_stats_noop_cb(const struct mempool_stats *stats, void *cb_ctx)
static void
memtx_engine_memory_stat(struct engine *engine, struct engine_memory_stat *stat)
{
- (void)engine;
+ struct memtx_engine *memtx = (struct memtx_engine *)engine;
struct small_stats data_stats;
struct mempool_stats index_stats;
- mempool_stats(&memtx_index_extent_pool, &index_stats);
- small_stats(&memtx_alloc, &data_stats, small_stats_noop_cb, NULL);
+ mempool_stats(&memtx->index_extent_pool, &index_stats);
+ small_stats(&memtx->alloc, &data_stats, small_stats_noop_cb, NULL);
stat->data += data_stats.used;
stat->index += index_stats.totals.used;
}
@@ -1007,21 +973,22 @@ memtx_engine_new(const char *snap_dirname, bool force_recovery,
objsize_min = OBJSIZE_MIN;
/* Initialize tuple allocator. */
- quota_init(&memtx_quota, tuple_arena_max_size);
- tuple_arena_create(&memtx_arena, &memtx_quota, tuple_arena_max_size,
+ quota_init(&memtx->quota, tuple_arena_max_size);
+ tuple_arena_create(&memtx->arena, &memtx->quota, tuple_arena_max_size,
SLAB_SIZE, "memtx");
- slab_cache_create(&memtx_slab_cache, &memtx_arena);
- small_alloc_create(&memtx_alloc, &memtx_slab_cache,
+ slab_cache_create(&memtx->slab_cache, &memtx->arena);
+ small_alloc_create(&memtx->alloc, &memtx->slab_cache,
objsize_min, alloc_factor);
/* Initialize index extent allocator. */
- slab_cache_create(&memtx_index_slab_cache, &memtx_arena);
- mempool_create(&memtx_index_extent_pool, &memtx_index_slab_cache,
+ slab_cache_create(&memtx->index_slab_cache, &memtx->arena);
+ mempool_create(&memtx->index_extent_pool, &memtx->index_slab_cache,
MEMTX_EXTENT_SIZE);
- memtx_index_num_reserved_extents = 0;
- memtx_index_reserved_extents = NULL;
+ memtx->num_reserved_extents = 0;
+ memtx->reserved_extents = NULL;
memtx->state = MEMTX_INITIALIZED;
+ memtx->max_tuple_size = MAX_TUPLE_SIZE;
memtx->force_recovery = force_recovery;
memtx->base.vtab = &memtx_engine_vtab;
@@ -1052,15 +1019,13 @@ memtx_engine_set_snap_io_rate_limit(struct memtx_engine *memtx, double limit)
void
memtx_engine_set_max_tuple_size(struct memtx_engine *memtx, size_t max_size)
{
- (void)memtx;
- memtx_max_tuple_size = max_size;
+ memtx->max_tuple_size = max_size;
}
struct tuple *
memtx_tuple_new(struct tuple_format *format, const char *data, const char *end)
{
struct memtx_engine *memtx = (struct memtx_engine *)format->engine_data;
- (void)memtx;
assert(mp_typeof(*data) == MP_ARRAY);
size_t tuple_len = end - data;
size_t meta_size = tuple_format_meta_size(format);
@@ -1070,20 +1035,20 @@ memtx_tuple_new(struct tuple_format *format, const char *data, const char *end)
diag_set(OutOfMemory, total, "slab allocator", "memtx_tuple");
return NULL;
});
- if (unlikely(total > memtx_max_tuple_size)) {
+ if (unlikely(total > memtx->max_tuple_size)) {
diag_set(ClientError, ER_MEMTX_MAX_TUPLE_SIZE, total);
error_log(diag_last_error(diag_get()));
return NULL;
}
- struct memtx_tuple *memtx_tuple = smalloc(&memtx_alloc, total);
+ struct memtx_tuple *memtx_tuple = smalloc(&memtx->alloc, total);
if (memtx_tuple == NULL) {
diag_set(OutOfMemory, total, "slab allocator", "memtx_tuple");
return NULL;
}
struct tuple *tuple = &memtx_tuple->base;
tuple->refs = 0;
- memtx_tuple->version = snapshot_version;
+ memtx_tuple->version = memtx->snapshot_version;
assert(tuple_len <= UINT32_MAX); /* bsize is UINT32_MAX */
tuple->bsize = tuple_len;
tuple->format_id = tuple_format_id(format);
@@ -1109,7 +1074,6 @@ void
memtx_tuple_delete(struct tuple_format *format, struct tuple *tuple)
{
struct memtx_engine *memtx = (struct memtx_engine *)format->engine_data;
- (void)memtx;
say_debug("%s(%p)", __func__, tuple);
assert(tuple->refs == 0);
#ifndef NDEBUG
@@ -1126,11 +1090,11 @@ memtx_tuple_delete(struct tuple_format *format, struct tuple *tuple)
tuple_format_unref(format);
struct memtx_tuple *memtx_tuple =
container_of(tuple, struct memtx_tuple, base);
- if (memtx_alloc.free_mode != SMALL_DELAYED_FREE ||
- memtx_tuple->version == snapshot_version)
- smfree(&memtx_alloc, memtx_tuple, total);
+ if (memtx->alloc.free_mode != SMALL_DELAYED_FREE ||
+ memtx_tuple->version == memtx->snapshot_version)
+ smfree(&memtx->alloc, memtx_tuple, total);
else
- smfree_delayed(&memtx_alloc, memtx_tuple, total);
+ smfree_delayed(&memtx->alloc, memtx_tuple, total);
}
struct tuple_format_vtab memtx_tuple_format_vtab = {
@@ -1145,13 +1109,11 @@ void *
memtx_index_extent_alloc(void *ctx)
{
struct memtx_engine *memtx = (struct memtx_engine *)ctx;
- (void)memtx;
- if (memtx_index_reserved_extents) {
- assert(memtx_index_num_reserved_extents > 0);
- memtx_index_num_reserved_extents--;
- void *result = memtx_index_reserved_extents;
- memtx_index_reserved_extents = *(void **)
- memtx_index_reserved_extents;
+ if (memtx->reserved_extents) {
+ assert(memtx->num_reserved_extents > 0);
+ memtx->num_reserved_extents--;
+ void *result = memtx->reserved_extents;
+ memtx->reserved_extents = *(void **)memtx->reserved_extents;
return result;
}
ERROR_INJECT(ERRINJ_INDEX_ALLOC, {
@@ -1160,7 +1122,7 @@ memtx_index_extent_alloc(void *ctx)
"mempool", "new slab");
return NULL;
});
- void *ret = mempool_alloc(&memtx_index_extent_pool);
+ void *ret = mempool_alloc(&memtx->index_extent_pool);
if (ret == NULL)
diag_set(OutOfMemory, MEMTX_EXTENT_SIZE,
"mempool", "new slab");
@@ -1174,8 +1136,7 @@ void
memtx_index_extent_free(void *ctx, void *extent)
{
struct memtx_engine *memtx = (struct memtx_engine *)ctx;
- (void)memtx;
- return mempool_free(&memtx_index_extent_pool, extent);
+ return mempool_free(&memtx->index_extent_pool, extent);
}
/**
@@ -1185,23 +1146,22 @@ memtx_index_extent_free(void *ctx, void *extent)
int
memtx_index_extent_reserve(struct memtx_engine *memtx, int num)
{
- (void)memtx;
ERROR_INJECT(ERRINJ_INDEX_ALLOC, {
/* same error as in mempool_alloc */
diag_set(OutOfMemory, MEMTX_EXTENT_SIZE,
"mempool", "new slab");
return -1;
});
- while (memtx_index_num_reserved_extents < num) {
- void *ext = mempool_alloc(&memtx_index_extent_pool);
+ while (memtx->num_reserved_extents < num) {
+ void *ext = mempool_alloc(&memtx->index_extent_pool);
if (ext == NULL) {
diag_set(OutOfMemory, MEMTX_EXTENT_SIZE,
"mempool", "new slab");
return -1;
}
- *(void **)ext = memtx_index_reserved_extents;
- memtx_index_reserved_extents = ext;
- memtx_index_num_reserved_extents++;
+ *(void **)ext = memtx->reserved_extents;
+ memtx->reserved_extents = ext;
+ memtx->num_reserved_extents++;
}
return 0;
}
diff --git a/src/box/memtx_engine.h b/src/box/memtx_engine.h
index 389314ba..0bcd24ac 100644
--- a/src/box/memtx_engine.h
+++ b/src/box/memtx_engine.h
@@ -33,6 +33,8 @@
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
+#include <small/quota.h>
+#include <small/small.h>
#include <small/mempool.h>
#include "engine.h"
@@ -97,6 +99,36 @@ struct memtx_engine {
uint64_t snap_io_rate_limit;
/** Skip invalid snapshot records if this flag is set. */
bool force_recovery;
+ /** Common quota for tuples and indexes. */
+ struct quota quota;
+ /**
+ * Common slab arena for tuples and indexes.
+ * If you decide to use it for anything other than
+ * tuple_alloc or index_extent_pool, make sure this
+ * is reflected in box.slab.info(), @sa lua/slab.c.
+ */
+ struct slab_arena arena;
+ /** Slab cache for allocating tuples. */
+ struct slab_cache slab_cache;
+ /** Tuple allocator. */
+ struct small_alloc alloc;
+ /** Slab cache for allocating index extents. */
+ struct slab_cache index_slab_cache;
+ /** Index extent allocator. */
+ struct mempool index_extent_pool;
+ /**
+ * To ensure proper statement-level rollback in case
+ * of out of memory conditions, we maintain a number
+ * of slack memory extents reserved before a statement
+ * is begun. If there isn't enough slack memory,
+ * we don't begin the statement.
+ */
+ int num_reserved_extents;
+ void *reserved_extents;
+ /** Maximal allowed tuple size, box.cfg.memtx_max_tuple_size. */
+ size_t max_tuple_size;
+ /** Incremented with each next snapshot. */
+ uint32_t snapshot_version;
/** Memory pool for tree index iterator. */
struct mempool tree_iterator_pool;
/** Memory pool for rtree index iterator. */
--
2.11.0
More information about the Tarantool-patches
mailing list