Skip to content

M
mariadb
Commit 22e33283 authored by Yoni Fogel's avatar Yoni Fogel
Browse files
Options

refs #6286 Add 148 items to information schema.global_status 

git-svn-id: file:///svn/toku/tokudb@54507 c7de825b-a66e-492c-adef-691d508d4ae1
parent e8226b79
Hide whitespace changes
Inline Side-by-side
Showing with 150 additions and 150 deletions
ft/cachetable.cc
View file @ 22e33283
......@@ -47,20 +47,20 @@ status_init(void) {
// Note, this function initializes the keyname, type, and legend fields.
// Value fields are initialized to zero by compiler.
STATUS_INIT(CT_MISS, nullptr, UINT64, "miss", TOKU_ENGINE_STATUS);
STATUS_INIT(CT_MISSTIME, nullptr, UINT64, "miss time", TOKU_ENGINE_STATUS);
STATUS_INIT(CT_PREFETCHES, nullptr, UINT64, "prefetches", TOKU_ENGINE_STATUS);
STATUS_INIT(CT_SIZE_CURRENT, nullptr, UINT64, "size current", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(CT_SIZE_LIMIT, nullptr, UINT64, "size limit", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(CT_SIZE_WRITING, nullptr, UINT64, "size writing", TOKU_ENGINE_STATUS);
STATUS_INIT(CT_SIZE_NONLEAF, nullptr, UINT64, "size nonleaf", TOKU_ENGINE_STATUS);
STATUS_INIT(CT_SIZE_LEAF, nullptr, UINT64, "size leaf", TOKU_ENGINE_STATUS);
STATUS_INIT(CT_SIZE_ROLLBACK, nullptr, UINT64, "size rollback", TOKU_ENGINE_STATUS);
STATUS_INIT(CT_SIZE_CACHEPRESSURE, nullptr, UINT64, "size cachepressure", TOKU_ENGINE_STATUS);
STATUS_INIT(CT_EVICTIONS, nullptr, UINT64, "evictions", TOKU_ENGINE_STATUS);
STATUS_INIT(CT_CLEANER_EXECUTIONS, nullptr, UINT64, "cleaner executions", TOKU_ENGINE_STATUS);
STATUS_INIT(CT_CLEANER_PERIOD, nullptr, UINT64, "cleaner period", TOKU_ENGINE_STATUS);
STATUS_INIT(CT_CLEANER_ITERATIONS, nullptr, UINT64, "cleaner iterations", TOKU_ENGINE_STATUS);
STATUS_INIT(CT_MISS, TOKUDB_CACHETABLE_MISS, UINT64, "miss", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(CT_MISSTIME, TOKUDB_CACHETABLE_MISS_TIME, UINT64, "miss time", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(CT_PREFETCHES, TOKUDB_CACHETABLE_PREFETCHES, UINT64, "prefetches", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(CT_SIZE_CURRENT, TOKUDB_CACHETABLE_SIZE_CURRENT, UINT64, "size current", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(CT_SIZE_LIMIT, TOKUDB_CACHETABLE_SIZE_LIMIT, UINT64, "size limit", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(CT_SIZE_WRITING, TOKUDB_CACHETABLE_SIZE_WRITING, UINT64, "size writing", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(CT_SIZE_NONLEAF, TOKUDB_CACHETABLE_SIZE_NONLEAF, UINT64, "size nonleaf", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(CT_SIZE_LEAF, TOKUDB_CACHETABLE_SIZE_LEAF, UINT64, "size leaf", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(CT_SIZE_ROLLBACK, TOKUDB_CACHETABLE_SIZE_ROLLBACK, UINT64, "size rollback", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(CT_SIZE_CACHEPRESSURE, TOKUDB_CACHETABLE_SIZE_CACHEPRESSURE, UINT64, "size cachepressure", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(CT_EVICTIONS, TOKUDB_CACHETABLE_EVICTIONS, UINT64, "evictions", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(CT_CLEANER_EXECUTIONS, TOKUDB_CACHETABLE_CLEANER_EXECUTIONS, UINT64, "cleaner executions", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(CT_CLEANER_PERIOD, TOKUDB_CACHETABLE_CLEANER_PERIOD, UINT64, "cleaner period", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(CT_CLEANER_ITERATIONS, TOKUDB_CACHETABLE_CLEANER_ITERATIONS, UINT64, "cleaner iterations", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
ct_status.initialized = true;
}
#undef STATUS_INIT
......
ft/checkpoint.cc
View file @ 22e33283
......@@ -67,14 +67,14 @@ status_init(void) {
// Note, this function initializes the keyname, type, and legend fields.
// Value fields are initialized to zero by compiler.
STATUS_INIT(CP_PERIOD, nullptr, UINT64, "period", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(CP_PERIOD, TOKUDB_CHECKPOINT_PERIOD, UINT64, "period", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(CP_FOOTPRINT, nullptr, UINT64, "footprint", TOKU_ENGINE_STATUS);
STATUS_INIT(CP_TIME_LAST_CHECKPOINT_BEGIN, nullptr, UNIXTIME, "last checkpoint began ", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(CP_TIME_LAST_CHECKPOINT_BEGIN_COMPLETE, nullptr, UNIXTIME, "last complete checkpoint began ", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(CP_TIME_LAST_CHECKPOINT_END, nullptr, UNIXTIME, "last complete checkpoint ended", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(CP_TIME_LAST_CHECKPOINT_BEGIN, TOKUDB_CHECKPOINT_LAST_BEGAN, UNIXTIME, "last checkpoint began ", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(CP_TIME_LAST_CHECKPOINT_BEGIN_COMPLETE, TOKUDB_CHECKPOINT_LAST_COMPLETE_BEGAN, UNIXTIME, "last complete checkpoint began ", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(CP_TIME_LAST_CHECKPOINT_END, TOKUDB_CHECKPOINT_LAST_COMPLETE_ENDED, UNIXTIME, "last complete checkpoint ended", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(CP_LAST_LSN, nullptr, UINT64, "last complete checkpoint LSN", TOKU_ENGINE_STATUS);
STATUS_INIT(CP_CHECKPOINT_COUNT, nullptr, UINT64, "checkpoints taken ", TOKU_ENGINE_STATUS);
STATUS_INIT(CP_CHECKPOINT_COUNT_FAIL, nullptr, UINT64, "checkpoints failed", TOKU_ENGINE_STATUS);
STATUS_INIT(CP_CHECKPOINT_COUNT, TOKUDB_CHECKPOINT_TAKEN, UINT64, "checkpoints taken ", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(CP_CHECKPOINT_COUNT_FAIL, TOKUDB_CHECKPOINT_FAILED, UINT64, "checkpoints failed", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(CP_WAITERS_NOW, nullptr, UINT64, "waiters now", TOKU_ENGINE_STATUS);
STATUS_INIT(CP_WAITERS_MAX, nullptr, UINT64, "waiters max", TOKU_ENGINE_STATUS);
STATUS_INIT(CP_CLIENT_WAIT_ON_MO, nullptr, UINT64, "non-checkpoint client wait on mo lock", TOKU_ENGINE_STATUS);
......
ft/ft-ops.cc
View file @ 22e33283
......@@ -155,126 +155,126 @@ status_init(void)
{
// Note, this function initializes the keyname, type, and legend fields.
// Value fields are initialized to zero by compiler.
STATUS_INIT(FT_UPDATES, nullptr, PARCOUNT, "dictionary updates", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_UPDATES_BROADCAST, nullptr, PARCOUNT, "dictionary broadcast updates", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_DESCRIPTOR_SET, nullptr, PARCOUNT, "descriptor set", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_MSN_DISCARDS, nullptr, PARCOUNT, "messages ignored by leaf due to msn", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_UPDATES, TOKUDB_DICTIONARY_UPDATES, PARCOUNT, "dictionary updates", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_UPDATES_BROADCAST, TOKUDB_DICTIONARY_BROADCAST_UPDATES, PARCOUNT, "dictionary broadcast updates", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_DESCRIPTOR_SET, TOKUDB_DESCRIPTOR_SET, PARCOUNT, "descriptor set", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_MSN_DISCARDS, TOKUDB_MESSAGES_IGNORED_BY_LEAF_DUE_TO_MSN, PARCOUNT, "messages ignored by leaf due to msn", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_TOTAL_RETRIES, nullptr, PARCOUNT, "total search retries due to TRY_AGAIN", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_SEARCH_TRIES_GT_HEIGHT, nullptr, PARCOUNT, "searches requiring more tries than the height of the tree", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_SEARCH_TRIES_GT_HEIGHTPLUS3, nullptr, PARCOUNT, "searches requiring more tries than the height of the tree plus three", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_CREATE_LEAF, nullptr, PARCOUNT, "leaf nodes created", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_CREATE_NONLEAF, nullptr, PARCOUNT, "nonleaf nodes created", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_DESTROY_LEAF, nullptr, PARCOUNT, "leaf nodes destroyed", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_DESTROY_NONLEAF, nullptr, PARCOUNT, "nonleaf nodes destroyed", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_MSG_BYTES_IN, nullptr, PARCOUNT, "bytes of messages injected at root (all trees)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_MSG_BYTES_OUT, nullptr, PARCOUNT, "bytes of messages flushed from h1 nodes to leaves", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_MSG_BYTES_CURR, nullptr, PARCOUNT, "bytes of messages currently in trees (estimate)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_MSG_NUM, nullptr, PARCOUNT, "messages injected at root", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_MSG_NUM_BROADCAST, nullptr, PARCOUNT, "broadcast messages injected at root", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_NUM_BASEMENTS_DECOMPRESSED_NORMAL, nullptr, PARCOUNT, "basements decompressed as a target of a query", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_NUM_BASEMENTS_DECOMPRESSED_AGGRESSIVE, nullptr, PARCOUNT, "basements decompressed for prelocked range", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_NUM_BASEMENTS_DECOMPRESSED_PREFETCH, nullptr, PARCOUNT, "basements decompressed for prefetch", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_NUM_BASEMENTS_DECOMPRESSED_WRITE, nullptr, PARCOUNT, "basements decompressed for write", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_NUM_MSG_BUFFER_DECOMPRESSED_NORMAL, nullptr, PARCOUNT, "buffers decompressed as a target of a query", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_NUM_MSG_BUFFER_DECOMPRESSED_AGGRESSIVE, nullptr, PARCOUNT, "buffers decompressed for prelocked range", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_NUM_MSG_BUFFER_DECOMPRESSED_PREFETCH, nullptr, PARCOUNT, "buffers decompressed for prefetch", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_NUM_MSG_BUFFER_DECOMPRESSED_WRITE, nullptr, PARCOUNT, "buffers decompressed for write", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_CREATE_LEAF, TOKUDB_LEAF_NODES_CREATED, PARCOUNT, "leaf nodes created", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_CREATE_NONLEAF, TOKUDB_NONLEAF_NODES_CREATED, PARCOUNT, "nonleaf nodes created", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_DESTROY_LEAF, TOKUDB_LEAF_NODES_DESTROYED, PARCOUNT, "leaf nodes destroyed", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_DESTROY_NONLEAF, TOKUDB_NONLEAF_NODES_DESTROYED, PARCOUNT, "nonleaf nodes destroyed", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_MSG_BYTES_IN, TOKUDB_MESSAGES_INJECTED_AT_ROOT_BYTES, PARCOUNT, "bytes of messages injected at root (all trees)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_MSG_BYTES_OUT, TOKUDB_MESSAGES_FLUSHED_FROM_H1_TO_LEAVES_BYTES, PARCOUNT, "bytes of messages flushed from h1 nodes to leaves", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_MSG_BYTES_CURR, TOKUDB_MESSAGES_IN_TREES_ESTIMATE_BYTES, PARCOUNT, "bytes of messages currently in trees (estimate)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_MSG_NUM, TOKUDB_MESSAGES_INJECTED_AT_ROOT, PARCOUNT, "messages injected at root", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_MSG_NUM_BROADCAST, TOKUDB_BROADCASE_MESSAGES_INJECTED_AT_ROOT, PARCOUNT, "broadcast messages injected at root", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_NUM_BASEMENTS_DECOMPRESSED_NORMAL, TOKUDB_BASEMENTS_DECOMPRESSED_TARGET_QUERY, PARCOUNT, "basements decompressed as a target of a query", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_NUM_BASEMENTS_DECOMPRESSED_AGGRESSIVE, TOKUDB_BASEMENTS_DECOMPRESSED_PRELOCKED_RANGE, PARCOUNT, "basements decompressed for prelocked range", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_NUM_BASEMENTS_DECOMPRESSED_PREFETCH, TOKUDB_BASEMENTS_DECOMPRESSED_PREFETCH, PARCOUNT, "basements decompressed for prefetch", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_NUM_BASEMENTS_DECOMPRESSED_WRITE, TOKUDB_BASEMENTS_DECOMPRESSED_FOR_WRITE, PARCOUNT, "basements decompressed for write", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_NUM_MSG_BUFFER_DECOMPRESSED_NORMAL, TOKUDB_BUFFERS_DECOMPRESSED_TARGET_QUERY, PARCOUNT, "buffers decompressed as a target of a query", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_NUM_MSG_BUFFER_DECOMPRESSED_AGGRESSIVE, TOKUDB_BUFFERS_DECOMPRESSED_PRELOCKED_RANGE, PARCOUNT, "buffers decompressed for prelocked range", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_NUM_MSG_BUFFER_DECOMPRESSED_PREFETCH, TOKUDB_BUFFERS_DECOMPRESSED_PREFETCH, PARCOUNT, "buffers decompressed for prefetch", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_NUM_MSG_BUFFER_DECOMPRESSED_WRITE, TOKUDB_BUFFERS_DECOMPRESSED_FOR_WRITE, PARCOUNT, "buffers decompressed for write", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
// Eviction statistics:
STATUS_INIT(FT_FULL_EVICTIONS_LEAF, nullptr, PARCOUNT, "leaf node full evictions", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_FULL_EVICTIONS_LEAF_BYTES, nullptr, PARCOUNT, "leaf node full evictions (bytes)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_FULL_EVICTIONS_NONLEAF, nullptr, PARCOUNT, "nonleaf node full evictions", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_FULL_EVICTIONS_NONLEAF_BYTES, nullptr, PARCOUNT, "nonleaf node full evictions (bytes)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_PARTIAL_EVICTIONS_LEAF, nullptr, PARCOUNT, "leaf node partial evictions", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_PARTIAL_EVICTIONS_LEAF_BYTES, nullptr, PARCOUNT, "leaf node partial evictions (bytes)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_PARTIAL_EVICTIONS_NONLEAF, nullptr, PARCOUNT, "nonleaf node partial evictions", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_PARTIAL_EVICTIONS_NONLEAF_BYTES, nullptr, PARCOUNT, "nonleaf node partial evictions (bytes)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_FULL_EVICTIONS_LEAF, TOKUDB_LEAF_NODE_FULL_EVICTIONS, PARCOUNT, "leaf node full evictions", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_FULL_EVICTIONS_LEAF_BYTES, TOKUDB_LEAF_NODE_FULL_EVICTIONS_BYTES, PARCOUNT, "leaf node full evictions (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_FULL_EVICTIONS_NONLEAF, TOKUDB_NONLEAF_NODE_FULL_EVICTIONS, PARCOUNT, "nonleaf node full evictions", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_FULL_EVICTIONS_NONLEAF_BYTES, TOKUDB_NONLEAF_NODE_FULL_EVICTIONS_BYTES, PARCOUNT, "nonleaf node full evictions (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_PARTIAL_EVICTIONS_LEAF, TOKUDB_LEAF_NODE_PARTIAL_EVICTIONS, PARCOUNT, "leaf node partial evictions", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_PARTIAL_EVICTIONS_LEAF_BYTES, TOKUDB_LEAF_NODE_PARTIAL_EVICTIONS_BYTES, PARCOUNT, "leaf node partial evictions (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_PARTIAL_EVICTIONS_NONLEAF, TOKUDB_NONLEAF_NODE_PARTIAL_EVICTIONS, PARCOUNT, "nonleaf node partial evictions", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_PARTIAL_EVICTIONS_NONLEAF_BYTES, TOKUDB_NONLEAF_NODE_PARTIAL_EVICTIONS_BYTES, PARCOUNT, "nonleaf node partial evictions (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
// Disk read statistics:
//
// Pivots: For queries, prefetching, or writing.
STATUS_INIT(FT_NUM_PIVOTS_FETCHED_QUERY, nullptr, PARCOUNT, "pivots fetched for query", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_BYTES_PIVOTS_FETCHED_QUERY, nullptr, PARCOUNT, "pivots fetched for query (bytes)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_TOKUTIME_PIVOTS_FETCHED_QUERY, nullptr, TOKUTIME, "pivots fetched for query (seconds)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_NUM_PIVOTS_FETCHED_PREFETCH, nullptr, PARCOUNT, "pivots fetched for prefetch", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_BYTES_PIVOTS_FETCHED_PREFETCH, nullptr, PARCOUNT, "pivots fetched for prefetch (bytes)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_TOKUTIME_PIVOTS_FETCHED_PREFETCH, nullptr, TOKUTIME, "pivots fetched for prefetch (seconds)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_NUM_PIVOTS_FETCHED_WRITE, nullptr, PARCOUNT, "pivots fetched for write", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_BYTES_PIVOTS_FETCHED_WRITE, nullptr, PARCOUNT, "pivots fetched for write (bytes)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_TOKUTIME_PIVOTS_FETCHED_WRITE, nullptr, TOKUTIME, "pivots fetched for write (seconds)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_NUM_PIVOTS_FETCHED_QUERY, TOKUDB_PIVOTS_FETCHED_FOR_QUERY, PARCOUNT, "pivots fetched for query", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_BYTES_PIVOTS_FETCHED_QUERY, TOKUDB_PIVOTS_FETCHED_FOR_QUERY_BYTES, PARCOUNT, "pivots fetched for query (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_TOKUTIME_PIVOTS_FETCHED_QUERY, TOKUDB_PIVOTS_FETCHED_FOR_QUERY_SECONDS, TOKUTIME, "pivots fetched for query (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_NUM_PIVOTS_FETCHED_PREFETCH, TOKUDB_PIVOTS_FETCHED_FOR_PREFETCH, PARCOUNT, "pivots fetched for prefetch", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_BYTES_PIVOTS_FETCHED_PREFETCH, TOKUDB_PIVOTS_FETCHED_FOR_PREFETCH_BYTES, PARCOUNT, "pivots fetched for prefetch (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_TOKUTIME_PIVOTS_FETCHED_PREFETCH, TOKUDB_PIVOTS_FETCHED_FOR_PREFETCH_SECONDS, TOKUTIME, "pivots fetched for prefetch (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_NUM_PIVOTS_FETCHED_WRITE, TOKUDB_PIVOTS_FETCHED_FOR_WRITE, PARCOUNT, "pivots fetched for write", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_BYTES_PIVOTS_FETCHED_WRITE, TOKUDB_PIVOTS_FETCHED_FOR_WRITE_BYTES, PARCOUNT, "pivots fetched for write (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_TOKUTIME_PIVOTS_FETCHED_WRITE, TOKUDB_PIVOTS_FETCHED_FOR_WRITE_SECONDS, TOKUTIME, "pivots fetched for write (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
// Basements: For queries, aggressive fetching in prelocked range, prefetching, or writing.
STATUS_INIT(FT_NUM_BASEMENTS_FETCHED_NORMAL, nullptr, PARCOUNT, "basements fetched as a target of a query", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_BYTES_BASEMENTS_FETCHED_NORMAL, nullptr, PARCOUNT, "basements fetched as a target of a query (bytes)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_TOKUTIME_BASEMENTS_FETCHED_NORMAL, nullptr, TOKUTIME, "basements fetched as a target of a query (seconds)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_NUM_BASEMENTS_FETCHED_AGGRESSIVE, nullptr, PARCOUNT, "basements fetched for prelocked range", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_BYTES_BASEMENTS_FETCHED_AGGRESSIVE, nullptr, PARCOUNT, "basements fetched for prelocked range (bytes)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_TOKUTIME_BASEMENTS_FETCHED_AGGRESSIVE, nullptr, TOKUTIME, "basements fetched for prelocked range (seconds)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_NUM_BASEMENTS_FETCHED_PREFETCH, nullptr, PARCOUNT, "basements fetched for prefetch", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_BYTES_BASEMENTS_FETCHED_PREFETCH, nullptr, PARCOUNT, "basements fetched for prefetch (bytes)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_TOKUTIME_BASEMENTS_FETCHED_PREFETCH, nullptr, TOKUTIME, "basements fetched for prefetch (seconds)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_NUM_BASEMENTS_FETCHED_WRITE, nullptr, PARCOUNT, "basements fetched for write", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_BYTES_BASEMENTS_FETCHED_WRITE, nullptr, PARCOUNT, "basements fetched for write (bytes)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_TOKUTIME_BASEMENTS_FETCHED_WRITE, nullptr, TOKUTIME, "basements fetched for write (seconds)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_NUM_BASEMENTS_FETCHED_NORMAL, TOKUDB_BASEMENTS_FETCHED_TARGET_QUERY, PARCOUNT, "basements fetched as a target of a query", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_BYTES_BASEMENTS_FETCHED_NORMAL, TOKUDB_BASEMENTS_FETCHED_TARGET_QUERY_BYTES, PARCOUNT, "basements fetched as a target of a query (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_TOKUTIME_BASEMENTS_FETCHED_NORMAL, TOKUDB_BASEMENTS_FETCHED_TARGET_QUERY_SECONDS, TOKUTIME, "basements fetched as a target of a query (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_NUM_BASEMENTS_FETCHED_AGGRESSIVE, TOKUDB_BASEMENTS_FETCHED_PRELOCKED_RANGE, PARCOUNT, "basements fetched for prelocked range", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_BYTES_BASEMENTS_FETCHED_AGGRESSIVE, TOKUDB_BASEMENTS_FETCHED_PRELOCKED_RANGE_BYTES, PARCOUNT, "basements fetched for prelocked range (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_TOKUTIME_BASEMENTS_FETCHED_AGGRESSIVE, TOKUDB_BASEMENTS_FETCHED_PRELOCKED_RANGE_SECONDS, TOKUTIME, "basements fetched for prelocked range (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_NUM_BASEMENTS_FETCHED_PREFETCH, TOKUDB_BASEMENTS_FETCHED_PREFETCH, PARCOUNT, "basements fetched for prefetch", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_BYTES_BASEMENTS_FETCHED_PREFETCH, TOKUDB_BASEMENTS_FETCHED_PREFETCH_BYTES, PARCOUNT, "basements fetched for prefetch (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_TOKUTIME_BASEMENTS_FETCHED_PREFETCH, TOKUDB_BASEMENTS_FETCHED_PREFETCH_SECONDS, TOKUTIME, "basements fetched for prefetch (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_NUM_BASEMENTS_FETCHED_WRITE, TOKUDB_BASEMENTS_FETCHED_FOR_WRITE, PARCOUNT, "basements fetched for write", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_BYTES_BASEMENTS_FETCHED_WRITE, TOKUDB_BASEMENTS_FETCHED_FOR_WRITE_BYTES, PARCOUNT, "basements fetched for write (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_TOKUTIME_BASEMENTS_FETCHED_WRITE, TOKUDB_BASEMENTS_FETCHED_FOR_WRITE_SECONDS, TOKUTIME, "basements fetched for write (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
// Buffers: For queries, aggressive fetching in prelocked range, prefetching, or writing.
STATUS_INIT(FT_NUM_MSG_BUFFER_FETCHED_NORMAL, nullptr, PARCOUNT, "buffers fetched as a target of a query", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_BYTES_MSG_BUFFER_FETCHED_NORMAL, nullptr, PARCOUNT, "buffers fetched as a target of a query (bytes)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_TOKUTIME_MSG_BUFFER_FETCHED_NORMAL, nullptr, TOKUTIME, "buffers fetched as a target of a query (seconds)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_NUM_MSG_BUFFER_FETCHED_AGGRESSIVE, nullptr, PARCOUNT, "buffers fetched for prelocked range", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_BYTES_MSG_BUFFER_FETCHED_AGGRESSIVE, nullptr, PARCOUNT, "buffers fetched for prelocked range (bytes)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_TOKUTIME_MSG_BUFFER_FETCHED_AGGRESSIVE, nullptr, TOKUTIME, "buffers fetched for prelocked range (seconds)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_NUM_MSG_BUFFER_FETCHED_PREFETCH, nullptr, PARCOUNT, "buffers fetched for prefetch", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_BYTES_MSG_BUFFER_FETCHED_PREFETCH, nullptr, PARCOUNT, "buffers fetched for prefetch (bytes)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_TOKUTIME_MSG_BUFFER_FETCHED_PREFETCH, nullptr, TOKUTIME, "buffers fetched for prefetch (seconds)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_NUM_MSG_BUFFER_FETCHED_WRITE, nullptr, PARCOUNT, "buffers fetched for write", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_BYTES_MSG_BUFFER_FETCHED_WRITE, nullptr, PARCOUNT, "buffers fetched for write (bytes)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_TOKUTIME_MSG_BUFFER_FETCHED_WRITE, nullptr, TOKUTIME, "buffers fetched for write (seconds)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_NUM_MSG_BUFFER_FETCHED_NORMAL, TOKUDB_BUFFERS_FETCHED_TARGET_QUERY, PARCOUNT, "buffers fetched as a target of a query", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_BYTES_MSG_BUFFER_FETCHED_NORMAL, TOKUDB_BUFFERS_FETCHED_TARGET_QUERY_BYTES, PARCOUNT, "buffers fetched as a target of a query (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_TOKUTIME_MSG_BUFFER_FETCHED_NORMAL, TOKUDB_BUFFERS_FETCHED_TARGET_QUERY_SECONDS, TOKUTIME, "buffers fetched as a target of a query (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_NUM_MSG_BUFFER_FETCHED_AGGRESSIVE, TOKUDB_BUFFERS_FETCHED_PRELOCKED_RANGE, PARCOUNT, "buffers fetched for prelocked range", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_BYTES_MSG_BUFFER_FETCHED_AGGRESSIVE, TOKUDB_BUFFERS_FETCHED_PRELOCKED_RANGE_BYTES, PARCOUNT, "buffers fetched for prelocked range (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_TOKUTIME_MSG_BUFFER_FETCHED_AGGRESSIVE, TOKUDB_BUFFERS_FETCHED_PRELOCKED_RANGE_SECONDS, TOKUTIME, "buffers fetched for prelocked range (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_NUM_MSG_BUFFER_FETCHED_PREFETCH, TOKUDB_BUFFERS_FETCHED_PREFETCH, PARCOUNT, "buffers fetched for prefetch", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_BYTES_MSG_BUFFER_FETCHED_PREFETCH, TOKUDB_BUFFERS_FETCHED_PREFETCH_BYTES, PARCOUNT, "buffers fetched for prefetch (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_TOKUTIME_MSG_BUFFER_FETCHED_PREFETCH, TOKUDB_BUFFERS_FETCHED_PREFETCH_SECONDS, TOKUTIME, "buffers fetched for prefetch (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_NUM_MSG_BUFFER_FETCHED_WRITE, TOKUDB_BUFFERS_FETCHED_FOR_WRITE, PARCOUNT, "buffers fetched for write", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_BYTES_MSG_BUFFER_FETCHED_WRITE, TOKUDB_BUFFERS_FETCHED_FOR_WRITE_BYTES, PARCOUNT, "buffers fetched for write (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_TOKUTIME_MSG_BUFFER_FETCHED_WRITE, TOKUDB_BUFFERS_FETCHED_FOR_WRITE_SECONDS, TOKUTIME, "buffers fetched for write (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
// Disk write statistics.
//
// Leaf/Nonleaf: Not for checkpoint
STATUS_INIT(FT_DISK_FLUSH_LEAF, nullptr, PARCOUNT, "leaf nodes flushed to disk (not for checkpoint)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_DISK_FLUSH_LEAF_BYTES, nullptr, PARCOUNT, "leaf nodes flushed to disk (not for checkpoint) (bytes)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_DISK_FLUSH_LEAF_UNCOMPRESSED_BYTES, nullptr, PARCOUNT, "leaf nodes flushed to disk (not for checkpoint) (uncompressed bytes)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_DISK_FLUSH_LEAF_TOKUTIME, nullptr, TOKUTIME, "leaf nodes flushed to disk (not for checkpoint) (seconds)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_DISK_FLUSH_NONLEAF, nullptr, PARCOUNT, "nonleaf nodes flushed to disk (not for checkpoint)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_DISK_FLUSH_NONLEAF_BYTES, nullptr, PARCOUNT, "nonleaf nodes flushed to disk (not for checkpoint) (bytes)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_DISK_FLUSH_NONLEAF_UNCOMPRESSED_BYTES, nullptr, PARCOUNT, "nonleaf nodes flushed to disk (not for checkpoint) (uncompressed bytes)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_DISK_FLUSH_NONLEAF_TOKUTIME, nullptr, TOKUTIME, "nonleaf nodes flushed to disk (not for checkpoint) (seconds)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_DISK_FLUSH_LEAF, TOKUDB_LEAF_NODES_FLUSHED_NOT_CHECKPOINT, PARCOUNT, "leaf nodes flushed to disk (not for checkpoint)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_DISK_FLUSH_LEAF_BYTES, TOKUDB_LEAF_NODES_FLUSHED_NOT_CHECKPOINT_BYTES, PARCOUNT, "leaf nodes flushed to disk (not for checkpoint) (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_DISK_FLUSH_LEAF_UNCOMPRESSED_BYTES, TOKUDB_LEAF_NODES_FLUSHED_NOT_CHECKPOINT_UNCOMPRESSED_BYTES, PARCOUNT, "leaf nodes flushed to disk (not for checkpoint) (uncompressed bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_DISK_FLUSH_LEAF_TOKUTIME, TOKUDB_LEAF_NODES_FLUSHED_NOT_CHECKPOINT_SECONDS, TOKUTIME, "leaf nodes flushed to disk (not for checkpoint) (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_DISK_FLUSH_NONLEAF, TOKUDB_NONLEAF_NODES_FLUSHED_TO_DISK_NOT_CHECKPOINT, PARCOUNT, "nonleaf nodes flushed to disk (not for checkpoint)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_DISK_FLUSH_NONLEAF_BYTES, TOKUDB_NONLEAF_NODES_FLUSHED_TO_DISK_NOT_CHECKPOINT_BYTES, PARCOUNT, "nonleaf nodes flushed to disk (not for checkpoint) (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_DISK_FLUSH_NONLEAF_UNCOMPRESSED_BYTES, TOKUDB_NONLEAF_NODES_FLUSHED_TO_DISK_NOT_CHECKPOINT_UNCOMPRESSED_BYTES, PARCOUNT, "nonleaf nodes flushed to disk (not for checkpoint) (uncompressed bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_DISK_FLUSH_NONLEAF_TOKUTIME, TOKUDB_NONLEAF_NODES_FLUSHED_TO_DISK_NOT_CHECKPOINT_SECONDS, TOKUTIME, "nonleaf nodes flushed to disk (not for checkpoint) (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
// Leaf/Nonleaf: For checkpoint
STATUS_INIT(FT_DISK_FLUSH_LEAF_FOR_CHECKPOINT, nullptr, PARCOUNT, "leaf nodes flushed to disk (for checkpoint)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_DISK_FLUSH_LEAF_BYTES_FOR_CHECKPOINT, nullptr, PARCOUNT, "leaf nodes flushed to disk (for checkpoint) (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_DISK_FLUSH_LEAF_UNCOMPRESSED_BYTES_FOR_CHECKPOINT, nullptr, PARCOUNT, "leaf nodes flushed to disk (for checkpoint) (uncompressed bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_DISK_FLUSH_LEAF_TOKUTIME_FOR_CHECKPOINT, nullptr, TOKUTIME, "leaf nodes flushed to disk (for checkpoint) (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_DISK_FLUSH_NONLEAF_FOR_CHECKPOINT, nullptr, PARCOUNT, "nonleaf nodes flushed to disk (for checkpoint)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_DISK_FLUSH_NONLEAF_BYTES_FOR_CHECKPOINT, nullptr, PARCOUNT, "nonleaf nodes flushed to disk (for checkpoint) (bytes)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_DISK_FLUSH_NONLEAF_UNCOMPRESSED_BYTES_FOR_CHECKPOINT, nullptr, PARCOUNT, "nonleaf nodes flushed to disk (for checkpoint) (uncompressed bytes)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_DISK_FLUSH_NONLEAF_TOKUTIME_FOR_CHECKPOINT, nullptr, TOKUTIME, "nonleaf nodes flushed to disk (for checkpoint) (seconds)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_DISK_FLUSH_LEAF_FOR_CHECKPOINT, TOKUDB_LEAF_NODES_FLUSHED_CHECKPOINT, PARCOUNT, "leaf nodes flushed to disk (for checkpoint)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_DISK_FLUSH_LEAF_BYTES_FOR_CHECKPOINT, TOKUDB_LEAF_NODES_FLUSHED_CHECKPOINT_BYTES, PARCOUNT, "leaf nodes flushed to disk (for checkpoint) (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_DISK_FLUSH_LEAF_UNCOMPRESSED_BYTES_FOR_CHECKPOINT, TOKUDB_LEAF_NODES_FLUSHED_CHECKPOINT_UNCOMPRESSED_BYTES, PARCOUNT, "leaf nodes flushed to disk (for checkpoint) (uncompressed bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_DISK_FLUSH_LEAF_TOKUTIME_FOR_CHECKPOINT, TOKUDB_LEAF_NODES_FLUSHED_CHECKPOINT_SECONDS, TOKUTIME, "leaf nodes flushed to disk (for checkpoint) (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_DISK_FLUSH_NONLEAF_FOR_CHECKPOINT, TOKUDB_NONLEAF_NODES_FLUSHED_TO_DISK_CHECKPOINT, PARCOUNT, "nonleaf nodes flushed to disk (for checkpoint)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_DISK_FLUSH_NONLEAF_BYTES_FOR_CHECKPOINT, TOKUDB_NONLEAF_NODES_FLUSHED_TO_DISK_CHECKPOINT_BYTES, PARCOUNT, "nonleaf nodes flushed to disk (for checkpoint) (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_DISK_FLUSH_NONLEAF_UNCOMPRESSED_BYTES_FOR_CHECKPOINT, TOKUDB_NONLEAF_NODES_FLUSHED_TO_DISK_CHECKPOINT_UNCOMPRESSED_BYTES, PARCOUNT, "nonleaf nodes flushed to disk (for checkpoint) (uncompressed bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_DISK_FLUSH_NONLEAF_TOKUTIME_FOR_CHECKPOINT, TOKUDB_NONLEAF_NODES_FLUSHED_TO_DISK_CHECKPOINT_SECONDS, TOKUTIME, "nonleaf nodes flushed to disk (for checkpoint) (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
// CPU time statistics for [de]serialization and [de]compression.
STATUS_INIT(FT_LEAF_COMPRESS_TOKUTIME, nullptr, TOKUTIME, "leaf compression to memory (seconds)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_LEAF_SERIALIZE_TOKUTIME, nullptr, TOKUTIME, "leaf serialization to memory (seconds)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_LEAF_DECOMPRESS_TOKUTIME, nullptr, TOKUTIME, "leaf decompression to memory (seconds)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_LEAF_DESERIALIZE_TOKUTIME, nullptr, TOKUTIME, "leaf deserialization to memory (seconds)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_NONLEAF_COMPRESS_TOKUTIME, nullptr, TOKUTIME, "nonleaf compression to memory (seconds)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_NONLEAF_SERIALIZE_TOKUTIME, nullptr, TOKUTIME, "nonleaf serialization to memory (seconds)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_NONLEAF_DECOMPRESS_TOKUTIME, nullptr, TOKUTIME, "nonleaf decompression to memory (seconds)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_NONLEAF_DESERIALIZE_TOKUTIME, nullptr, TOKUTIME, "nonleaf deserialization to memory (seconds)", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_LEAF_COMPRESS_TOKUTIME, TOKUDB_LEAF_COMPRESSION_TO_MEMORY_SECONDS, TOKUTIME, "leaf compression to memory (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_LEAF_SERIALIZE_TOKUTIME, TOKUDB_LEAF_SERIALIZATION_TO_MEMORY_SECONDS, TOKUTIME, "leaf serialization to memory (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_LEAF_DECOMPRESS_TOKUTIME, TOKUDB_LEAF_DECOMPRESSION_TO_MEMORY_SECONDS, TOKUTIME, "leaf decompression to memory (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_LEAF_DESERIALIZE_TOKUTIME, TOKUDB_LEAF_DESERIALIZATION_TO_MEMORY_SECONDS, TOKUTIME, "leaf deserialization to memory (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_NONLEAF_COMPRESS_TOKUTIME, TOKUDB_NONLEAF_COMPRESSION_TO_MEMORY_SECONDS, TOKUTIME, "nonleaf compression to memory (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_NONLEAF_SERIALIZE_TOKUTIME, TOKUDB_NONLEAF_SERIALIZATION_TO_MEMORY_SECONDS, TOKUTIME, "nonleaf serialization to memory (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_NONLEAF_DECOMPRESS_TOKUTIME, TOKUDB_NONLEAF_DECOMPRESSION_TO_MEMORY_SECONDS, TOKUTIME, "nonleaf decompression to memory (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_NONLEAF_DESERIALIZE_TOKUTIME, TOKUDB_NONLEAF_DESERIALIZATION_TO_MEMORY_SECONDS, TOKUTIME, "nonleaf deserialization to memory (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
// Promotion statistics.
STATUS_INIT(FT_PRO_NUM_ROOT_SPLIT, nullptr, PARCOUNT, "promotion: roots split", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_PRO_NUM_ROOT_H0_INJECT, nullptr, PARCOUNT, "promotion: leaf roots injected into", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_PRO_NUM_ROOT_H1_INJECT, nullptr, PARCOUNT, "promotion: h1 roots injected into", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_PRO_NUM_INJECT_DEPTH_0, nullptr, PARCOUNT, "promotion: injections at depth 0", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_PRO_NUM_INJECT_DEPTH_1, nullptr, PARCOUNT, "promotion: injections at depth 1", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_PRO_NUM_INJECT_DEPTH_2, nullptr, PARCOUNT, "promotion: injections at depth 2", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_PRO_NUM_INJECT_DEPTH_3, nullptr, PARCOUNT, "promotion: injections at depth 3", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_PRO_NUM_INJECT_DEPTH_GT3, nullptr, PARCOUNT, "promotion: injections lower than depth 3", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_PRO_NUM_STOP_NONEMPTY_BUF, nullptr, PARCOUNT, "promotion: stopped because of a nonempty buffer", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_PRO_NUM_STOP_H1, nullptr, PARCOUNT, "promotion: stopped at height 1", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_PRO_NUM_STOP_LOCK_CHILD, nullptr, PARCOUNT, "promotion: stopped because the child was locked or not at all in memory", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_PRO_NUM_STOP_CHILD_INMEM, nullptr, PARCOUNT, "promotion: stopped because the child was not fully in memory", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_PRO_NUM_DIDNT_WANT_PROMOTE, nullptr, PARCOUNT, "promotion: stopped anyway, after locking the child", TOKU_ENGINE_STATUS);
STATUS_INIT(FT_PRO_NUM_ROOT_SPLIT, TOKUDB_PROMOTION_ROOTS_SPLIT, PARCOUNT, "promotion: roots split", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_PRO_NUM_ROOT_H0_INJECT, TOKUDB_PROMOTION_LEAF_ROOTS_INJECTED_INTO, PARCOUNT, "promotion: leaf roots injected into", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_PRO_NUM_ROOT_H1_INJECT, TOKUDB_PROMOTION_H1_ROOTS_INJECTED_INTO, PARCOUNT, "promotion: h1 roots injected into", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_PRO_NUM_INJECT_DEPTH_0, TOKUDB_PROMOTION_INJECTIONS_AT_DEPTH_0, PARCOUNT, "promotion: injections at depth 0", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_PRO_NUM_INJECT_DEPTH_1, TOKUDB_PROMOTION_INJECTIONS_AT_DEPTH_1, PARCOUNT, "promotion: injections at depth 1", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_PRO_NUM_INJECT_DEPTH_2, TOKUDB_PROMOTION_INJECTIONS_AT_DEPTH_2, PARCOUNT, "promotion: injections at depth 2", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_PRO_NUM_INJECT_DEPTH_3, TOKUDB_PROMOTION_INJECTIONS_AT_DEPTH_3, PARCOUNT, "promotion: injections at depth 3", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_PRO_NUM_INJECT_DEPTH_GT3, TOKUDB_PROMOTION_INJECTIONS_LOWER_THAN_DEPTH_3, PARCOUNT, "promotion: injections lower than depth 3", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_PRO_NUM_STOP_NONEMPTY_BUF, TOKUDB_PROMOTION_STOPPED_NONEMPTY_BUFFER, PARCOUNT, "promotion: stopped because of a nonempty buffer", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_PRO_NUM_STOP_H1, TOKUDB_PROMOTION_STOPPED_AT_HEIGHT_1, PARCOUNT, "promotion: stopped at height 1", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_PRO_NUM_STOP_LOCK_CHILD, TOKUDB_PROMOTION_STOPPED_CHILD_LOCKED_OR_NOT_IN_MEMORY, PARCOUNT, "promotion: stopped because the child was locked or not at all in memory", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_PRO_NUM_STOP_CHILD_INMEM, TOKUDB_PROMOTION_STOPPED_CHILD_NOT_FULLY_IN_MEMORY, PARCOUNT, "promotion: stopped because the child was not fully in memory", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(FT_PRO_NUM_DIDNT_WANT_PROMOTE, TOKUDB_PROMOTION_STOPPED_AFTER_LOCKING_CHILD, PARCOUNT, "promotion: stopped anyway, after locking the child", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
ft_status.initialized = true;
}
......
ft/logger.cc
View file @ 22e33283
......@@ -1324,10 +1324,10 @@ status_init(void) {
STATUS_INIT(LOGGER_ILOCK_CTR, nullptr, UINT64, "ilock count", TOKU_ENGINE_STATUS);
STATUS_INIT(LOGGER_OLOCK_CTR, nullptr, UINT64, "olock count", TOKU_ENGINE_STATUS);
STATUS_INIT(LOGGER_SWAP_CTR, nullptr, UINT64, "swap count", TOKU_ENGINE_STATUS);
STATUS_INIT(LOGGER_NUM_WRITES, nullptr, UINT64, "writes", TOKU_ENGINE_STATUS);
STATUS_INIT(LOGGER_BYTES_WRITTEN, nullptr, UINT64, "writes (bytes)", TOKU_ENGINE_STATUS);
STATUS_INIT(LOGGER_UNCOMPRESSED_BYTES_WRITTEN, nullptr, UINT64, "writes (uncompressed bytes)", TOKU_ENGINE_STATUS);
STATUS_INIT(LOGGER_TOKUTIME_WRITES, nullptr, TOKUTIME, "writes (seconds)", TOKU_ENGINE_STATUS);
STATUS_INIT(LOGGER_NUM_WRITES, TOKUDB_LOGGER_WRITES, UINT64, "writes", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(LOGGER_BYTES_WRITTEN, TOKUDB_LOGGER_WRITES_BYTES, UINT64, "writes (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(LOGGER_UNCOMPRESSED_BYTES_WRITTEN, TOKUDB_LOGGER_WRITES_UNCOMPRESSED_BYTES, UINT64, "writes (uncompressed bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(LOGGER_TOKUTIME_WRITES, TOKUDB_LOGGER_WRITES_SECONDS, TOKUTIME, "writes (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
logger_status.initialized = true;
}
#undef STATUS_INIT
......
ft/txn.cc
View file @ 22e33283
......@@ -29,10 +29,10 @@ void
txn_status_init(void) {
// Note, this function initializes the keyname, type, and legend fields.
// Value fields are initialized to zero by compiler.
STATUS_INIT(TXN_BEGIN, nullptr, PARCOUNT, "begin", TOKU_ENGINE_STATUS);
STATUS_INIT(TXN_READ_BEGIN, nullptr, PARCOUNT, "begin read only", TOKU_ENGINE_STATUS);
STATUS_INIT(TXN_COMMIT, nullptr, PARCOUNT, "successful commits", TOKU_ENGINE_STATUS);
STATUS_INIT(TXN_ABORT, nullptr, PARCOUNT, "aborts", TOKU_ENGINE_STATUS);
STATUS_INIT(TXN_BEGIN, TOKUDB_TXN_BEGIN, PARCOUNT, "begin", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(TXN_READ_BEGIN, TOKUDB_TXN_BEGIN_READ_ONLY, PARCOUNT, "begin read only", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(TXN_COMMIT, TOKUDB_TXN_COMMITS, PARCOUNT, "successful commits", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(TXN_ABORT, TOKUDB_TXN_ABORTS, PARCOUNT, "aborts", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
txn_status.initialized = true;
}
......
locktree/manager.cc
View file @ 22e33283
......@@ -275,16 +275,16 @@ bool locktree::manager::memory_tracker::out_of_locks(void) const {
#define STATUS_INIT(k,c,t,l,inc) TOKUDB_STATUS_INIT(status, k, c, t, "locktree: " l, inc)
void locktree::manager::status_init(void) {
STATUS_INIT(LTM_SIZE_CURRENT, nullptr, UINT64, "memory size", TOKU_ENGINE_STATUS);
STATUS_INIT(LTM_SIZE_LIMIT, nullptr, UINT64, "memory size limit", TOKU_ENGINE_STATUS);
STATUS_INIT(LTM_ESCALATION_COUNT, nullptr, UINT64, "number of times lock escalation ran", TOKU_ENGINE_STATUS);
STATUS_INIT(LTM_ESCALATION_TIME, nullptr, TOKUTIME, "time spent running escalation (seconds)", TOKU_ENGINE_STATUS);
STATUS_INIT(LTM_ESCALATION_LATEST_RESULT, nullptr, UINT64, "latest post-escalation memory size", TOKU_ENGINE_STATUS);
STATUS_INIT(LTM_NUM_LOCKTREES, nullptr, UINT64, "number of locktrees open now", TOKU_ENGINE_STATUS);
STATUS_INIT(LTM_LOCK_REQUESTS_PENDING, nullptr, UINT64, "number of pending lock requests", TOKU_ENGINE_STATUS);
STATUS_INIT(LTM_STO_NUM_ELIGIBLE, nullptr, UINT64, "number of locktrees eligible for the STO", TOKU_ENGINE_STATUS);
STATUS_INIT(LTM_STO_END_EARLY_COUNT, nullptr, UINT64, "number of times a locktree ended the STO early", TOKU_ENGINE_STATUS);
STATUS_INIT(LTM_STO_END_EARLY_TIME, nullptr, TOKUTIME, "time spent ending the STO early (seconds)", TOKU_ENGINE_STATUS);
STATUS_INIT(LTM_SIZE_CURRENT, TOKUDB_LOCKTREE_MEMORY_SIZE, UINT64, "memory size", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(LTM_SIZE_LIMIT, TOKUDB_LOCKTREE_MEMORY_SIZE_LIMIT, UINT64, "memory size limit", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(LTM_ESCALATION_COUNT, TOKUDB_LOCKTREE_ESCALATION_NUM, UINT64, "number of times lock escalation ran", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(LTM_ESCALATION_TIME, TOKUDB_LOCKTREE_ESCALATION_SECONDS, TOKUTIME, "time spent running escalation (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(LTM_ESCALATION_LATEST_RESULT, TOKUDB_LOCKTREE_LATEST_POST_ESCALATION_MEMORY_SIZE, UINT64, "latest post-escalation memory size", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(LTM_NUM_LOCKTREES, TOKUDB_LOCKTREE_OPEN_CURRENT, UINT64, "number of locktrees open now", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(LTM_LOCK_REQUESTS_PENDING, TOKUDB_LOCKTREE_PENDING_LOCK_REQUESTS, UINT64, "number of pending lock requests", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(LTM_STO_NUM_ELIGIBLE, TOKUDB_LOCKTREE_STO_ELIGIBLE_NUM, UINT64, "number of locktrees eligible for the STO", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(LTM_STO_END_EARLY_COUNT, TOKUDB_LOCKTREE_STO_ENDED_NUM, UINT64, "number of times a locktree ended the STO early", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(LTM_STO_END_EARLY_TIME, TOKUDB_LOCKTREE_STO_ENDED_SECONDS, TOKUTIME, "time spent ending the STO early (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
status.initialized = true;
}
......
src/loader.cc
View file @ 22e33283
......@@ -47,15 +47,15 @@ static void
status_init(void) {
// Note, this function initializes the keyname, type, and legend fields.
// Value fields are initialized to zero by compiler.
STATUS_INIT(LOADER_CREATE, nullptr, UINT64, "number of loaders successfully created", TOKU_ENGINE_STATUS);
STATUS_INIT(LOADER_CREATE, TOKUDB_LOADER_NUM_CREATED, UINT64, "number of loaders successfully created", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(LOADER_CREATE_FAIL, nullptr, UINT64, "number of calls to toku_loader_create_loader() that failed", TOKU_ENGINE_STATUS);
STATUS_INIT(LOADER_PUT, nullptr, UINT64, "number of calls to loader->put() succeeded", TOKU_ENGINE_STATUS);
STATUS_INIT(LOADER_PUT_FAIL, nullptr, UINT64, "number of calls to loader->put() failed", TOKU_ENGINE_STATUS);
STATUS_INIT(LOADER_CLOSE, nullptr, UINT64, "number of calls to loader->close() that succeeded", TOKU_ENGINE_STATUS);
STATUS_INIT(LOADER_CLOSE_FAIL, nullptr, UINT64, "number of calls to loader->close() that failed", TOKU_ENGINE_STATUS);
STATUS_INIT(LOADER_ABORT, nullptr, UINT64, "number of calls to loader->abort()", TOKU_ENGINE_STATUS);
STATUS_INIT(LOADER_CURRENT, nullptr, UINT64, "number of loaders currently in existence", TOKU_ENGINE_STATUS);
STATUS_INIT(LOADER_MAX, nullptr, UINT64, "max number of loaders that ever existed simultaneously", TOKU_ENGINE_STATUS);
STATUS_INIT(LOADER_CURRENT, TOKUDB_LOADER_NUM_CURRENT, UINT64, "number of loaders currently in existence", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(LOADER_MAX, TOKUDB_LOADER_NUM_MAX, UINT64, "max number of loaders that ever existed simultaneously", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
loader_status.initialized = true;
}
#undef STATUS_INIT
......
src/ydb.cc
View file @ 22e33283
......@@ -121,10 +121,10 @@ ydb_layer_status_init (void) {
STATUS_INIT(YDB_LAYER_TIME_CREATION, nullptr, UNIXTIME, "time of environment creation", TOKU_ENGINE_STATUS);
STATUS_INIT(YDB_LAYER_TIME_STARTUP, nullptr, UNIXTIME, "time of engine startup", TOKU_ENGINE_STATUS);
STATUS_INIT(YDB_LAYER_TIME_NOW, nullptr, UNIXTIME, "time now", TOKU_ENGINE_STATUS);
STATUS_INIT(YDB_LAYER_NUM_DB_OPEN, nullptr, UINT64, "db opens", TOKU_ENGINE_STATUS);
STATUS_INIT(YDB_LAYER_NUM_DB_CLOSE, nullptr, UINT64, "db closes", TOKU_ENGINE_STATUS);
STATUS_INIT(YDB_LAYER_NUM_OPEN_DBS, nullptr, UINT64, "num open dbs now", TOKU_ENGINE_STATUS);
STATUS_INIT(YDB_LAYER_MAX_OPEN_DBS, nullptr, UINT64, "max open dbs", TOKU_ENGINE_STATUS);
STATUS_INIT(YDB_LAYER_NUM_DB_OPEN, TOKUDB_DB_OPENS, UINT64, "db opens", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(YDB_LAYER_NUM_DB_CLOSE, TOKUDB_DB_CLOSES, UINT64, "db closes", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(YDB_LAYER_NUM_OPEN_DBS, TOKUDB_DB_OPEN_CURRENT, UINT64, "num open dbs now", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(YDB_LAYER_MAX_OPEN_DBS, TOKUDB_DB_OPEN_MAX, UINT64, "max open dbs", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(YDB_LAYER_FSYNC_LOG_PERIOD, nullptr, UINT64, "period, in ms, that recovery log is automatically fsynced", TOKU_ENGINE_STATUS);
STATUS_VALUE(YDB_LAYER_TIME_STARTUP) = time(NULL);
......@@ -1701,12 +1701,12 @@ static FS_STATUS_S fsstat;
static void
fs_status_init(void) {
FS_STATUS_INIT(FS_ENOSPC_REDZONE_STATE, nullptr, FS_STATE, "ENOSPC redzone state", TOKU_ENGINE_STATUS);
FS_STATUS_INIT(FS_ENOSPC_THREADS_BLOCKED, nullptr, UINT64, "threads currently blocked by full disk", TOKU_ENGINE_STATUS);
FS_STATUS_INIT(FS_ENOSPC_THREADS_BLOCKED, TOKUDB_FILESYSTEM_THREADS_BLOCKED_BY_FULL_DISK, UINT64, "threads currently blocked by full disk", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
FS_STATUS_INIT(FS_ENOSPC_REDZONE_CTR, nullptr, UINT64, "number of operations rejected by enospc prevention (red zone)", TOKU_ENGINE_STATUS);
FS_STATUS_INIT(FS_ENOSPC_MOST_RECENT, nullptr, UNIXTIME, "most recent disk full", TOKU_ENGINE_STATUS);
FS_STATUS_INIT(FS_ENOSPC_COUNT, nullptr, UINT64, "number of write operations that returned ENOSPC", TOKU_ENGINE_STATUS);
FS_STATUS_INIT(FS_FSYNC_TIME, nullptr, UINT64, "fsync time", TOKU_ENGINE_STATUS);
FS_STATUS_INIT(FS_FSYNC_COUNT, nullptr, UINT64, "fsync count", TOKU_ENGINE_STATUS);
FS_STATUS_INIT(FS_FSYNC_TIME, TOKUDB_FILESYSTEM_FSYNC_SECONDS, UINT64, "fsync time", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
FS_STATUS_INIT(FS_FSYNC_COUNT, TOKUDB_FILESYSTEM_FSYNC_NUM, UINT64, "fsync count", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
fsstat.initialized = true;
}
#undef FS_STATUS_INIT
......@@ -1775,7 +1775,7 @@ memory_status_init(void) {
STATUS_INIT(MEMORY_REQUESTED, nullptr, UINT64, "number of bytes requested", TOKU_ENGINE_STATUS);
STATUS_INIT(MEMORY_USED, nullptr, UINT64, "number of bytes used (requested + overhead)", TOKU_ENGINE_STATUS);
STATUS_INIT(MEMORY_FREED, nullptr, UINT64, "number of bytes freed", TOKU_ENGINE_STATUS);
STATUS_INIT(MEMORY_MAX_IN_USE, nullptr, UINT64, "estimated maximum memory footprint", TOKU_ENGINE_STATUS);
STATUS_INIT(MEMORY_MAX_IN_USE, TOKUDB_MEM_ESTIMATED_MAXIMUM_MEMORY_FOOTPRINT, UINT64, "estimated maximum memory footprint", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
STATUS_INIT(MEMORY_MALLOCATOR_VERSION, nullptr, CHARSTR, "mallocator version", TOKU_ENGINE_STATUS);
STATUS_INIT(MEMORY_MMAP_THRESHOLD, nullptr, UINT64, "mmap threshold", TOKU_ENGINE_STATUS);
memory_status.initialized = true;
......
util/partitioned_counter.h
View file @ 22e33283
......@@ -67,7 +67,7 @@ void partitioned_counters_destroy(void);
array.status[k].type = t; \
array.status[k].legend = l; \
static_assert((inc) != 0, "Var must be included in at least one place"); \
static_assert(true || (inc) == TOKU_ENGINE_STATUS || \
static_assert((inc) == TOKU_ENGINE_STATUS || \
(strcmp(#c, "nullptr") && strcmp(#c, "NULL") && strcmp(#c, "0")) \
, "Missing column name."); \
array.status[k].include = static_cast<toku_engine_status_include_type>(inc); \
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7