int umm_munmap(void *addr, size_t len)
{
int ret;
if (!mem_ref_is_safe(addr, len))
return -EACCES;
ret = munmap(addr, len);
if (ret) {
printf("hack to unmap big pages %p len %lx\n", addr, len);
ret = munmap(addr, BIG_PGADDR(len + BIG_PGSIZE - 1));
if (ret)
return -errno;
dune_vm_unmap(pgroot, addr, BIG_PGADDR(len + BIG_PGSIZE - 1));
return 0;
}
dune_vm_unmap(pgroot, addr, len);
return 0;
}
void *umm_mremap(void *old_address, size_t old_size, size_t new_size, int flags,
void *new_address)
{
int adjust_mmap_len = 0;
void *ret;
if (!mem_ref_is_safe(old_address, old_size))
return (void*) -EACCES;
if (flags & MREMAP_FIXED) {
if (!mem_ref_is_safe(new_address, new_size))
return (void*) -EACCES;
} else {
if (!umm_space_left(new_size))
return (void*) -ENOMEM;
adjust_mmap_len = 1;
new_address = (void *) umm_get_map_pos() - PGADDR(new_size + PGSIZE - 1);
}
/* XXX add support in future */
if (!(flags & MREMAP_MAYMOVE))
return (void*) -EINVAL;
flags |= MREMAP_FIXED | MREMAP_MAYMOVE;
ret = mremap(old_address, old_size, new_size, flags, new_address);
if (ret != new_address)
return (void*) (long) -errno;
if (adjust_mmap_len)
mmap_len += PGADDR(new_size + PGSIZE - 1);
dune_vm_unmap(pgroot, old_address, old_size);
if (dune_vm_map_phys(pgroot, new_address, new_size,
(void *) dune_va_to_pa(new_address),
prot_to_perm(PROT_READ | PROT_WRITE))) {
printf("help me!\n");
exit(1);
}
return ret;
}
unsigned long umm_brk(unsigned long brk)
{
size_t len;
int ret;
if (!brk)
return UMM_ADDR_START;
if (brk < UMM_ADDR_START)
return -EINVAL;
len = brk - UMM_ADDR_START;
#if USE_BIG_MEM
len = BIG_PGADDR(len + BIG_PGSIZE - 1);
#else
len = PGADDR(len + PGSIZE - 1);
#endif
if (!umm_space_left(len))
return -ENOMEM;
if (len == brk_len) {
return brk;
} else if (len < brk_len) {
ret = munmap((void *) (UMM_ADDR_START + len), brk_len - len);
if (ret)
return -errno;
dune_vm_unmap(pgroot, (void *) (UMM_ADDR_START + len),
brk_len - len);
} else {
ret = umm_mmap_anom((void *) (UMM_ADDR_START + brk_len),
len - brk_len,
PROT_READ | PROT_WRITE, USE_BIG_MEM);
if (ret)
return ret;
}
brk_len = len;
return brk;
}
int main(int argc, char *argv[])
{
int i,n;
volatile int ret;
char* val;
struct timeval t0, t1, t2, t3;
ret = dune_init_and_enter();
if (ret) {
printf("failed to initialize dune\n");
return ret;
}
dune_register_pgflt_handler(pgflt_handler);
if (argc != 4){
usage(argv[0]);
}
page_nr = atoi(argv[3]);
page_len = PAGE_SIZE*page_nr;
//launch_server(2, page_nr);
//ret = rdma_init("cp-2", "41406", PAGE_SIZE);
rdma_init(argv[1], argv[2] , PAGE_SIZE);
gettimeofday(&t0, 0);
//allocated a memory
if (posix_memalign((void **)&page, PAGE_SIZE, page_len)) {
perror("init page memory failed");
return -1;
}
memset( page,0, page_len);
val= (char*) malloc(page_len);
memcpy(val, page, page_len);
/*page-out*/
pthread_mutex_lock(&_syscall_mtx);
//remote write
for (i=0; i<page_nr; i++)
rdma_write_offset( &page[i*PAGE_SIZE], i*PAGE_SIZE);
//unmap physical address
dune_vm_unmap(pgroot, (void *)page, page_len);
pthread_mutex_unlock(&_syscall_mtx);
//printf("page-out\n");
//generate page fault
//printf("page fault!\n");
gettimeofday(&t1, 0);
assert(!memcmp(val, page, page_len));
gettimeofday(&t2, 0);
//printf("page fault handled\n");
rdma_done();
long pagefault = (t1.tv_sec-t0.tv_sec)*1000000 + t1.tv_usec-t0.tv_usec;
long total = (t2.tv_sec-t0.tv_sec)*1000000 + t2.tv_usec-t0.tv_usec;
fprintf(stdout, "%ld\t%ld\n", pagefault, total);
return 0;
}
static void __vm_unmap(void *addr, int nr, int size)
{
dune_vm_unmap(pgroot, addr, (size_t) nr * (size_t) size);
}
