From 5c6e1e540a9b5b0e0c87fa3522b9e668e2357a8c Mon Sep 17 00:00:00 2001 From: Luke Chen Date: Fri, 5 Jun 2020 17:04:46 +1000 Subject: Import wiredtiger: 4eb9f719eed3e24a9e49a6fa60d8d56eadb8b189 from branch mongodb-4.4 ref: d198ee319d..4eb9f719ee for: 4.5.1 WT-5801 Reduce runtime of Python unit tests by pruning test_compat02.py WT-6276 Add size first to cache and btree to avoid the race that can cause cache size underflow WT-6342 Fix external symbolizer path for PPC Evergreen tasks WT-6366 Off-by-one overflow in block-modification bitmaps for incremental backup WT-6373 Don't reset transaction ids when evicting mixed mode transactions WT-6376 Minor cleanups in resolving prepared operations WT-6378 Fix compile failure on OS X 10.12 --- src/third_party/wiredtiger/dist/api_data.py | 2 +- src/third_party/wiredtiger/import.data | 2 +- src/third_party/wiredtiger/src/block/block_ckpt.c | 13 +++--- src/third_party/wiredtiger/src/btree/row_modify.c | 3 +- src/third_party/wiredtiger/src/config/config_def.c | 2 +- src/third_party/wiredtiger/src/include/btree.i | 34 ++++++++++----- .../wiredtiger/src/include/wiredtiger.in | 2 +- .../wiredtiger/src/reconcile/rec_visibility.c | 1 - src/third_party/wiredtiger/src/txn/txn.c | 22 +++++----- .../wiredtiger/test/csuite/incr_backup/main.c | 19 +++++---- src/third_party/wiredtiger/test/evergreen.yml | 4 +- src/third_party/wiredtiger/test/format/backup.c | 7 ++-- src/third_party/wiredtiger/test/format/config.c | 48 ++++++++++++++++++++++ src/third_party/wiredtiger/test/format/config.h | 3 ++ src/third_party/wiredtiger/test/format/format.h | 1 + src/third_party/wiredtiger/test/format/smoke.sh | 20 ++++----- .../wiredtiger/test/suite/test_compat02.py | 4 +- 17 files changed, 129 insertions(+), 58 deletions(-) (limited to 'src') diff --git a/src/third_party/wiredtiger/dist/api_data.py b/src/third_party/wiredtiger/dist/api_data.py index 49b2f4f8f27..9130bef7ed0 100644 --- a/src/third_party/wiredtiger/dist/api_data.py +++ b/src/third_party/wiredtiger/dist/api_data.py @@ -1286,7 +1286,7 @@ methods = { this setting manages the granularity of how WiredTiger maintains modification maps internally. The larger the granularity, the smaller amount of information WiredTiger need to maintain''', - min='1MB', max='2GB'), + min='4KB', max='2GB'), Config('src_id', '', r''' a string that identifies a previous checkpoint backup source as the source of this incremental backup. This identifier must have already been created diff --git a/src/third_party/wiredtiger/import.data b/src/third_party/wiredtiger/import.data index 1fd7bb991a6..049419a81f9 100644 --- a/src/third_party/wiredtiger/import.data +++ b/src/third_party/wiredtiger/import.data @@ -2,5 +2,5 @@ "vendor": "wiredtiger", "github": "wiredtiger/wiredtiger.git", "branch": "mongodb-4.4", - "commit": "d198ee319dcb857f27358f9a75c11aab4725bedb" + "commit": "4eb9f719eed3e24a9e49a6fa60d8d56eadb8b189" } diff --git a/src/third_party/wiredtiger/src/block/block_ckpt.c b/src/third_party/wiredtiger/src/block/block_ckpt.c index 2f97613368a..6a10df06fff 100644 --- a/src/third_party/wiredtiger/src/block/block_ckpt.c +++ b/src/third_party/wiredtiger/src/block/block_ckpt.c @@ -355,16 +355,16 @@ __ckpt_add_blkmod_entry( WT_ASSERT(session, blk_mod->granularity != 0); /* - * Figure out how the starting and ending bits based on the granularity and our offset and - * length. + * Figure out the starting and ending locations in the bitmap based on its granularity and our + * offset and length. The bit locations are zero-based; be careful translating to sizes. */ start_bit = (uint64_t)offset / blk_mod->granularity; end_bit = (uint64_t)(offset + len - 1) / blk_mod->granularity; WT_ASSERT(session, end_bit < UINT32_MAX); /* We want to grow the bitmap by 64 bits, or 8 bytes at a time. */ - end_rdup_bits = WT_MAX(__wt_rduppo2((uint32_t)end_bit, 64), WT_BLOCK_MODS_LIST_MIN); - end_rdup_bytes = end_rdup_bits >> 3; - end_buf_bytes = (uint32_t)blk_mod->nbits >> 3; + end_rdup_bits = WT_MAX(__wt_rduppo2((uint32_t)end_bit + 1, 64), WT_BLOCK_MODS_LIST_MIN); + end_rdup_bytes = __bitstr_size(end_rdup_bits); + end_buf_bytes = __bitstr_size((uint32_t)blk_mod->nbits); /* * We are doing a lot of shifting. Make sure that the number of bytes we end up with is a * multiple of eight. We guarantee that in the rounding up call, but also make sure that the @@ -384,6 +384,9 @@ __ckpt_add_blkmod_entry( } blk_mod->nbits = end_rdup_bits; } + /* Make sure we're not going to run past the end of the bitmap */ + WT_ASSERT(session, blk_mod->bitstring.size >= __bitstr_size((uint32_t)blk_mod->nbits)); + WT_ASSERT(session, end_bit < blk_mod->nbits); /* Set all the bits needed to record this offset/length pair. */ __bit_nset(blk_mod->bitstring.mem, start_bit, end_bit); return (0); diff --git a/src/third_party/wiredtiger/src/btree/row_modify.c b/src/third_party/wiredtiger/src/btree/row_modify.c index 1ec05b29779..e71f96daa9a 100644 --- a/src/third_party/wiredtiger/src/btree/row_modify.c +++ b/src/third_party/wiredtiger/src/btree/row_modify.c @@ -71,13 +71,14 @@ __wt_row_modify(WT_CURSOR_BTREE *cbt, const WT_ITEM *key, const WT_ITEM *value, * - A key with no value to create a reserved or tombstone update to append to the update list. * * A "full update list" is distinguished from "an update" by checking whether it has a "next" - * update. + * update. The modify type should only be set if no update list provided. */ WT_ASSERT( session, ((modify_type == WT_UPDATE_RESERVE || modify_type == WT_UPDATE_TOMBSTONE) && value == NULL && upd_arg == NULL) || (!(modify_type == WT_UPDATE_RESERVE || modify_type == WT_UPDATE_TOMBSTONE) && ((value == NULL && upd_arg != NULL) || (value != NULL && upd_arg == NULL)))); + WT_ASSERT(session, upd_arg == NULL || modify_type == WT_UPDATE_INVALID); /* If we don't yet have a modify structure, we'll need one. */ WT_RET(__wt_page_modify_init(session, page)); diff --git a/src/third_party/wiredtiger/src/config/config_def.c b/src/third_party/wiredtiger/src/config/config_def.c index 6ef93c7bc4b..7b0b657619c 100644 --- a/src/third_party/wiredtiger/src/config/config_def.c +++ b/src/third_party/wiredtiger/src/config/config_def.c @@ -303,7 +303,7 @@ static const WT_CONFIG_CHECK confchk_WT_SESSION_log_flush[] = { static const WT_CONFIG_CHECK confchk_WT_SESSION_open_cursor_incremental_subconfigs[] = { {"enabled", "boolean", NULL, NULL, NULL, 0}, {"file", "string", NULL, NULL, NULL, 0}, {"force_stop", "boolean", NULL, NULL, NULL, 0}, - {"granularity", "int", NULL, "min=1MB,max=2GB", NULL, 0}, + {"granularity", "int", NULL, "min=4KB,max=2GB", NULL, 0}, {"src_id", "string", NULL, NULL, NULL, 0}, {"this_id", "string", NULL, NULL, NULL, 0}, {NULL, NULL, NULL, NULL, NULL, 0}}; diff --git a/src/third_party/wiredtiger/src/include/btree.i b/src/third_party/wiredtiger/src/include/btree.i index 5a7fec77f71..87a6c66dba2 100644 --- a/src/third_party/wiredtiger/src/include/btree.i +++ b/src/third_party/wiredtiger/src/include/btree.i @@ -195,18 +195,22 @@ __wt_cache_page_inmem_incr(WT_SESSION_IMPL *session, WT_PAGE *page, size_t size) if (size == 0) return; - (void)__wt_atomic_add64(&btree->bytes_inmem, size); + /* + * Always increase the size in sequence of cache, btree, and page as we may race with other + * threads that are trying to decrease the sizes concurrently. + */ (void)__wt_atomic_add64(&cache->bytes_inmem, size); + (void)__wt_atomic_add64(&btree->bytes_inmem, size); (void)__wt_atomic_addsize(&page->memory_footprint, size); if (__wt_page_is_modified(page)) { - (void)__wt_atomic_addsize(&page->modify->bytes_dirty, size); if (WT_PAGE_IS_INTERNAL(page)) { - (void)__wt_atomic_add64(&btree->bytes_dirty_intl, size); (void)__wt_atomic_add64(&cache->bytes_dirty_intl, size); + (void)__wt_atomic_add64(&btree->bytes_dirty_intl, size); } else if (!btree->lsm_primary) { - (void)__wt_atomic_add64(&btree->bytes_dirty_leaf, size); (void)__wt_atomic_add64(&cache->bytes_dirty_leaf, size); + (void)__wt_atomic_add64(&btree->bytes_dirty_leaf, size); } + (void)__wt_atomic_addsize(&page->modify->bytes_dirty, size); } /* Track internal size in cache. */ if (WT_PAGE_IS_INTERNAL(page)) @@ -292,6 +296,9 @@ __wt_cache_page_byte_dirty_decr(WT_SESSION_IMPL *session, WT_PAGE *page, size_t * without underflow. If we can't decrement the dirty byte counts after * few tries, give up: the cache's value will be wrong, but consistent, * and we'll fix it the next time this page is marked clean, or evicted. + * + * Always decrease the size in sequence of page, btree, and cache as we may race with other + * threads that are trying to increase the sizes concurrently. */ for (i = 0; i < 5; ++i) { /* @@ -332,10 +339,14 @@ __wt_cache_page_inmem_decr(WT_SESSION_IMPL *session, WT_PAGE *page, size_t size) WT_ASSERT(session, size < WT_EXABYTE); + /* + * Always decrease the size in sequence of page, btree, and cache as we may race with other + * threads that are trying to increase the sizes concurrently. + */ + __wt_cache_decr_check_size(session, &page->memory_footprint, size, "WT_PAGE.memory_footprint"); __wt_cache_decr_check_uint64( session, &S2BT(session)->bytes_inmem, size, "WT_BTREE.bytes_inmem"); __wt_cache_decr_check_uint64(session, &cache->bytes_inmem, size, "WT_CACHE.bytes_inmem"); - __wt_cache_decr_check_size(session, &page->memory_footprint, size, "WT_PAGE.memory_footprint"); if (__wt_page_is_modified(page)) __wt_cache_page_byte_dirty_decr(session, page, size); /* Track internal size in cache. */ @@ -359,22 +370,25 @@ __wt_cache_dirty_incr(WT_SESSION_IMPL *session, WT_PAGE *page) cache = S2C(session)->cache; /* + * Always increase the size in sequence of cache, btree, and page as we may race with other + * threads that are trying to decrease the sizes concurrently. + * * Take care to read the memory_footprint once in case we are racing with updates. */ size = page->memory_footprint; if (WT_PAGE_IS_INTERNAL(page)) { - (void)__wt_atomic_add64(&btree->bytes_dirty_intl, size); - (void)__wt_atomic_add64(&cache->bytes_dirty_intl, size); (void)__wt_atomic_add64(&cache->pages_dirty_intl, 1); + (void)__wt_atomic_add64(&cache->bytes_dirty_intl, size); + (void)__wt_atomic_add64(&btree->bytes_dirty_intl, size); } else { + (void)__wt_atomic_add64(&cache->pages_dirty_leaf, 1); if (!btree->lsm_primary) { - (void)__wt_atomic_add64(&btree->bytes_dirty_leaf, size); (void)__wt_atomic_add64(&cache->bytes_dirty_leaf, size); + (void)__wt_atomic_add64(&btree->bytes_dirty_leaf, size); } - (void)__wt_atomic_add64(&cache->pages_dirty_leaf, 1); } - (void)__wt_atomic_add64(&btree->bytes_dirty_total, size); (void)__wt_atomic_add64(&cache->bytes_dirty_total, size); + (void)__wt_atomic_add64(&btree->bytes_dirty_total, size); (void)__wt_atomic_addsize(&page->modify->bytes_dirty, size); } diff --git a/src/third_party/wiredtiger/src/include/wiredtiger.in b/src/third_party/wiredtiger/src/include/wiredtiger.in index 4784d990ee7..ec40bc20e70 100644 --- a/src/third_party/wiredtiger/src/include/wiredtiger.in +++ b/src/third_party/wiredtiger/src/include/wiredtiger.in @@ -1086,7 +1086,7 @@ struct __wt_session { * @config{    granularity, * this setting manages the granularity of how WiredTiger maintains modification maps * internally. The larger the granularity\, the smaller amount of information WiredTiger - * need to maintain., an integer between 1MB and 2GB; default \c 16MB.} + * need to maintain., an integer between 4KB and 2GB; default \c 16MB.} * @config{    src_id, a string that identifies a previous checkpoint * backup source as the source of this incremental backup. This identifier must have * already been created by use of the 'this_id' configuration in an earlier backup. A diff --git a/src/third_party/wiredtiger/src/reconcile/rec_visibility.c b/src/third_party/wiredtiger/src/reconcile/rec_visibility.c index b4a054a95b1..56d3f711f10 100644 --- a/src/third_party/wiredtiger/src/reconcile/rec_visibility.c +++ b/src/third_party/wiredtiger/src/reconcile/rec_visibility.c @@ -489,7 +489,6 @@ __wt_rec_upd_select(WT_SESSION_IMPL *session, WT_RECONCILE *r, WT_INSERT *ins, v select_tw->durable_start_ts = select_tw->durable_stop_ts; select_tw->start_ts = select_tw->stop_ts; - select_tw->start_txn = select_tw->stop_txn; } /* diff --git a/src/third_party/wiredtiger/src/txn/txn.c b/src/third_party/wiredtiger/src/txn/txn.c index 7fcb1ef940f..86aeabb9c29 100644 --- a/src/third_party/wiredtiger/src/txn/txn.c +++ b/src/third_party/wiredtiger/src/txn/txn.c @@ -873,15 +873,15 @@ __txn_resolve_prepared_op(WT_SESSION_IMPL *session, WT_TXN_OP *op, bool commit, WT_DECL_RET; WT_TXN *txn; WT_UPDATE *fix_upd, *tombstone, *upd; - size_t size; + size_t not_used; uint32_t hs_btree_id, session_flags; bool is_owner, upd_appended; - fix_upd = NULL; hs_cursor = NULL; txn = session->txn; + fix_upd = tombstone = NULL; session_flags = 0; - upd_appended = is_owner = false; + is_owner = upd_appended = false; WT_RET(__txn_search_prepared_op(session, op, cursorp, &upd)); @@ -933,15 +933,15 @@ __txn_resolve_prepared_op(WT_SESSION_IMPL *session, WT_TXN_OP *op, bool commit, true); if (ret == WT_NOTFOUND && !commit) { /* - * Allocate a tombstone so that when we reconcile the update chain we don't copy the - * prepared cell, which is now associated with a rolled back prepare, and instead write - * nothing. + * Allocate a tombstone and prepend it to the row so when we reconcile the update chain + * we don't copy the prepared cell, which is now associated with a rolled back prepare, + * and instead write nothing. */ - WT_ERR(__wt_upd_alloc_tombstone(session, &tombstone, &size)); - /* Apply the tombstone to the row. */ + WT_ERR(__wt_upd_alloc_tombstone(session, &tombstone, ¬_used)); WT_WITH_BTREE(session, op->btree, ret = __wt_row_modify(cbt, &cbt->iface.key, NULL, - tombstone, WT_UPDATE_INVALID, true)); + tombstone, WT_UPDATE_INVALID, false)); WT_ERR(ret); + tombstone = NULL; } else ret = 0; } @@ -1005,10 +1005,10 @@ __txn_resolve_prepared_op(WT_SESSION_IMPL *session, WT_TXN_OP *op, bool commit, WT_ERR(__txn_fixup_prepared_update(session, hs_cursor, fix_upd, commit)); err: - if (hs_cursor != NULL) - ret = __wt_hs_cursor_close(session, session_flags, is_owner); + WT_TRET(__wt_hs_cursor_close(session, session_flags, is_owner)); if (!upd_appended) __wt_free(session, fix_upd); + __wt_free(session, tombstone); return (ret); } diff --git a/src/third_party/wiredtiger/test/csuite/incr_backup/main.c b/src/third_party/wiredtiger/test/csuite/incr_backup/main.c index 68a4e4b26d1..fee64ff683a 100644 --- a/src/third_party/wiredtiger/test/csuite/incr_backup/main.c +++ b/src/third_party/wiredtiger/test/csuite/incr_backup/main.c @@ -479,6 +479,7 @@ base_backup(WT_CONNECTION *conn, WT_RAND_STATE *rand, const char *home, const ch int nfiles, ret; char buf[4096]; char *filename; + char granularity_unit; nfiles = 0; @@ -493,14 +494,18 @@ base_backup(WT_CONNECTION *conn, WT_RAND_STATE *rand, const char *home, const ch testutil_check(conn->open_session(conn, NULL, NULL, &session)); tinfo->full_backup_number = tinfo->incr_backup_number++; - /* Half of the runs with a low granularity: 1M */ - if (__wt_random(rand) % 2 == 0) - granularity = 1; - else - granularity = 1 + __wt_random(rand) % 20; + /* Half of the runs with very low granularity to stress bitmaps */ + granularity = __wt_random(rand) % 20; + if (__wt_random(rand) % 2 == 0) { + granularity_unit = 'K'; + granularity += 4; + } else { + granularity_unit = 'M'; + granularity += 1; + } testutil_check(__wt_snprintf(buf, sizeof(buf), - "incremental=(granularity=%" PRIu32 "M,enabled=true,this_id=ID%d)", granularity, - (int)tinfo->full_backup_number)); + "incremental=(granularity=%" PRIu32 "%c,enabled=true,this_id=ID%d)", granularity, + granularity_unit, (int)tinfo->full_backup_number)); VERBOSE(3, "open_cursor(session, \"backup:\", NULL, \"%s\", &cursor)\n", buf); testutil_check(session->open_cursor(session, "backup:", NULL, buf, &cursor)); diff --git a/src/third_party/wiredtiger/test/evergreen.yml b/src/third_party/wiredtiger/test/evergreen.yml index c2e748513e2..4cc34b03a89 100755 --- a/src/third_party/wiredtiger/test/evergreen.yml +++ b/src/third_party/wiredtiger/test/evergreen.yml @@ -2189,7 +2189,7 @@ tasks: posix_configure_flags: --enable-diagnostic --with-builtins=lz4,snappy,zlib - func: "format test script" vars: - test_env_vars: ASAN_OPTIONS="detect_leaks=1:abort_on_error=1:disable_coredump=0" ASAN_SYMBOLIZER_PATH=/usr/bin/llvm-symbolizer + test_env_vars: ASAN_OPTIONS="detect_leaks=1:abort_on_error=1:disable_coredump=0" ASAN_SYMBOLIZER_PATH=/usr/lib/llvm-6.0/bin/llvm-symbolizer # run for 2 hours ( 2 * 60 = 120 minutes), don't stop at failed tests, use default config format_test_script_args: -t 120 @@ -2207,7 +2207,7 @@ tasks: # to emulate the original Jenkins job's test coverage, we are running the smoke test 16 times # run smoke tests, don't stop at failed tests, use default config vars: - test_env_vars: ASAN_OPTIONS="detect_leaks=1:abort_on_error=1:disable_coredump=0" ASAN_SYMBOLIZER_PATH=/usr/bin/llvm-symbolizer + test_env_vars: ASAN_OPTIONS="detect_leaks=1:abort_on_error=1:disable_coredump=0" ASAN_SYMBOLIZER_PATH=/usr/lib/llvm-6.0/bin/llvm-symbolizer format_test_script_args: -S times: 16 diff --git a/src/third_party/wiredtiger/test/format/backup.c b/src/third_party/wiredtiger/test/format/backup.c index ca87d27f098..bfe964cf871 100644 --- a/src/third_party/wiredtiger/test/format/backup.c +++ b/src/third_party/wiredtiger/test/format/backup.c @@ -399,15 +399,16 @@ backup(void *arg) if (g.c_backup_incr_flag == INCREMENTAL_BLOCK) { /* * If we're doing a full backup as the start of the incremental backup, only send in an - * identifier for this one. + * identifier for this one. Also set the block granularity. */ if (incr_full) { active_files_free(&active[0]); active_files_free(&active[1]); active_now = &active[g.backup_id % 2]; active_prev = NULL; - testutil_check(__wt_snprintf( - cfg, sizeof(cfg), "incremental=(enabled,this_id=ID%" PRIu64 ")", g.backup_id++)); + testutil_check(__wt_snprintf(cfg, sizeof(cfg), + "incremental=(enabled,granularity=%" PRIu32 "K,this_id=ID%" PRIu64 ")", + g.c_backup_incr_granularity, g.backup_id++)); full = true; incr_full = false; } else { diff --git a/src/third_party/wiredtiger/test/format/config.c b/src/third_party/wiredtiger/test/format/config.c index f802d8eb36b..e2f933526bf 100644 --- a/src/third_party/wiredtiger/test/format/config.c +++ b/src/third_party/wiredtiger/test/format/config.c @@ -30,6 +30,7 @@ #include "config.h" static void config_backup_incr(void); +static void config_backup_incr_granularity(void); static void config_backward_compatible(void); static void config_cache(void); static void config_checkpoint(void); @@ -280,6 +281,8 @@ config_backup_incr(void) if (g.c_logging_archive) config_single("logging.archive=0", false); } + if (g.c_backup_incr_flag == INCREMENTAL_BLOCK) + config_backup_incr_granularity(); return; } @@ -308,10 +311,55 @@ config_backup_incr(void) case 9: case 10: config_single("backup.incremental=block", false); + config_backup_incr_granularity(); break; } } +/* + * config_backup_incr_granularity -- + * Configuration of block granularity for incremental backup + */ +static void +config_backup_incr_granularity(void) +{ + uint32_t granularity, i; + char confbuf[128]; + + if (config_is_perm("backup.incr_granularity")) + return; + + /* + * Three block sizes are interesting. 16MB is the default for WiredTiger and MongoDB. 1MB is the + * minimum allowed by MongoDB. Smaller sizes stress block tracking and are good for testing. The + * granularity is in units of KB. + */ + granularity = 0; + i = mmrand(NULL, 1, 10); + switch (i) { + case 1: /* 50% small size for stress testing */ + case 2: + case 3: + case 4: + case 5: + granularity = 4 * i; + break; + case 6: /* 20% 1MB granularity */ + case 7: + granularity = 1024; + break; + case 8: /* 30% 16MB granularity */ + case 9: + case 10: + granularity = 16 * 1024; + break; + } + + testutil_check( + __wt_snprintf(confbuf, sizeof(confbuf), "backup.incr_granularity=%u", granularity)); + config_single(confbuf, false); +} + /* * config_backward_compatible -- * Backward compatibility configuration. diff --git a/src/third_party/wiredtiger/test/format/config.h b/src/third_party/wiredtiger/test/format/config.h index cef2eda6142..30b8f2a09a6 100644 --- a/src/third_party/wiredtiger/test/format/config.h +++ b/src/third_party/wiredtiger/test/format/config.h @@ -74,6 +74,9 @@ static CONFIG c[] = { {"backup.incremental", "type of backup (block | log | off)", C_IGNORE | C_STRING, 0, 0, 0, NULL, &g.c_backup_incremental}, + {"backup.incr_granularity", "incremental backup block granularity in KB", 0x0, 4, 16384, 16384, + &g.c_backup_incr_granularity, NULL}, + {"btree.bitcnt", "number of bits for fixed-length column-store files", 0x0, 1, 8, 8, &g.c_bitcnt, NULL}, diff --git a/src/third_party/wiredtiger/test/format/format.h b/src/third_party/wiredtiger/test/format/format.h index 9416c45cd60..7f5230709fe 100644 --- a/src/third_party/wiredtiger/test/format/format.h +++ b/src/third_party/wiredtiger/test/format/format.h @@ -138,6 +138,7 @@ typedef struct { uint32_t c_assert_read_timestamp; uint32_t c_auto_throttle; char *c_backup_incremental; + uint32_t c_backup_incr_granularity; uint32_t c_backups; uint32_t c_bitcnt; uint32_t c_bloom; diff --git a/src/third_party/wiredtiger/test/format/smoke.sh b/src/third_party/wiredtiger/test/format/smoke.sh index de46580c078..067ef8e2589 100755 --- a/src/third_party/wiredtiger/test/format/smoke.sh +++ b/src/third_party/wiredtiger/test/format/smoke.sh @@ -3,6 +3,7 @@ set -e # Smoke-test format as part of running "make check". +args="-1 -c . " args="$args btree.compression=none " args="$args logging_compression=none" args="$args runs.ops=50000 " @@ -10,18 +11,11 @@ args="$args runs.rows=10000 " args="$args runs.source=table " args="$args runs.threads=4 " -# Locate format.sh from home directory. -FORMAT_SCRIPT=$(git rev-parse --show-toplevel)/test/format/format.sh - # Temporarily disabled -# $FORMAT_SCRIPT -t 2 $args runs.type=fix -# $FORMAT_SCRIPT -t 2 $args runs.type=row runs.source=lsm -# $FORMAT_SCRIPT -t 2 $args runs.type=var - -# Run the format script for 10 minutues, distribute it across the number -# of different test arguments. - -# This will run the test/format binary for 5 minutes each. -$FORMAT_SCRIPT -t 5 $args runs.type=row +# $TEST_WRAPPER ./t $args runs.type=fix +# $TEST_WRAPPER ./t $args runs.type=row runs.source=lsm +# $TEST_WRAPPER ./t $args runs.type=var -$FORMAT_SCRIPT -t 5 $args runs.type=row statistics.server=1 ops.rebalance=1 +$TEST_WRAPPER ./t $args runs.type=row +# Force a rebalance to occur with statistics logging to test the utility +$TEST_WRAPPER ./t $args runs.type=row statistics.server=1 ops.rebalance=1 diff --git a/src/third_party/wiredtiger/test/suite/test_compat02.py b/src/third_party/wiredtiger/test/suite/test_compat02.py index e3397d0d7ea..8d44b25d7ba 100644 --- a/src/third_party/wiredtiger/test/suite/test_compat02.py +++ b/src/third_party/wiredtiger/test/suite/test_compat02.py @@ -110,7 +110,9 @@ class test_compat02(wttest.WiredTigerTestCase, suite_subprocess): ('basecfg_true', dict(basecfg='true')), ('basecfg_false', dict(basecfg='false')), ] - scenarios = make_scenarios(compat_create, compat_release, compat_min, compat_max, base_config) + + scenarios = make_scenarios(compat_create, compat_release, compat_min, compat_max, base_config, + prune=100, prunelong=100000) def conn_config(self): # Set archive false on the home directory. -- cgit v1.2.1