static void
test_one_way(void)
{
int i, k;
int pe_size = world_size;
tmp = 0;
total = 0;
shmem_barrier_all();
if (world_size % 2 == 1) {
pe_size = world_size - 1;
}
if (!(world_size % 2 == 1 && rank == (world_size - 1))) {
if (rank < world_size / 2) {
for (i = 0 ; i < niters ; ++i) {
cache_invalidate();
shmem_barrier(0, 0, pe_size, barrier_pSync);
tmp = timer();
for (k = 0 ; k < nmsgs ; ++k) {
shmem_putmem(recv_buf + (nbytes * k),
send_buf + (nbytes * k),
nbytes, rank + (world_size / 2));
}
shmem_quiet();
total += (timer() - tmp);
}
} else {
for (i = 0 ; i < niters ; ++i) {
cache_invalidate();
shmem_barrier(0, 0, pe_size, barrier_pSync);
tmp = timer();
shmem_short_wait((short*) (recv_buf + (nbytes * (nmsgs - 1))), 0);
total += (timer() - tmp);
memset(recv_buf, 0, npeers * nmsgs * nbytes);
}
}
shmem_double_sum_to_all(&tmp, &total, 1, 0, 0, pe_size, reduce_pWrk, reduce_pSync);
display_result("single direction", (niters * nmsgs) / (tmp / world_size));
}
shmem_barrier_all();
}
static void
cache_invalidate_dir(const char *path)
{
cache_invalidate(path);
const char *s = strrchr(path, '/');
if(s) {
if(s == path)
g_hash_table_remove(cache.files, "/");
else {
char *parent = g_strndup(path, s - path);
cache_invalidate(parent);
free(parent);
}
}
}
static void
test_prepost(void)
{
int i, j, k;
tmp = 0;
total = 0;
shmem_barrier_all();
for (i = 0 ; i < niters - 1 ; ++i) {
cache_invalidate();
shmem_barrier_all();
tmp = timer();
for (j = 0 ; j < npeers ; ++j) {
for (k = 0 ; k < nmsgs ; ++k) {
shmem_putmem(recv_buf + (nbytes * (k + j * nmsgs)),
send_buf + (nbytes * (k + j * nmsgs)),
nbytes, send_peers[npeers - j - 1]);
}
}
shmem_quiet();
shmem_short_wait((short*) (recv_buf + (nbytes * ((nmsgs - 1) + (npeers - 1) * nmsgs))), 0);
total += (timer() - tmp);
memset(recv_buf, 0, npeers * nmsgs * nbytes);
}
shmem_double_sum_to_all(&tmp, &total, 1, 0, 0, world_size, reduce_pWrk, reduce_pSync);
display_result("pre-post", (niters * npeers * nmsgs * 2) / (tmp / world_size));
}
int rp (int argc, char *argv[])
{
cache_invalidate();
replay_log(VolA);
return 0;
}
int clearp (int argc, char *argv[])
{
cache_invalidate();
return 0;
}
void test_prepostME(int cache_size,
int *cache_buf,
ptl_handle_ni_t ni,
int npeers,
int nmsgs,
int nbytes,
int niters)
{
int i, j, k;
double tmp, total = 0;
ptl_handle_md_t send_md_handle;
ptl_md_t send_md;
ptl_process_t dest;
ptl_size_t offset;
ptl_pt_index_t index;
ptl_handle_eq_t recv_eq_handle;
ptl_handle_me_t me_handles[npeers * nmsgs];
ptl_event_t event;
ptl_assert(PtlEQAlloc(ni, nmsgs * npeers + 1,
&send_md.eq_handle), PTL_OK);
send_md.start = send_buf;
send_md.length = SEND_BUF_SIZE;
send_md.options = PTL_MD_UNORDERED;
send_md.ct_handle = PTL_CT_NONE;
ptl_assert(PtlMDBind(ni, &send_md, &send_md_handle), PTL_OK);
ptl_assert(PtlEQAlloc(ni, nmsgs * npeers + 1, &recv_eq_handle), PTL_OK);
ptl_assert(PtlPTAlloc(ni, 0, recv_eq_handle, TestSameDirectionIndex,
&index), PTL_OK);
ptl_assert(TestSameDirectionIndex, index);
tmp = timer();
for (j = 0; j < npeers; ++j) {
for (k = 0; k < nmsgs; ++k) {
ptl_process_t src;
src.rank = recv_peers[j];
postME(ni, index, recv_buf + (nbytes * (k + j * nmsgs)),
nbytes, src, magic_tag, &me_handles[k + j * nmsgs]);
}
}
total += (timer() - tmp);
for (i = 0; i < niters - 1; ++i) {
cache_invalidate(cache_size, cache_buf);
libtest_Barrier();
tmp = timer();
for (j = 0; j < npeers; ++j) {
for (k = 0; k < nmsgs; ++k) {
offset = (nbytes * (k + j * nmsgs));
dest.rank = send_peers[npeers - j - 1],
ptl_assert(libtest_Put_offset(send_md_handle, offset, nbytes,
dest, index, magic_tag, offset), PTL_OK);
}
}
/* wait for sends */
for (j = 0; j < npeers * nmsgs; ++j) {
ptl_assert(PtlEQWait(send_md.eq_handle, &event), PTL_OK);
ptl_assert(event.type, PTL_EVENT_SEND);
}
/* wait for receives */
for (j = 0; j < npeers * nmsgs; j++) {
PtlEQWait(recv_eq_handle, &event);
}
for (j = 0; j < npeers; ++j) {
for (k = 0; k < nmsgs; ++k) {
ptl_process_t src;
src.rank = recv_peers[j];
postME(ni, index, recv_buf + (nbytes * (k + j * nmsgs)),
nbytes, src, magic_tag, &me_handles[k + j * nmsgs]);
}
}
total += (timer() - tmp);
}
libtest_Barrier();
tmp = timer();
for (j = 0; j < npeers; ++j) {
for (k = 0; k < nmsgs; ++k) {
offset = (nbytes * (k + j * nmsgs));
dest.rank = send_peers[npeers - j - 1],
ptl_assert(libtest_Put_offset(send_md_handle, offset, nbytes, dest,
index, magic_tag, offset), PTL_OK);
}
}
/* wait for sends */
for (j = 0; j < npeers * nmsgs; ++j) {
ptl_assert(PtlEQWait(send_md.eq_handle, &event), PTL_OK);
ptl_assert(event.type, PTL_EVENT_SEND);
}
/* wait for receives */
for (j = 0; j < npeers * nmsgs; j++) {
PtlEQWait(recv_eq_handle, &event);
}
total += (timer() - tmp);
ptl_assert(PtlEQFree(send_md.eq_handle), PTL_OK);
ptl_assert(PtlMDRelease(send_md_handle), PTL_OK);
ptl_assert(PtlEQFree(recv_eq_handle), PTL_OK);
ptl_assert(PtlPTFree(ni, index), PTL_OK);
tmp = libtest_AllreduceDouble(total, PTL_SUM);
display_result("pre-post", (niters * npeers * nmsgs * 2) / (tmp / world_size));
}
file_t* file_open(const char* path, int forcenew)
{
file_handle_t handle = INVALID_FILE_HANDLE;
file_hdr_t* hdr = NULL;
file_t* file;
int result;
u32 size;
if (system_page_size == 0) {
if (get_system_page_size() < 0)
return NULL;
}
/* Open/create the backing file. */
result = os_open_file(path, &handle);
if (result < 0)
goto error;
/* Make sure the file is at least 16 pages in size. */
if (os_get_file_size(handle, &size) < 0)
goto error;
if (size < MIN_FILE_SIZE) {
if (os_set_file_size(handle, MIN_FILE_SIZE, &size) < 0)
goto error;
if (size < MIN_FILE_SIZE) {
fprintf(stderr, "file_open: file with size %u is smaller than the"
" minimum size (%u)\n", size, MIN_FILE_SIZE);
goto error;
}
}
/* Map the first page of the file as the B-Tree's header. */
hdr = (file_hdr_t*)os_get_page(handle, 0);
if (hdr == NULL)
goto error;
if ((result == 0) && (forcenew == 0)) {
DPRINT("Opening existing file\n");
/* Existing file: validate the cookie. */
if (hdr->cookie != FILE_COOKIE) {
fprintf(stderr, "Found a bad file cookie (%x) while opening %s",
hdr->cookie, path);
goto error;
}
}
else {
DPRINT("Creating a new file\n");
/* New file. Initialize the header. */
hdr->cookie = FILE_COOKIE;
hdr->head = 0;
hdr->tail = 0;
hdr->free = 0;
hdr->npages = 0;
hdr->nrecs = 0;
}
/* Create the file object. */
file = (file_t*)malloc(sizeof(file_t));
if (file == NULL) {
fprintf(stderr, "file_open: failed to allocate the file object\n");
goto error;
}
/* Fill the B-Tree structure. */
file->handle = handle;
file->header = hdr;
file->size = size >> PAGE_SIZE_ORDER;
cache_invalidate(&file->cache, 1);
memset(&file->stats, 0, sizeof(stats_t));
DPRINT("file_open successful\n");
return file;
error:
if (handle != INVALID_FILE_HANDLE) {
if (hdr != NULL)
os_put_page(handle, hdr);
os_close_file(handle);
}
return NULL;
}
