int
main(int argc, char *argv[])
{
START(argc, argv, "obj_pvector");
if (argc != 2)
UT_FATAL("usage: %s [file]", argv[0]);
const char *path = argv[1];
PMEMobjpool *pop;
if ((pop = pmemobj_create(path, "obj_pvector",
PMEMOBJ_MIN_POOL, S_IWUSR | S_IRUSR)) == NULL)
UT_FATAL("!pmemobj_create: %s", path);
PMEMoid root = pmemobj_root(pop, sizeof(struct test_root));
struct test_root *r = pmemobj_direct(root);
UT_ASSERTne(r, NULL);
struct pvector_context *ctx = pvector_new(pop, &r->vec);
uint64_t *val = pvector_push_back(ctx);
*val = 5;
val = pvector_push_back(ctx);
*val = 10;
val = pvector_push_back(ctx);
*val = 15;
uint64_t v;
int n = 0;
for (v = pvector_first(ctx); v != 0; v = pvector_next(ctx)) {
if (n == 0)
UT_ASSERTeq(v, 5);
if (n == 1)
UT_ASSERTeq(v, 10);
if (n == 2)
UT_ASSERTeq(v, 15);
if (n == 3)
UT_ASSERT(0);
n++;
}
uint64_t removed = pvector_pop_back(ctx, NULL);
UT_ASSERTeq(removed, 15);
n = 0;
for (v = pvector_first(ctx); v != 0; v = pvector_next(ctx)) {
if (n == 0)
UT_ASSERTeq(v, 5);
if (n == 1)
UT_ASSERTeq(v, 10);
if (n == 3)
UT_ASSERT(0);
n++;
}
while (pvector_pop_back(ctx, vec_zero_entry) != 0)
;
pvector_delete(ctx);
ctx = pvector_new(pop, &r->vec);
for (int i = 0; i < PVECTOR_INSERT_VALUES; ++i) {
val = pvector_push_back(ctx);
UT_ASSERTne(val, NULL);
*val = i;
}
n = 0;
for (v = pvector_first(ctx); v != 0; v = pvector_next(ctx)) {
UT_ASSERTeq(v, n);
n++;
}
n = 0;
for (int i = PVECTOR_INSERT_VALUES - 1; i >= 0; --i) {
v = pvector_pop_back(ctx, NULL);
UT_ASSERTeq(v, i);
}
UT_ASSERTeq(pvector_first(ctx), 0);
pvector_delete(ctx);
pmemobj_close(pop);
DONE(NULL);
}
int
main(int argc, char *argv[])
{
START(argc, argv, "obj_direct");
if (argc != 3)
UT_FATAL("usage: %s [directory] [# of pools]", argv[0]);
int npools = atoi(argv[2]);
const char *dir = argv[1];
int r;
PMEMobjpool *pops[npools];
void *guard_after[npools];
char path[MAX_PATH_LEN];
for (int i = 0; i < npools; ++i) {
snprintf(path, MAX_PATH_LEN, "%s/testfile%d", dir, i);
pops[i] = pmemobj_create(path, LAYOUT_NAME, PMEMOBJ_MIN_POOL,
S_IWUSR | S_IRUSR);
/*
* Reserve a page after the pool for address checks, if it
* doesn't map precisely at that address - it's OK.
*/
guard_after[i] =
MMAP((char *)pops[i] + PMEMOBJ_MIN_POOL, Ut_pagesize,
PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
UT_ASSERTne(guard_after[i], NULL);
if (pops[i] == NULL)
UT_FATAL("!pmemobj_create");
}
PMEMoid oids[npools];
for (int i = 0; i < npools; ++i) {
r = pmemobj_alloc(pops[i], &oids[i], ALLOC_SIZE, 1, NULL, NULL);
UT_ASSERTeq(r, 0);
}
PMEMoid invalid = {123, 321};
UT_ASSERTeq(pmemobj_pool_by_oid(OID_NULL), NULL);
UT_ASSERTeq(pmemobj_pool_by_oid(invalid), NULL);
for (int i = 0; i < npools; ++i) {
UT_ASSERTeq(pmemobj_pool_by_oid(oids[i]), pops[i]);
}
UT_ASSERTeq(pmemobj_pool_by_ptr(NULL), NULL);
UT_ASSERTeq(pmemobj_pool_by_ptr((void *)0xCBA), NULL);
for (int i = 0; i < npools; ++i) {
void *before_pool = (char *)pops[i] - 1;
void *after_pool = (char *)pops[i] + PMEMOBJ_MIN_POOL + 1;
void *edge = (char *)pops[i] + PMEMOBJ_MIN_POOL;
void *middle = (char *)pops[i] + (PMEMOBJ_MIN_POOL / 2);
void *in_oid = (char *)pmemobj_direct(oids[i]) +
(ALLOC_SIZE / 2);
UT_ASSERTeq(pmemobj_pool_by_ptr(before_pool), NULL);
UT_ASSERTeq(pmemobj_pool_by_ptr(after_pool), NULL);
UT_ASSERTeq(pmemobj_pool_by_ptr(edge), NULL);
UT_ASSERTeq(pmemobj_pool_by_ptr(middle), pops[i]);
UT_ASSERTeq(pmemobj_pool_by_ptr(in_oid), pops[i]);
pmemobj_close(pops[i]);
UT_ASSERTeq(pmemobj_pool_by_ptr(middle), NULL);
UT_ASSERTeq(pmemobj_pool_by_ptr(in_oid), NULL);
MUNMAP(guard_after[i], Ut_pagesize);
}
DONE(NULL);
}
int
main(int argc, char *argv[])
{
START(argc, argv, "obj_direct");
if (argc != 3)
UT_FATAL("usage: %s [directory] [# of pools]", argv[0]);
int npools = atoi(argv[2]);
const char *dir = argv[1];
int r;
pthread_mutex_init(&lock1, NULL);
pthread_mutex_init(&lock2, NULL);
pthread_cond_init(&sync_cond1, NULL);
pthread_cond_init(&sync_cond2, NULL);
cond1 = cond2 = 0;
PMEMobjpool **pops = MALLOC(npools * sizeof(PMEMobjpool *));
UT_ASSERTne(pops, NULL);
char path[MAX_PATH_LEN];
for (int i = 0; i < npools; ++i) {
snprintf(path, MAX_PATH_LEN, "%s/testfile%d", dir, i);
pops[i] = pmemobj_create(path, LAYOUT_NAME, PMEMOBJ_MIN_POOL,
S_IWUSR | S_IRUSR);
if (pops[i] == NULL)
UT_FATAL("!pmemobj_create");
}
PMEMoid *oids = MALLOC(npools * sizeof(PMEMoid));
UT_ASSERTne(oids, NULL);
PMEMoid *tmpoids = MALLOC(npools * sizeof(PMEMoid));
UT_ASSERTne(tmpoids, NULL);
oids[0] = OID_NULL;
UT_ASSERTeq(pmemobj_direct(oids[0]), NULL);
for (int i = 0; i < npools; ++i) {
oids[i] = (PMEMoid) {pops[i]->uuid_lo, 0};
UT_ASSERTeq(pmemobj_direct(oids[i]), NULL);
uint64_t off = pops[i]->heap_offset;
oids[i] = (PMEMoid) {pops[i]->uuid_lo, off};
UT_ASSERTeq((char *)pmemobj_direct(oids[i]) - off,
(char *)pops[i]);
r = pmemobj_alloc(pops[i], &tmpoids[i], 100, 1, NULL, NULL);
UT_ASSERTeq(r, 0);
}
r = pmemobj_alloc(pops[0], &thread_oid, 100, 2, NULL, NULL);
UT_ASSERTeq(r, 0);
UT_ASSERTne(pmemobj_direct(thread_oid), NULL);
pthread_t t;
PTHREAD_CREATE(&t, NULL, test_worker, NULL);
/* wait for the worker thread to perform the first check */
pthread_mutex_lock(&lock1);
while (!cond1)
pthread_cond_wait(&sync_cond1, &lock1);
pthread_mutex_unlock(&lock1);
for (int i = 0; i < npools; ++i) {
UT_ASSERTne(pmemobj_direct(tmpoids[i]), NULL);
pmemobj_free(&tmpoids[i]);
UT_ASSERTeq(pmemobj_direct(tmpoids[i]), NULL);
pmemobj_close(pops[i]);
UT_ASSERTeq(pmemobj_direct(oids[i]), NULL);
}
/* signal the worker that we're free and closed */
pthread_mutex_lock(&lock2);
cond2 = 1;
pthread_cond_signal(&sync_cond2);
pthread_mutex_unlock(&lock2);
PTHREAD_JOIN(t, NULL);
pthread_cond_destroy(&sync_cond1);
pthread_cond_destroy(&sync_cond2);
pthread_mutex_destroy(&lock1);
pthread_mutex_destroy(&lock2);
FREE(pops);
FREE(tmpoids);
FREE(oids);
DONE(NULL);
}
int
main(int argc, char *argv[])
{
START(argc, argv, "obj_direct");
if (argc != 3)
FATAL("usage: %s [directory] [# of pools]", argv[0]);
int npools = atoi(argv[2]);
const char *dir = argv[1];
int r;
PMEMobjpool *pops[npools];
char path[MAX_PATH_LEN];
for (int i = 0; i < npools; ++i) {
snprintf(path, MAX_PATH_LEN, "%s/testfile%d", dir, i);
pops[i] = pmemobj_create(path, LAYOUT_NAME, PMEMOBJ_MIN_POOL,
S_IWUSR | S_IRUSR);
if (pops[i] == NULL)
FATAL("!pmemobj_create");
}
PMEMoid oids[npools];
PMEMoid tmpoids[npools];
oids[0] = OID_NULL;
ASSERTeq(pmemobj_direct(oids[0]), NULL);
for (int i = 0; i < npools; ++i) {
oids[i] = (PMEMoid) {pops[i]->uuid_lo, 0};
ASSERTeq(pmemobj_direct(oids[i]), NULL);
uint64_t off = pops[i]->heap_offset;
oids[i] = (PMEMoid) {pops[i]->uuid_lo, off};
ASSERTeq((char *)pmemobj_direct(oids[i]) - off,
(char *)pops[i]);
r = pmemobj_alloc(pops[i], &tmpoids[i], 100, 1, NULL, NULL);
ASSERTeq(r, 0);
}
r = pmemobj_alloc(pops[0], &thread_oid, 100, 2, NULL, NULL);
ASSERTeq(r, 0);
ASSERTne(pmemobj_direct(thread_oid), NULL);
pthread_mutex_lock(&lock);
pthread_t t;
pthread_create(&t, NULL, test_worker, NULL);
/* wait for the thread to perform the first direct */
while (flag)
;
for (int i = 0; i < npools; ++i) {
ASSERTne(pmemobj_direct(tmpoids[i]), NULL);
pmemobj_free(&tmpoids[i]);
ASSERTeq(pmemobj_direct(tmpoids[i]), NULL);
pmemobj_close(pops[i]);
ASSERTeq(pmemobj_direct(oids[i]), NULL);
}
pthread_mutex_unlock(&lock);
pthread_join(t, NULL);
DONE(NULL);
}
