int main(int argc, char *argv[]) { START(argc, argv, "libpmempool_rm"); if (argc < 2) FATAL_USAGE(argv[0]); unsigned flags = 0; char *optstr = "flro"; int do_open = 0; int opt; while ((opt = getopt(argc, argv, optstr)) != -1) { switch (opt) { case 'f': flags |= PMEMPOOL_RM_FORCE; break; case 'r': flags |= PMEMPOOL_RM_POOLSET_REMOTE; break; case 'l': flags |= PMEMPOOL_RM_POOLSET_LOCAL; break; case 'o': do_open = 1; break; default: FATAL_USAGE(argv[0]); } } for (int i = optind; i < argc; i++) { const char *path = argv[i]; if (do_open) { Pop = pmemobj_open(path, NULL); UT_ASSERTne(Pop, NULL); } int ret = pmempool_rm(path, flags); if (ret) { UT_OUT("!%s: %s", path, pmempool_errormsg()); } if (do_open) { UT_ASSERTne(Pop, NULL); pmemobj_close(Pop); } } DONE(NULL); }
/* * cleanup -- (internal) clean up after each run */ static void cleanup(char test_type) { switch (test_type) { case 'm': os_mutex_destroy(&((PMEMmutex_internal *) &(Test_obj->mutex))->PMEMmutex_lock); break; case 'r': os_rwlock_destroy(&((PMEMrwlock_internal *) &(Test_obj->rwlock))->PMEMrwlock_lock); break; case 'c': os_mutex_destroy(&((PMEMmutex_internal *) &(Test_obj->mutex))->PMEMmutex_lock); os_cond_destroy(&((PMEMcond_internal *) &(Test_obj->cond))->PMEMcond_cond); break; case 't': os_mutex_destroy(&((PMEMmutex_internal *) &(Test_obj->mutex))->PMEMmutex_lock); os_mutex_destroy(&((PMEMmutex_internal *) &(Test_obj->mutex_locked))->PMEMmutex_lock); break; default: FATAL_USAGE(); } }
int main(int argc, char *argv[]) { START(argc, argv, "obj_redo_log"); util_init(); if (argc < 4) FATAL_USAGE(); PMEMobjpool *pop = pmemobj_open_mock(argv[1]); UT_ASSERTne(pop, NULL); UT_ASSERTeq(util_is_zeroed((char *)pop->addr + PMEMOBJ_POOL_HDR_SIZE, pop->size - PMEMOBJ_POOL_HDR_SIZE), 1); char *end = NULL; errno = 0; size_t redo_size = strtoul(argv[2], &end, 0); if (errno || !end || *end != '\0') FATAL_USAGE(); UT_ASSERT(pop->size >= redo_size * sizeof(struct redo_log)); struct redo_log *redo = (struct redo_log *)pop->addr; uint64_t offset; uint64_t value; int i; int ret; size_t index; for (i = 3; i < argc; i++) { char *arg = argv[i]; UT_ASSERTne(arg, NULL); switch (arg[0]) { case 's': if (sscanf(arg, "s:%ld:0x%lx:0x%lx", &index, &offset, &value) != 3) FATAL_USAGE(); UT_OUT("s:%ld:0x%08lx:0x%08lx", index, offset, value); redo_log_store(pop, redo, index, offset, value); break; case 'f': if (sscanf(arg, "f:%ld:0x%lx:0x%lx", &index, &offset, &value) != 3) FATAL_USAGE(); UT_OUT("f:%ld:0x%08lx:0x%08lx", index, offset, value); redo_log_store_last(pop, redo, index, offset, value); break; case 'F': if (sscanf(arg, "F:%ld", &index) != 1) FATAL_USAGE(); UT_OUT("F:%ld", index); redo_log_set_last(pop, redo, index); break; case 'r': if (sscanf(arg, "r:0x%lx", &offset) != 1) FATAL_USAGE(); uint64_t *valp = (uint64_t *)((uintptr_t)pop->addr + offset); UT_OUT("r:0x%08lx:0x%08lx", offset, *valp); break; case 'e': if (sscanf(arg, "e:%ld", &index) != 1) FATAL_USAGE(); struct redo_log *entry = redo + index; int flag = (entry->offset & REDO_FINISH_FLAG) ? 1 : 0; offset = entry->offset & REDO_FLAG_MASK; value = entry->value; UT_OUT("e:%ld:0x%08lx:%d:0x%08lx", index, offset, flag, value); break; case 'P': redo_log_process(pop, redo, redo_size); UT_OUT("P"); break; case 'R': redo_log_recover(pop, redo, redo_size); UT_OUT("R"); break; case 'C': ret = redo_log_check(pop, redo, redo_size); UT_OUT("C:%d", ret); break; default: FATAL_USAGE(); } } pmemobj_close_mock(pop); DONE(NULL); }
int main(int argc, char *argv[]) { START(argc, argv, "obj_sync"); util_init(); if (argc < 4) FATAL_USAGE(); worker writer; worker checker; char test_type = argv[1][0]; switch (test_type) { case 'm': writer = mutex_write_worker; checker = mutex_check_worker; break; case 'r': writer = rwlock_write_worker; checker = rwlock_check_worker; break; case 'c': writer = cond_write_worker; checker = cond_check_worker; break; case 't': writer = timed_write_worker; checker = timed_check_worker; break; default: FATAL_USAGE(); } unsigned long num_threads = strtoul(argv[2], NULL, 10); if (num_threads > MAX_THREAD_NUM) UT_FATAL("Do not use more than %d threads.\n", MAX_THREAD_NUM); unsigned long opens = strtoul(argv[3], NULL, 10); if (opens > MAX_OPENS) UT_FATAL("Do not use more than %d runs.\n", MAX_OPENS); os_thread_t *write_threads = (os_thread_t *)MALLOC(num_threads * sizeof(os_thread_t)); os_thread_t *check_threads = (os_thread_t *)MALLOC(num_threads * sizeof(os_thread_t)); /* first pool open */ mock_open_pool(&Mock_pop); Mock_pop.p_ops.persist = obj_sync_persist; Mock_pop.p_ops.base = &Mock_pop; Test_obj = (struct mock_obj *)MALLOC(sizeof(struct mock_obj)); /* zero-initialize the test object */ pmemobj_mutex_zero(&Mock_pop, &Test_obj->mutex); pmemobj_mutex_zero(&Mock_pop, &Test_obj->mutex_locked); pmemobj_cond_zero(&Mock_pop, &Test_obj->cond); pmemobj_rwlock_zero(&Mock_pop, &Test_obj->rwlock); Test_obj->check_data = 0; memset(&Test_obj->data, 0, DATA_SIZE); for (unsigned long run = 0; run < opens; run++) { if (test_type == 't') { pmemobj_mutex_lock(&Mock_pop, &Test_obj->mutex_locked); } for (unsigned i = 0; i < num_threads; i++) { PTHREAD_CREATE(&write_threads[i], NULL, writer, (void *)(uintptr_t)i); PTHREAD_CREATE(&check_threads[i], NULL, checker, (void *)(uintptr_t)i); } for (unsigned i = 0; i < num_threads; i++) { PTHREAD_JOIN(&write_threads[i], NULL); PTHREAD_JOIN(&check_threads[i], NULL); } if (test_type == 't') { pmemobj_mutex_unlock(&Mock_pop, &Test_obj->mutex_locked); } /* up the run_id counter and cleanup */ mock_open_pool(&Mock_pop); cleanup(test_type); } FREE(check_threads); FREE(write_threads); FREE(Test_obj); DONE(NULL); }