int
main(int argc, char *argv[])
{
TEST_OPTS *opts, _opts;
TEST_PER_THREAD_OPTS thread_args[N_THREADS];
pthread_t ckpt_thread, mon_thread, threads[N_THREADS];
int i;
/*
* This test should not run unless long tests flag is set. The test
* runs for 15 minutes.
*/
if (!testutil_is_flag_set("TESTUTIL_ENABLE_TIMING_TESTS"))
return (EXIT_SUCCESS);
opts = &_opts;
opts->unique_id = 0;
memset(opts, 0, sizeof(*opts));
testutil_check(testutil_parse_opts(argc, argv, opts));
testutil_make_work_dir(opts->home);
testutil_check(wiredtiger_open(opts->home, &event_handler,
"create,cache_size=1G,timing_stress_for_test=[checkpoint_slow]",
&opts->conn));
testutil_check(pthread_create(
&ckpt_thread, NULL, do_checkpoints, opts));
for (i = 0; i < N_THREADS; ++i) {
thread_args[i].testopts = opts;
thread_args[i].thread_counter = 0;
thread_args[i].threadnum = i;
testutil_check(pthread_create(
&threads[i], NULL, do_ops, &thread_args[i]));
}
/*
* Pass the whole array of thread arguments to the monitoring thread.
* This thread will need to monitor each threads counter to track if it
* is stuck.
*/
testutil_check(pthread_create(&mon_thread, NULL, monitor, thread_args));
for (i = 0; i < N_THREADS; ++i)
testutil_check(pthread_join(threads[i], NULL));
testutil_check(pthread_join(mon_thread, NULL));
testutil_check(pthread_join(ckpt_thread, NULL));
printf("Success\n");
testutil_cleanup(opts);
return (EXIT_SUCCESS);
}
/*
* main --
* The main program for the test. When invoked with "subtest"
* argument, run the subtest. Otherwise, run a separate process
* for each needed subtest, and check the results.
*/
int
main(int argc, char *argv[])
{
TEST_OPTS *opts, _opts;
uint64_t nresults;
const char *debugger;
/* Ignore unless requested */
if (!testutil_is_flag_set("TESTUTIL_ENABLE_LONG_TESTS"))
return (EXIT_SUCCESS);
opts = &_opts;
memset(opts, 0, sizeof(*opts));
debugger = NULL;
testutil_check(testutil_parse_opts(argc, argv, opts));
argc -= __wt_optind;
argv += __wt_optind;
if (opts->nrecords == 0)
opts->nrecords = 50000;
while (argc > 0) {
if (strcmp(argv[0], "subtest") == 0) {
subtest_main(argc, argv, false);
return (0);
} else if (strcmp(argv[0], "subtest_close") == 0) {
subtest_main(argc, argv, true);
return (0);
} else if (strcmp(argv[0], "gdb") == 0)
debugger = "/usr/bin/gdb";
else
testutil_assert(false);
argc--;
argv++;
}
if (opts->verbose) {
printf("Number of operations until failure: %" PRIu64
" (change with -o N)\n", opts->nops);
printf("Number of records: %" PRIu64
" (change with -n N)\n", opts->nrecords);
}
if (opts->nops == 0) {
run_check_subtest_range(opts, debugger, false);
run_check_subtest_range(opts, debugger, true);
} else
run_check_subtest(opts, debugger, opts->nops,
opts->nrecords, &nresults);
testutil_clean_work_dir(opts->home);
testutil_cleanup(opts);
return (0);
}
int
main(int argc, char *argv[])
{
WT_SESSION *session;
clock_t ce, cs;
pthread_t idlist[100];
uint64_t i, id;
char buf[100];
/* Bypass this test for valgrind */
if (testutil_is_flag_set("TESTUTIL_BYPASS_VALGRIND"))
return (EXIT_SUCCESS);
opts = &_opts;
memset(opts, 0, sizeof(*opts));
opts->table_type = TABLE_ROW;
opts->n_append_threads = N_APPEND_THREADS;
opts->nrecords = N_RECORDS;
testutil_check(testutil_parse_opts(argc, argv, opts));
testutil_make_work_dir(opts->home);
testutil_check(__wt_snprintf(buf, sizeof(buf),
"create,"
"cache_size=%s,"
"eviction=(threads_max=5),"
"statistics=(fast)",
opts->table_type == TABLE_FIX ? "500MB" : "2GB"));
testutil_check(wiredtiger_open(opts->home, NULL, buf, &opts->conn));
testutil_check(
opts->conn->open_session(opts->conn, NULL, NULL, &session));
testutil_check(__wt_snprintf(buf, sizeof(buf),
"key_format=r,value_format=%s,"
"allocation_size=4K,leaf_page_max=64K",
opts->table_type == TABLE_FIX ? "8t" : "S"));
testutil_check(session->create(session, opts->uri, buf));
testutil_check(session->close(session, NULL));
page_init(5000);
/* Force to disk and re-open. */
testutil_check(opts->conn->close(opts->conn, NULL));
testutil_check(wiredtiger_open(opts->home, NULL, NULL, &opts->conn));
(void)signal(SIGINT, onsig);
cs = clock();
id = 0;
for (i = 0; i < opts->n_append_threads; ++i, ++id) {
printf("append: %" PRIu64 "\n", id);
testutil_check(
pthread_create(&idlist[id], NULL, thread_append, opts));
}
for (i = 0; i < id; ++i)
testutil_check(pthread_join(idlist[i], NULL));
ce = clock();
printf("%" PRIu64 "M records: %.2lf processor seconds\n",
opts->max_inserted_id / MILLION,
(ce - cs) / (double)CLOCKS_PER_SEC);
testutil_cleanup(opts);
return (EXIT_SUCCESS);
}
int
main(int argc, char *argv[])
{
static const struct {
u_int workers;
u_int uris;
bool cache_cursors;
} runs[] = {
{ 1, 1, false},
{ 1, 1, true},
{ 8, 1, false},
{ 8, 1, true},
{ 16, 1, false},
{ 16, 1, true},
{ 16, WT_ELEMENTS(uri_list), false},
{ 16, WT_ELEMENTS(uri_list), true},
{200, 100, false},
{200, 100, true},
{200, WT_ELEMENTS(uri_list), false},
{200, WT_ELEMENTS(uri_list), true},
{300, 100, false},
{300, 100, true},
{600, WT_ELEMENTS(uri_list), false},
{600, WT_ELEMENTS(uri_list), true},
};
WT_RAND_STATE rnd;
u_int i, n;
int ch;
/*
* Bypass this test for valgrind. It has a fairly low thread limit.
*/
if (testutil_is_flag_set("TESTUTIL_BYPASS_VALGRIND"))
return (EXIT_SUCCESS);
(void)testutil_set_progname(argv);
__wt_random_init_seed(NULL, &rnd);
while ((ch = __wt_getopt(argv[0], argc, argv, "v")) != EOF) {
switch (ch) {
case 'v':
verbose = true;
break;
default:
fprintf(stderr, "usage: %s [-v]\n", argv[0]);
return (EXIT_FAILURE);
}
}
(void)signal(SIGALRM, on_alarm);
/* Each test in the table runs for a minute, run 5 tests at random. */
for (i = 0; i < 5; ++i) {
n = __wt_random(&rnd) % WT_ELEMENTS(runs);
workers = runs[n].workers;
uris = runs[n].uris;
run(runs[n].cache_cursors);
}
uri_teardown();
return (EXIT_SUCCESS);
}
