rusage: Refactor test programs

Change-Id: I846a6416acf903f7fa19db98d4d937c51c10b4af

test/rusage/000_mck.c

@@ -0,0 +1,44 @@
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+#include <string.h>
+#include "util.h"
+
+#define DEBUG
+
+int sz_anon[] = {
+	4 * (1ULL<<10),
+	2 * (1ULL<<20),
+	1 * (1ULL<<30),
+	134217728};
+
+#define SZ_INDEX 0
+#define NUM_AREAS 1
+
+int main(int argc, char **argv)
+{
+	int i;
+	int sz_index;
+	void *anon[NUM_AREAS];
+	int ret = 0;
+
+	CHKANDJUMP(argc != 2, 255, "%s <sz_index>\n", argv[0]);
+	sz_index = atoi(argv[1]);
+
+	for (i = 0; i < NUM_AREAS; i++) {
+		anon[i] = mmap(0, sz_anon[sz_index], PROT_READ | PROT_WRITE,
+			       MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+		CHKANDJUMP(anon[i] == MAP_FAILED, 255, "mmap failed\n");
+		*((unsigned long *)anon[i]) = 0x123456789abcdef0;
+	}
+
+	for (i = 0; i < NUM_AREAS; i++) {
+		munmap(anon[i], sz_anon[sz_index]);
+	}
+
+ fn_exit:
+	return ret;
+ fn_fail:
+	goto fn_exit;
+}

test/rusage/001_mck.c

@@ -0,0 +1,50 @@
+#include <unistd.h>
+#include <stdio.h>
+#include <sys/mman.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include "util.h"
+
+#define DEBUG
+
+int sz_mem[] = {
+	4 * (1ULL<<10),
+	2 * (1ULL<<20),
+	1 * (1ULL<<30),
+	134217728};
+
+#define SZ_INDEX 0
+
+int main(int argc, char **argv)
+{
+	void *mem;
+	int ret = 0;
+	int fd;
+	unsigned long val;
+
+	fd = open("./file", O_RDWR);
+	CHKANDJUMP(fd == -1, 255, "open failed\n");
+
+	mem = mmap(0, sz_mem[SZ_INDEX], PROT_READ | PROT_WRITE, MAP_SHARED,
+		   fd, 0);
+	CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
+
+	val = *((unsigned long *)mem);
+	printf("val=%lx\n", val);
+	// memset(mem, 0, sz_mem[SZ_INDEX]);
+
+	*((unsigned long *)mem) = 0x123456789abcdef0;
+	// ret = msync(mem, sz_mem[SZ_INDEX], MS_SYNC);
+	// *((unsigned long *)mem) = 0x123456789abcdef0;
+
+	munmap(mem, sz_mem[SZ_INDEX]);
+	// ret = close(fd);
+	// CHKANDJUMP(ret != 0, 255, "close failed\n");
+
+ fn_exit:
+	return ret;
+ fn_fail:
+	goto fn_exit;
+}

test/rusage/002_mck.c

@@ -0,0 +1,55 @@
+#include <unistd.h>
+#include <stdio.h>
+#include <sys/mman.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include "util.h"
+
+#define DEBUG
+
+int sz_mem[] = {
+	4 * (1ULL<<10),
+	2 * (1ULL<<20),
+	1 * (1ULL<<30),
+	134217728};
+
+#define SZ_INDEX 0
+
+int main(int argc, char **argv)
+{
+	void *mem;
+	int ret = 0;
+	int fd;
+	char fn[256] = "/dev/shm/Intel_MPI";
+
+	fd = open(fn, O_CREAT | O_TRUNC | O_RDWR, 0600);
+	CHKANDJUMP(fd == -1, 255, "shm_open failed,str=%s\n", strerror(errno));
+
+	ret = ftruncate(fd, sz_mem[SZ_INDEX]);
+	CHKANDJUMP(ret != 0, 255, "ftruncate failed\n");
+
+	mem = mmap(0, sz_mem[SZ_INDEX], PROT_READ | PROT_WRITE, MAP_SHARED,
+		   fd, 0);
+	CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
+
+	//unsigned long val = *((unsigned long *)mem);
+	//memset(mem, 0, sz_mem[SZ_INDEX]);
+
+		*((unsigned long *)mem) = 0x123456789abcdef0;
+	//  ret = msync(mem, sz_mem[SZ_INDEX], MS_SYNC);
+	//	*((unsigned long *)mem) = 0x123456789abcdef0;
+
+	munmap(mem, sz_mem[SZ_INDEX]);
+	ret = close(fd);
+	CHKANDJUMP(ret != 0, 255, "close failed\n");
+	ret = unlink(fn);
+	CHKANDJUMP(ret != 0, 255, "shm_unlink failed\n");
+
+ fn_exit:
+	return ret;
+ fn_fail:
+	goto fn_exit;
+}

test/rusage/003_mck.c

@@ -0,0 +1,55 @@
+#include <unistd.h>
+#include <stdio.h>
+#include <sys/mman.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include "util.h"
+
+#define DEBUG
+
+int sz_mem[] = {
+	4 * (1ULL<<10),
+	2 * (1ULL<<20),
+	1 * (1ULL<<30),
+	134217728};
+
+#define SZ_INDEX 0
+
+int main(int argc, char **argv)
+{
+	void *mem;
+	int ret = 0;
+	int fd;
+	char fn[256] = "/dev/shm/Intel_MPI";
+
+	fd = open(fn, O_CREAT | O_TRUNC | O_RDWR, 0600);
+	CHKANDJUMP(fd == -1, 255, "shm_open failed,str=%s\n", strerror(errno));
+
+	ret = ftruncate(fd, sz_mem[SZ_INDEX]);
+	CHKANDJUMP(ret != 0, 255, "ftruncate failed\n");
+
+	mem = mmap(0, sz_mem[SZ_INDEX], PROT_READ | PROT_WRITE, MAP_SHARED,
+		   fd, 0);
+	CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
+
+	//unsigned long val = *((unsigned long *)mem);
+	//memset(mem, 0, sz_mem[SZ_INDEX]);
+
+		*((unsigned long *)mem) = 0x123456789abcdef0;
+	//  ret = msync(mem, sz_mem[SZ_INDEX], MS_SYNC);
+	//	*((unsigned long *)mem) = 0x123456789abcdef0;
+
+	munmap(mem, sz_mem[SZ_INDEX]);
+	ret = close(fd);
+	CHKANDJUMP(ret != 0, 255, "close failed\n");
+	ret = unlink(fn);
+	CHKANDJUMP(ret != 0, 255, "shm_unlink failed\n");
+
+ fn_exit:
+	return ret;
+ fn_fail:
+	goto fn_exit;
+}

test/rusage/004_mck.c

@@ -0,0 +1,56 @@
+#include <unistd.h>
+#include <stdio.h>
+#include <sys/mman.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/wait.h>
+#include "util.h"
+
+#define DEBUG
+
+int sz_mem[] = {
+	4 * (1ULL<<10),
+	2 * (1ULL<<20),
+	1 * (1ULL<<30),
+	134217728};
+
+#define SZ_INDEX 0
+#define NUM_AREAS 1
+
+int main(int argc, char **argv)
+{
+	void *mem;
+	int ret = 0;
+	pid_t pid;
+	int status;
+	int fd;
+	unsigned long val;
+
+	fd = open("./file", O_RDWR);
+	CHKANDJUMP(fd == -1, 255, "open failed\n");
+
+	mem = mmap(0, sz_mem[SZ_INDEX], PROT_READ | PROT_WRITE, MAP_SHARED,
+		   fd, 0);
+	CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
+
+	val = *((unsigned long *)mem);
+	printf("val=%lx\n", val);
+
+	pid = fork();
+	CHKANDJUMP(pid == -1, 255, "fork failed\n");
+	if (pid == 0) {
+		_exit(123);
+	} else {
+		ret = waitpid(pid, &status, 0);
+		CHKANDJUMP(ret == -1, 255, "waitpid failed\n");
+		printf("exit status=%d\n", WEXITSTATUS(status));
+	}
+
+ fn_exit:
+	return ret;
+ fn_fail:
+	goto fn_exit;
+}

test/rusage/006_mck.c

@@ -0,0 +1,61 @@
+#include <unistd.h>
+#include <stdio.h>
+#include <sys/mman.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/wait.h>
+#include "util.h"
+
+#define DEBUG
+
+int sz_mem[] = {
+	4 * (1ULL<<10),
+	2 * (1ULL<<20),
+	1 * (1ULL<<30),
+	134217728};
+
+#define SZ_INDEX 0
+#define NUM_AREAS 1
+
+int main(int argc, char **argv)
+{
+	void *mem;
+	int ret = 0;
+	pid_t pid;
+	int status;
+	int fd;
+
+	char fn[256] = "/dev/shm/Intel_MPI";
+
+	fd = open(fn, O_CREAT | O_TRUNC | O_RDWR, 0600);
+	CHKANDJUMP(fd == -1, 255, "shm_open failed,str=%s\n", strerror(errno));
+
+	ret = ftruncate(fd, sz_mem[SZ_INDEX]);
+	CHKANDJUMP(ret != 0, 255, "ftruncate failed\n");
+
+	mem = mmap(0, sz_mem[SZ_INDEX], PROT_READ | PROT_WRITE, MAP_SHARED,
+		   fd, 0);
+	CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
+
+	//unsigned long val = *((unsigned long *)mem);
+	*((unsigned long *)mem) = 0x123456789abcdef0;
+
+	pid = fork();
+	CHKANDJUMP(pid == -1, 255, "fork failed\n");
+	if (pid == 0) {
+		_exit(123);
+	} else {
+		ret = waitpid(pid, &status, 0);
+		CHKANDJUMP(ret == -1, 255, "waitpid failed\n");
+		printf("exit status=%d\n", WEXITSTATUS(status));
+	}
+
+
+ fn_exit:
+	return ret;
+ fn_fail:
+	goto fn_exit;
+}

test/rusage/007_mck.c

@@ -0,0 +1,61 @@
+#include <unistd.h>
+#include <stdio.h>
+#include <sys/mman.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/wait.h>
+#include "util.h"
+
+#define DEBUG
+
+int sz_mem[] = {
+	4 * (1ULL<<10),
+	2 * (1ULL<<20),
+	1 * (1ULL<<30),
+	134217728};
+
+#define SZ_INDEX 0
+#define NUM_AREAS 1
+
+int main(int argc, char **argv)
+{
+	void *mem;
+	int ret = 0;
+	pid_t pid;
+	int status;
+	int fd;
+
+	char fn[256] = "/dev/shm/Intel_MPI";
+
+	fd = open(fn, O_CREAT | O_TRUNC | O_RDWR, 0600);
+	CHKANDJUMP(fd == -1, 255, "shm_open failed,str=%s\n", strerror(errno));
+
+	ret = ftruncate(fd, sz_mem[SZ_INDEX]);
+	CHKANDJUMP(ret != 0, 255, "ftruncate failed\n");
+
+	mem = mmap(0, sz_mem[SZ_INDEX], PROT_READ | PROT_WRITE, MAP_SHARED,
+		   fd, 0);
+	CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
+
+	//unsigned long val = *((unsigned long *)mem);
+	*((unsigned long *)mem) = 0x123456789abcdef0;
+
+	pid = fork();
+	CHKANDJUMP(pid == -1, 255, "fork failed\n");
+	if (pid == 0) {
+		_exit(123);
+	} else {
+		ret = waitpid(pid, &status, 0);
+		CHKANDJUMP(ret == -1, 255, "waitpid failed\n");
+		printf("exit status=%d\n", WEXITSTATUS(status));
+	}
+
+
+ fn_exit:
+	return ret;
+ fn_fail:
+	goto fn_exit;
+}

test/rusage/008_mck.c

@@ -0,0 +1,66 @@
+#include <unistd.h>
+#include <stdio.h>
+#include <sys/mman.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/wait.h>
+#include "util.h"
+
+#define DEBUG
+
+int sz_mem[] = {
+	4 * (1ULL<<10),
+	2 * (1ULL<<20),
+	1 * (1ULL<<30),
+	134217728};
+
+#define SZ_INDEX 0
+#define NUM_AREAS 1
+
+int main(int argc, char **argv)
+{
+	void *mem;
+	int ret = 0;
+	pid_t pid;
+	int status;
+	int fd;
+	unsigned long val;
+
+	pid = fork();
+	CHKANDJUMP(pid == -1, 255, "fork failed\n");
+	if (pid == 0) {
+		fd = open("./file", O_RDWR);
+		CHKANDJUMP(fd == -1, 255, "open failed\n");
+
+		mem = mmap(0, sz_mem[SZ_INDEX], PROT_READ | PROT_WRITE,
+			   MAP_SHARED, fd, 0);
+		CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
+
+		val = *((unsigned long *)mem);
+		printf("val=%lx\n", val);
+
+		_exit(123);
+	} else {
+		fd = open("./file", O_RDWR);
+		CHKANDJUMP(fd == -1, 255, "open failed\n");
+
+		mem = mmap(0, sz_mem[SZ_INDEX], PROT_READ | PROT_WRITE,
+			   MAP_SHARED, fd, 0);
+		CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
+
+		val = *((unsigned long *)mem);
+		printf("val=%lx\n", val);
+
+		ret = waitpid(pid, &status, 0);
+		CHKANDJUMP(ret == -1, 255, "waitpid failed\n");
+		printf("exit status=%d\n", WEXITSTATUS(status));
+	}
+
+ fn_exit:
+	return ret;
+ fn_fail:
+	goto fn_exit;
+}

test/rusage/009_mck.c

@@ -0,0 +1,75 @@
+#include <unistd.h>
+#include <stdio.h>
+#include <sys/mman.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/wait.h>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#include "util.h"
+
+#define DEBUG
+
+int sz_mem[] = {
+	4 * (1ULL<<10),
+	2 * (1ULL<<20),
+	1 * (1ULL<<30),
+	134217728};
+
+#define SZ_INDEX 0
+
+int main(int argc, char **argv)
+{
+	void *mem;
+	int ret = 0;
+	pid_t pid;
+	int status;
+	key_t key = ftok(argv[0], 0);
+	int shmid;
+
+	shmid = shmget(key, sz_mem[SZ_INDEX], IPC_CREAT | 0660);
+	CHKANDJUMP(shmid == -1, 255, "shmget failed: %s\n", strerror(errno));
+
+	pid = fork();
+	CHKANDJUMP(pid == -1, 255, "fork failed\n");
+	if (pid == 0) {
+		mem = shmat(shmid, NULL, 0);
+		CHKANDJUMP(mem == (void *)-1, 255, "shmat failed: %s\n",
+			   strerror(errno));
+
+		*((unsigned long *)mem) = 0x1234;
+
+		ret = shmdt(mem);
+		CHKANDJUMP(ret == -1, 255, "shmdt failed\n");
+
+		_exit(123);
+	} else {
+		mem = shmat(shmid, NULL, 0);
+		CHKANDJUMP(mem == (void *)-1, 255, "shmat failed: %s\n",
+			   strerror(errno));
+
+
+		ret = waitpid(pid, &status, 0);
+		CHKANDJUMP(ret == -1, 255, "waitpid failed\n");
+
+		printf("%lx\n", *((unsigned long *)mem));
+
+#if 0
+		struct shmid_ds buf;
+
+		ret = shmctl(shmid, IPC_RMID, &buf);
+		CHKANDJUMP(ret == -1, 255, "shmctl failed\n");
+#endif
+
+		ret = shmdt(mem);
+		CHKANDJUMP(ret == -1, 255, "shmdt failed\n");
+	}
+
+ fn_exit:
+	return ret;
+ fn_fail:
+	goto fn_exit;
+}

test/rusage/010_mck.c

@@ -0,0 +1,44 @@
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+#include <string.h>
+#include "util.h"
+
+#define DEBUG
+
+int sz_anon[] = {
+	4 * (1ULL<<10),
+	2 * (1ULL<<20),
+	1 * (1ULL<<30),
+	134217728};
+
+#define SZ_INDEX 0
+#define NUM_AREAS 1
+
+int main(int argc, char **argv)
+{
+	int i;
+	int sz_index;
+	void *anon[NUM_AREAS];
+	int ret = 0;
+
+	CHKANDJUMP(argc != 2, 255, "%s <sz_index>\n", argv[0]);
+	sz_index = atoi(argv[1]);
+
+	for (i = 0; i < NUM_AREAS; i++) {
+		anon[i] = mmap(0, sz_anon[sz_index], PROT_READ | PROT_WRITE,
+			       MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+		CHKANDJUMP(anon[i] == MAP_FAILED, 255, "mmap failed\n");
+		*((unsigned long *)anon[i]) = 0x123456789abcdef0;
+	}
+
+	for (i = 0; i < NUM_AREAS; i++) {
+		munmap(anon[i], sz_anon[sz_index]);
+	}
+
+ fn_exit:
+	return ret;
+ fn_fail:
+	goto fn_exit;
+}

test/rusage/011_mck.c

@@ -0,0 +1,108 @@
+#include <unistd.h>
+#include <stdio.h>
+#include <sys/mman.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/wait.h>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#include <xpmem.h>
+#include "util.h"
+
+#define DEBUG
+
+int sz_mem[] = {
+	4 * (1ULL<<10),
+	2 * (1ULL<<20),
+	1 * (1ULL<<30),
+	134217728};
+
+#define SZ_INDEX 0
+
+int main(int argc, char **argv)
+{
+	void *mem;
+	int ret = 0;
+	pid_t pid;
+	int status;
+	key_t key = ftok(argv[0], 0);
+	int shmid;
+	xpmem_segid_t segid;
+
+	shmid = shmget(key, sz_mem[SZ_INDEX], IPC_CREAT | 0660);
+	CHKANDJUMP(shmid == -1, 255, "shmget failed: %s\n", strerror(errno));
+
+	mem = mmap(0, sz_mem[SZ_INDEX], PROT_READ | PROT_WRITE,
+		   MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
+	CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
+	memset(mem, 0, sz_mem[SZ_INDEX]);
+
+	pid = fork();
+	CHKANDJUMP(pid == -1, 255, "fork failed\n");
+	if (pid == 0) {
+		void *shm = shmat(shmid, NULL, 0);
+
+		CHKANDJUMP(shm == (void *)-1, 255, "shmat failed: %s\n",
+			   strerror(errno));
+
+		while ((segid = *(xpmem_segid_t *)shm) == 0) {
+		};
+
+		ret = shmdt(shm);
+		CHKANDJUMP(ret == -1, 255, "shmdt failed\n");
+
+		xpmem_apid_t apid = xpmem_get(segid, XPMEM_RDWR,
+					      XPMEM_PERMIT_MODE, NULL);
+		CHKANDJUMP(apid == -1, 255, "xpmem_get failed: %s\n",
+			   strerror(errno));
+
+		struct xpmem_addr addr = { .apid = apid, .offset = 0 };
+		void *attach = xpmem_attach(addr, sz_mem[SZ_INDEX], NULL);
+
+		CHKANDJUMP(attach == (void *)-1, 255,
+			   "xpmem_attach failed: %s\n", strerror(errno));
+
+		*((unsigned long *)attach) = 0x1234;
+
+		ret = xpmem_detach(attach);
+		CHKANDJUMP(ret == -1, 255, "xpmem_detach failed\n");
+
+		_exit(123);
+	} else {
+		void *shm = shmat(shmid, NULL, 0);
+
+		CHKANDJUMP(mem == (void *)-1, 255, "shmat failed: %s\n",
+			   strerror(errno));
+
+		segid = xpmem_make(mem, sz_mem[SZ_INDEX], XPMEM_PERMIT_MODE,
+				   (void *)0666);
+		CHKANDJUMP(segid == -1, 255, "xpmem_ioctl failed: %s\n",
+			   strerror(errno));
+
+		*(xpmem_segid_t *)shm = segid;
+
+		ret = waitpid(pid, &status, 0);
+		CHKANDJUMP(ret == -1, 255, "waitpid failed\n");
+
+		printf("%lx\n", *((unsigned long *)mem));
+
+		struct shmid_ds buf;
+
+		ret = shmctl(shmid, IPC_RMID, &buf);
+		CHKANDJUMP(ret == -1, 255, "shmctl failed\n");
+
+		ret = shmdt(shm);
+		CHKANDJUMP(ret == -1, 255, "shmdt failed\n");
+
+		ret = xpmem_remove(segid);
+		CHKANDJUMP(ret == -1, 255, "xpmem_remove failed\n");
+	}
+
+ fn_exit:
+	return ret;
+ fn_fail:
+	goto fn_exit;
+}

test/rusage/012_mck.c

@@ -0,0 +1,78 @@
+#include <unistd.h>
+#include <stdio.h>
+#include <sys/mman.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/wait.h>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#include <xpmem.h>
+#include "util.h"
+
+#define DEBUG
+
+int sz_mem[] = {
+	4 * (1ULL<<10),
+	2 * (1ULL<<20),
+	1 * (1ULL<<30),
+	134217728};
+
+#define SZ_INDEX 0
+
+int main(int argc, char **argv)
+{
+	void *mem;
+	int ret = 0;
+	pid_t pid;
+	int status;
+	xpmem_segid_t segid;
+
+	mem = mmap(0, sz_mem[SZ_INDEX], PROT_READ | PROT_WRITE,
+		   MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+	CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
+	memset(mem, 0, sz_mem[SZ_INDEX]);
+
+	segid = xpmem_make(mem, sz_mem[SZ_INDEX], XPMEM_PERMIT_MODE,
+			   (void *)0666);
+	CHKANDJUMP(segid == -1, 255, "xpmem_ioctl failed: %s\n",
+		   strerror(errno));
+
+	pid = fork();
+	CHKANDJUMP(pid == -1, 255, "fork failed\n");
+	if (pid == 0) {
+		xpmem_apid_t apid = xpmem_get(segid, XPMEM_RDWR,
+					      XPMEM_PERMIT_MODE, NULL);
+
+		CHKANDJUMP(apid == -1, 255, "xpmem_get failed: %s\n",
+			   strerror(errno));
+
+		struct xpmem_addr addr = { .apid = apid, .offset = 0 };
+		void *attach = xpmem_attach(addr, sz_mem[SZ_INDEX], NULL);
+
+		CHKANDJUMP(attach == (void *)-1, 255,
+			   "xpmem_attach failed: %s\n", strerror(errno));
+
+		*((unsigned long *)attach) = 0x1234;
+
+		ret = xpmem_detach(attach);
+		CHKANDJUMP(ret == -1, 255, "xpmem_detach failed\n");
+
+		_exit(123);
+	} else {
+		ret = waitpid(pid, &status, 0);
+		CHKANDJUMP(ret == -1, 255, "waitpid failed\n");
+
+		printf("%lx\n", *((unsigned long *)mem));
+
+		ret = xpmem_remove(segid);
+		CHKANDJUMP(ret == -1, 255, "xpmem_remove failed\n");
+	}
+
+ fn_exit:
+	return ret;
+ fn_fail:
+	goto fn_exit;
+}

test/rusage/013_mck.c

@@ -0,0 +1,48 @@
+#include <unistd.h>
+#include <stdio.h>
+#include <sys/mman.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include "util.h"
+
+#define DEBUG
+
+int sz_mem[] = {
+	4 * (1ULL<<10),
+	2 * (1ULL<<20),
+	1 * (1ULL<<30),
+	134217728};
+
+#define SZ_INDEX 0
+
+int main(int argc, char **argv)
+{
+	void *mem;
+	int ret = 0;
+	int fd;
+
+	fd = open("./file", O_RDWR);
+	CHKANDJUMP(fd == -1, 255, "open failed\n");
+
+	mem = mmap(0, sz_mem[SZ_INDEX], PROT_READ | PROT_WRITE,
+		   MAP_PRIVATE, fd, 0);
+	CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
+
+	// unsigned long val = *((unsigned long *)mem);
+	// memset(mem, 0, sz_mem[SZ_INDEX]);
+
+	*((unsigned long *)mem) = 0x123456789abcdef0;
+	// ret = msync(mem, sz_mem[SZ_INDEX], MS_SYNC);
+	// *((unsigned long *)mem) = 0x123456789abcdef0;
+
+	munmap(mem, sz_mem[SZ_INDEX]);
+	// ret = close(fd);
+	// CHKANDJUMP(ret != 0, 255, "close failed\n");
+
+ fn_exit:
+	return ret;
+ fn_fail:
+	goto fn_exit;
+}

test/rusage/014_mck.c

@@ -0,0 +1,51 @@
+#define _GNU_SOURCE         /* See feature_test_macros(7) */
+#include <unistd.h>
+#include <stdio.h>
+#include <sys/mman.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include "util.h"
+
+#define DEBUG
+
+int sz_unit[] = {
+	4 * (1ULL<<10),
+	2 * (1ULL<<20),
+	1 * (1ULL<<30)};
+
+#define SZ_INDEX 0
+
+int main(int argc, char **argv)
+{
+	void *mem;
+	int ret = 0;
+	int fd;
+
+	fd = open("./file", O_RDWR);
+	CHKANDJUMP(fd == -1, 255, "open failed\n");
+
+	mem = mmap(0, 2 * sz_unit[SZ_INDEX], PROT_READ | PROT_WRITE,
+		   MAP_SHARED, fd, 0);
+	CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
+
+	ret = remap_file_pages(mem + 0 * sz_unit[SZ_INDEX],
+			       sz_unit[SZ_INDEX], 0, 1, MAP_SHARED);
+	CHKANDJUMP(ret != 0, 255, "remap_file_pages failed\n");
+
+	ret = remap_file_pages(mem + 1 * sz_unit[SZ_INDEX],
+			       sz_unit[SZ_INDEX], 0, 0, MAP_SHARED);
+	CHKANDJUMP(ret != 0, 255, "remap_file_pages failed\n");
+
+	*((unsigned long *)mem) = 0x123456789abcdef0;
+	*(unsigned long *)((char *)mem + 1 * sz_unit[SZ_INDEX]) =
+		0x123456789abcdef0;
+
+	munmap(mem, 2 * sz_unit[SZ_INDEX]);
+
+ fn_exit:
+	return ret;
+ fn_fail:
+	goto fn_exit;
+}

test/rusage/015_mck.c

@@ -0,0 +1,55 @@
+#define _GNU_SOURCE         /* See feature_test_macros(7) */
+#include <unistd.h>
+#include <stdio.h>
+#include <sys/mman.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include "util.h"
+
+#define DEBUG
+
+int sz_unit[] = {
+	4 * (1ULL<<10),
+	2 * (1ULL<<20),
+	1 * (1ULL<<30)};
+
+#define SZ_INDEX 0
+
+int main(int argc, char **argv)
+{
+	void *mem;
+	int ret = 0;
+	int fd;
+
+	fd = open("./file", O_RDWR);
+	CHKANDJUMP(fd == -1, 255, "open failed\n");
+
+	mem = mmap(0, 2 * sz_unit[SZ_INDEX], PROT_READ | PROT_WRITE,
+		   MAP_SHARED, fd, 0);
+	CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
+
+	*((unsigned long *)mem) = 0x123456789abcdef0;
+	*(unsigned long *)((char *)mem + 1 * sz_unit[SZ_INDEX]) =
+		0xbeefbeefbeefbeef;
+
+	ret = remap_file_pages(mem + 0 * sz_unit[SZ_INDEX],
+			       sz_unit[SZ_INDEX], 0, 1, MAP_SHARED);
+	CHKANDJUMP(ret != 0, 255, "remap_file_pages failed\n");
+
+	ret = remap_file_pages(mem + 1 * sz_unit[SZ_INDEX],
+			       sz_unit[SZ_INDEX], 0, 0, MAP_SHARED);
+	CHKANDJUMP(ret != 0, 255, "remap_file_pages failed\n");
+
+	*((unsigned long *)mem) = 0x123456789abcdef0;
+	*(unsigned long *)((char *)mem + 1 * sz_unit[SZ_INDEX]) =
+		0xbeefbeefbeefbeef;
+
+	munmap(mem, 2 * sz_unit[SZ_INDEX]);
+
+ fn_exit:
+	return ret;
+ fn_fail:
+	goto fn_exit;
+}

test/rusage/016_mck.c

@@ -0,0 +1,43 @@
+#define _GNU_SOURCE         /* See feature_test_macros(7) */
+
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+#include <string.h>
+#include "util.h"
+
+#define DEBUG
+
+int sz_anon[] = {
+	4 * (1ULL<<10),
+	2 * (1ULL<<20),
+	1 * (1ULL<<30),
+	134217728};
+
+#define SZ_INDEX 0
+#define NUM_AREAS 1
+
+int main(int argc, char **argv)
+{
+	void *mem;
+	void *newmem;
+	int ret = 0;
+
+	mem = mmap(0, sz_anon[SZ_INDEX], PROT_READ | PROT_WRITE,
+		   MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
+	CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
+	*((unsigned long *)mem) = 0x123456789abcdef0;
+
+	newmem = mremap(mem, sz_anon[SZ_INDEX], sz_anon[SZ_INDEX + 1],
+			MREMAP_MAYMOVE);
+	CHKANDJUMP(newmem == MAP_FAILED, 255, "mmap failed\n");
+	*((unsigned long *)mem) = 0xbeefbeefbeefbeef;
+
+	munmap(newmem, sz_anon[SZ_INDEX + 1]);
+
+ fn_exit:
+	return ret;
+ fn_fail:
+	goto fn_exit;
+}

test/rusage/017_mck.c

@@ -0,0 +1,53 @@
+#define _GNU_SOURCE         /* See feature_test_macros(7) */
+
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include "util.h"
+
+#define DEBUG
+
+int sz_mem[] = {
+	4 * (1ULL<<10),
+	2 * (1ULL<<20),
+	1 * (1ULL<<30),
+	134217728};
+
+#define SZ_INDEX 0
+#define NUM_AREAS 1
+
+int main(int argc, char **argv)
+{
+	void *mem;
+	int ret = 0;
+	int fd;
+
+	fd = open("./file", O_RDWR);
+	CHKANDJUMP(fd == -1, 255, "open failed\n");
+
+	mem = mmap(0, 3 * sz_mem[SZ_INDEX], PROT_READ | PROT_WRITE,
+		   MAP_PRIVATE, fd, 0);
+	CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
+
+	*(unsigned long *)((char *)mem + 0) = 0x123456789abcdef0;
+	*(unsigned long *)((char *)mem + sz_mem[SZ_INDEX]) =
+		0xbeefbeefbeefbeef;
+	*(unsigned long *)((char *)mem + 2 * sz_mem[SZ_INDEX]) =
+		0xbeefbeefbeefbeef;
+
+	ret = mprotect(mem + sz_mem[SZ_INDEX], sz_mem[SZ_INDEX],
+		       PROT_READ | PROT_WRITE | PROT_EXEC);
+	CHKANDJUMP(ret != 0, 255, "mprotect failed\n");
+
+	munmap(mem, 3 * sz_mem[SZ_INDEX]);
+
+ fn_exit:
+	return ret;
+ fn_fail:
+	goto fn_exit;
+}

test/rusage/018_mck.c

@@ -0,0 +1,49 @@
+#define _GNU_SOURCE         /* See feature_test_macros(7) */
+
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include "util.h"
+
+#define DEBUG
+
+int sz_mem[] = {
+	4 * (1ULL<<10),
+	2 * (1ULL<<20),
+	1 * (1ULL<<30),
+	134217728};
+
+#define SZ_INDEX 1
+#define NUM_AREAS 1
+
+int main(int argc, char **argv)
+{
+	void *mem;
+	int ret = 0;
+
+	mem = mmap(0, 3 * sz_mem[SZ_INDEX], PROT_READ | PROT_WRITE,
+		   MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+	CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
+
+	*(unsigned long *)((char *)mem + 0) = 0x123456789abcdef0;
+	*(unsigned long *)((char *)mem + sz_mem[SZ_INDEX]) =
+		0xbeefbeefbeefbeef;
+	*(unsigned long *)((char *)mem + 2 * sz_mem[SZ_INDEX]) =
+		0xbeefbeefbeefbeef;
+
+	ret = mprotect(mem + sz_mem[SZ_INDEX - 1], sz_mem[SZ_INDEX - 1],
+		       PROT_READ | PROT_WRITE | PROT_EXEC);
+	CHKANDJUMP(ret != 0, 255, "mprotect failed\n");
+
+	munmap(mem, 3 * sz_mem[SZ_INDEX]);
+
+ fn_exit:
+	return ret;
+ fn_fail:
+	goto fn_exit;
+}

test/rusage/020_mck.c

@@ -0,0 +1,44 @@
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+#include <string.h>
+#include "util.h"
+
+#define DEBUG
+
+int sz_anon[] = {
+	4 * (1ULL<<10),
+	2 * (1ULL<<20),
+	1 * (1ULL<<30),
+	134217728};
+
+#define SZ_INDEX 0
+#define NUM_AREAS 1
+
+int main(int argc, char **argv)
+{
+	int i;
+	int sz_index;
+	void *anon[NUM_AREAS];
+	int ret = 0;
+
+	CHKANDJUMP(argc != 2, 255, "%s <sz_index>\n", argv[0]);
+	sz_index = atoi(argv[1]);
+
+	for (i = 0; i < NUM_AREAS; i++) {
+		anon[i] = mmap(0, sz_anon[sz_index], PROT_READ | PROT_WRITE,
+			       MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
+		CHKANDJUMP(anon[i] == MAP_FAILED, 255, "mmap failed\n");
+		*((unsigned long *)anon[i]) = 0x123456789abcdef0;
+	}
+
+	for (i = 0; i < NUM_AREAS; i++) {
+		munmap(anon[i], sz_anon[sz_index]);
+	}
+
+ fn_exit:
+	return ret;
+ fn_fail:
+	goto fn_exit;
+}

test/rusage/030_mck.c

@@ -0,0 +1,44 @@
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+#include <string.h>
+#include "util.h"
+
+#define DEBUG
+
+int sz_anon[] = {
+	4 * (1ULL<<10),
+	2 * (1ULL<<20),
+	1 * (1ULL<<30),
+	134217728};
+
+#define SZ_INDEX 0
+#define NUM_AREAS 1
+
+int main(int argc, char **argv)
+{
+	int i;
+	int sz_index;
+	void *anon[NUM_AREAS];
+	int ret = 0;
+
+	CHKANDJUMP(argc != 2, 255, "%s <sz_index>\n", argv[0]);
+	sz_index = atoi(argv[1]);
+
+	for (i = 0; i < NUM_AREAS; i++) {
+		anon[i] = mmap(0, sz_anon[sz_index], PROT_READ | PROT_WRITE,
+			       MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+		CHKANDJUMP(anon[i] == MAP_FAILED, 255, "mmap failed\n");
+		*((unsigned long *)anon[i]) = 0x123456789abcdef0;
+	}
+
+	for (i = 0; i < NUM_AREAS; i++) {
+		munmap(anon[i], sz_anon[sz_index]);
+	}
+
+ fn_exit:
+	return ret;
+ fn_fail:
+	goto fn_exit;
+}

test/rusage/100_mck.c

@@ -0,0 +1,70 @@
+#include <stdio.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <sys/syscall.h>   /* For SYS_xxx definitions */
+#include "util.h"
+#include "ihklib.h"
+#include "mckernel/ihklib_rusage.h"
+
+#define DEBUG
+
+int sz_anon[] = {
+	4 * (1ULL<<10),
+	2 * (1ULL<<20),
+	1 * (1ULL<<30),
+	134217728};
+
+#define SZ_INDEX 0
+#define NLOOP 2
+
+int main(int argc, char **argv)
+{
+	int i, j, ret = 0;
+	void *mem;
+	struct mckernel_rusage rusage;
+
+	for (j = 0; j < NLOOP; j++) {
+		mem = mmap(0, sz_anon[SZ_INDEX], PROT_READ | PROT_WRITE,
+			   MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+		CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
+		*((unsigned long *)mem) = 0x123456789abcdef0;
+
+		ret = syscall(900);
+		CHKANDJUMP(ret != 0, 255, "syscall failed\n");
+
+		ret  = ihk_os_getrusage(0, &rusage, sizeof(rusage));
+		CHKANDJUMP(ret != 0, 255, "ihk_os_getrusage failed\n");
+
+		for (i = 0; i < IHK_MAX_NUM_PGSIZES; i++) {
+			printf("memory_stat_rss[%d]=%ld\n", i,
+			       rusage.memory_stat_rss[i]);
+			printf("memory_stat_mapped_file[%d]=%ld\n", i,
+			       rusage.memory_stat_mapped_file[i]);
+		}
+		printf("memory_max_usage=%ld\n", rusage.memory_max_usage);
+		printf("memory_kmem_usage=%ld\n", rusage.memory_kmem_usage);
+		printf("memory_kmem_max_usage=%ld\n",
+		       rusage.memory_kmem_max_usage);
+#define NUM_NUMA_NODES 2
+		for (i = 0; i < NUM_NUMA_NODES; i++) {
+			printf("memory_numa_stat[%d]=%ld\n", i,
+			       rusage.memory_numa_stat[i]);
+		}
+#define NUM_CPUS 2
+		for (i = 0; i < NUM_CPUS; i++) {
+			printf("cpuacct_usage_percpu[%d]=%ld\n", i,
+			       rusage.cpuacct_usage_percpu[i]);
+		}
+		printf("cpuacct_stat_system=%ld\n",
+		       rusage.cpuacct_stat_system);
+		printf("cpuacct_stat_user=%ld\n", rusage.cpuacct_stat_user);
+		printf("cpuacct_usage=%ld\n", rusage.cpuacct_usage);
+
+		printf("num_threads=%d\n", rusage.num_threads);
+		printf("max_num_threads=%d\n", rusage.max_num_threads);
+	}
+ fn_exit:
+	return ret;
+ fn_fail:
+	goto fn_exit;
+}

test/rusage/101_mck.c

@@ -0,0 +1,88 @@
+#include <stdio.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <sys/syscall.h>   /* For SYS_xxx definitions */
+#include "util.h"
+#include "ihklib.h"
+#include "mckernel/ihklib_rusage.h"
+
+#define DEBUG
+
+int sz_anon[] = {
+	4 * (1ULL<<10),
+	2 * (1ULL<<20),
+	1 * (1ULL<<30),
+	134217728};
+
+#define SZ_INDEX 0
+#define NLOOP 2
+
+int main(int argc, char **argv)
+{
+	int i, j, ret = 0;
+	void *mem;
+	struct mckernel_rusage rusage;
+	pid_t pid;
+	int status;
+
+	pid = fork();
+	CHKANDJUMP(pid == -1, 255, "fork failed");
+	if (pid == 0) {
+
+		for (j = 0; j < NLOOP; j++) {
+			mem = mmap(0, sz_anon[SZ_INDEX],
+				   PROT_READ | PROT_WRITE,
+				   MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+			CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
+			*((unsigned long *)mem) = 0x123456789abcdef0;
+
+			ret = syscall(900);
+			CHKANDJUMP(ret != 0, 255, "syscall failed\n");
+
+			ret  = ihk_os_getrusage(0, &rusage, sizeof(rusage));
+			CHKANDJUMP(ret != 0, 255, "ihk_os_getrusage failed\n");
+
+			for (i = 0; i < IHK_MAX_NUM_PGSIZES; i++) {
+				printf("memory_stat_rss[%d]=%ld\n",
+				       i, rusage.memory_stat_rss[i]);
+				printf("memory_stat_mapped_file[%d]=%ld\n",
+				       i, rusage.memory_stat_mapped_file[i]);
+			}
+			printf("memory_max_usage=%ld\n",
+			       rusage.memory_max_usage);
+			printf("memory_kmem_usage=%ld\n",
+			       rusage.memory_kmem_usage);
+			printf("memory_kmem_max_usage=%ld\n",
+			       rusage.memory_kmem_max_usage);
+#define NUM_NUMA_NODES 2
+			for (i = 0; i < NUM_NUMA_NODES; i++) {
+				printf("memory_numa_stat[%d]=%ld\n",
+				       i, rusage.memory_numa_stat[i]);
+			}
+#define NUM_CPUS 2
+			for (i = 0; i < NUM_CPUS; i++) {
+				printf("cpuacct_usage_percpu[%d]=%ld\n",
+				       i, rusage.cpuacct_usage_percpu[i]);
+			}
+			printf("cpuacct_stat_system=%ld\n",
+			       rusage.cpuacct_stat_system);
+			printf("cpuacct_stat_user=%ld\n",
+			       rusage.cpuacct_stat_user);
+			printf("cpuacct_usage=%ld\n", rusage.cpuacct_usage);
+
+			printf("num_threads=%d\n", rusage.num_threads);
+			printf("max_num_threads=%d\n", rusage.max_num_threads);
+		}
+		_exit(123);
+	} else {
+		ret = waitpid(pid, &status, 0);
+		CHKANDJUMP(ret == -1, 255, "waitpid failed\n");
+	}
+
+ fn_exit:
+	return ret;
+ fn_fail:
+	goto fn_exit;
+}

test/rusage/102_mck.c

@@ -0,0 +1,78 @@
+#include <stdio.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <sys/syscall.h>   /* For SYS_xxx definitions */
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include "util.h"
+#include "ihklib.h"
+#include "mckernel/ihklib_rusage.h"
+
+#define DEBUG
+
+int sz_mem[] = {
+	4 * (1ULL<<10),
+	2 * (1ULL<<20),
+	1 * (1ULL<<30),
+	134217728};
+
+#define SZ_INDEX 0
+#define NLOOP 2
+
+int main(int argc, char **argv)
+{
+	int i, j, ret = 0;
+	void *mem;
+	int fd;
+	struct mckernel_rusage rusage;
+
+	fd = open("./file", O_RDWR);
+	CHKANDJUMP(fd == -1, 255, "open failed\n");
+
+	for (j = 0; j < NLOOP; j++) {
+
+		mem = mmap(0, sz_mem[SZ_INDEX], PROT_READ | PROT_WRITE,
+			   MAP_SHARED, fd, sz_mem[SZ_INDEX] * j);
+		CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
+		*((unsigned long *)mem) = 0x123456789abcdef0;
+
+		ret = syscall(900);
+		CHKANDJUMP(ret != 0, 255, "syscall failed\n");
+
+		ret  = ihk_os_getrusage(0, &rusage, sizeof(rusage));
+		CHKANDJUMP(ret != 0, 255, "ihk_os_getrusage failed\n");
+
+		for (i = 0; i < IHK_MAX_NUM_PGSIZES; i++) {
+			printf("memory_stat_rss[%d]=%ld\n",
+			       i, rusage.memory_stat_rss[i]);
+			printf("memory_stat_mapped_file[%d]=%ld\n",
+			       i, rusage.memory_stat_mapped_file[i]);
+		}
+		printf("memory_max_usage=%ld\n", rusage.memory_max_usage);
+		printf("memory_kmem_usage=%ld\n", rusage.memory_kmem_usage);
+		printf("memory_kmem_max_usage=%ld\n",
+		       rusage.memory_kmem_max_usage);
+#define NUM_NUMA_NODES 2
+		for (i = 0; i < NUM_NUMA_NODES; i++) {
+			printf("memory_numa_stat[%d]=%ld\n",
+			       i, rusage.memory_numa_stat[i]);
+		}
+#define NUM_CPUS 2
+		for (i = 0; i < NUM_CPUS; i++) {
+			printf("cpuacct_usage_percpu[%d]=%ld\n",
+			       i, rusage.cpuacct_usage_percpu[i]);
+		}
+		printf("cpuacct_stat_system=%ld\n",
+		       rusage.cpuacct_stat_system);
+		printf("cpuacct_stat_user=%ld\n", rusage.cpuacct_stat_user);
+		printf("cpuacct_usage=%ld\n", rusage.cpuacct_usage);
+
+		printf("num_threads=%d\n", rusage.num_threads);
+		printf("max_num_threads=%d\n", rusage.max_num_threads);
+	}
+ fn_exit:
+	return ret;
+ fn_fail:
+	goto fn_exit;
+}

test/rusage/103_mck.c

@@ -0,0 +1,70 @@
+#include <stdio.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <sys/syscall.h>   /* For SYS_xxx definitions */
+#include "util.h"
+#include "ihklib.h"
+#include "mckernel/ihklib_rusage.h"
+
+#define DEBUG
+
+int sz_anon[] = {
+	4 * (1ULL<<10),
+	2 * (1ULL<<20),
+	1 * (1ULL<<30),
+	134217728};
+
+#define SZ_INDEX 0
+#define NLOOP 2
+
+int main(int argc, char **argv)
+{
+	int i, j, ret = 0;
+	void *mem;
+	struct mckernel_rusage rusage;
+
+	for (j = 0; j < NLOOP; j++) {
+		mem = mmap(0, sz_anon[SZ_INDEX], PROT_READ | PROT_WRITE,
+			   MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
+		CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
+		*((unsigned long *)mem) = 0x123456789abcdef0;
+
+		ret = syscall(900);
+		CHKANDJUMP(ret != 0, 255, "syscall failed\n");
+
+		ret  = ihk_os_getrusage(0, &rusage, sizeof(rusage));
+		CHKANDJUMP(ret != 0, 255, "ihk_os_getrusage failed\n");
+
+		for (i = 0; i < IHK_MAX_NUM_PGSIZES; i++) {
+			printf("memory_stat_rss[%d]=%ld\n",
+			       i, rusage.memory_stat_rss[i]);
+			printf("memory_stat_mapped_file[%d]=%ld\n",
+			       i, rusage.memory_stat_mapped_file[i]);
+		}
+		printf("memory_max_usage=%ld\n", rusage.memory_max_usage);
+		printf("memory_kmem_usage=%ld\n", rusage.memory_kmem_usage);
+		printf("memory_kmem_max_usage=%ld\n",
+		       rusage.memory_kmem_max_usage);
+#define NUM_NUMA_NODES 2
+		for (i = 0; i < NUM_NUMA_NODES; i++) {
+			printf("memory_numa_stat[%d]=%ld\n",
+			       i, rusage.memory_numa_stat[i]);
+		}
+#define NUM_CPUS 2
+		for (i = 0; i < NUM_CPUS; i++) {
+			printf("cpuacct_usage_percpu[%d]=%ld\n",
+			       i, rusage.cpuacct_usage_percpu[i]);
+		}
+		printf("cpuacct_stat_system=%ld\n",
+		       rusage.cpuacct_stat_system);
+		printf("cpuacct_stat_user=%ld\n", rusage.cpuacct_stat_user);
+		printf("cpuacct_usage=%ld\n", rusage.cpuacct_usage);
+
+		printf("num_threads=%d\n", rusage.num_threads);
+		printf("max_num_threads=%d\n", rusage.max_num_threads);
+	}
+ fn_exit:
+	return ret;
+ fn_fail:
+	goto fn_exit;
+}

test/rusage/200_lin.c

@@ -20,7 +20,7 @@ int main(int argc, char **argv)
 	if ((ret = ihk_os_getrusage(0, &rusage, sizeof(rusage)))) {
 		fprintf(stderr, "%s: ihk_os_getrusage failed\n", __func__);
 		ret = -EINVAL;
-		goto out;
+		goto fn_fail;
 	}
 
 	OKNG(WITHIN_RANGE(rusage.cpuacct_usage_percpu[1], DELAY0, SCALE),
@@ -32,7 +32,7 @@ int main(int argc, char **argv)
 
 	printf("All tests finished\n");
 
- out:
+ fn_fail:
 	return ret;
 }
 

test/rusage/200_mck.c

@@ -12,6 +12,7 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
+#include "util.h"
 
 
 #define DELAY0 (100UL * 1000 * 1000)
@@ -115,7 +116,6 @@ unsigned long nsec;
 void fwq_init(void)
 {
 	struct timespec start, end;
-	int i;
 
 	clock_gettime(TIMER_KIND, &start);
 #define N_INIT 10000000

test/rusage/Makefile

@@ -1,179 +1,60 @@
-.SUFFIXES:	# Clear suffixes
+include $(HOME)/.mck_test_config.mk
-.SUFFIXES:	.c
+XPMEM_DIR=$(HOME)/usr
 
 CC = gcc
 
-CPPFLAGS = -I$(HOME)/project/os/install/include
+CPPFLAGSLIN = -I$(MCK_DIR)/include
-CCFLAGS = -g
+CFLAGSLIN = -Wall -Werror -g
-LDFLAGS = -L$(HOME)/project/os/install/lib -lihk -Wl,-rpath -Wl,$(HOME)/project/os/install/lib -lpthread
+LDFLAGSLIN = -L$(MCK_DIR)/lib -lihk -Wl,-rpath -Wl,$(MCK_DIR)/lib -lpthread
-EXES =
+SRCSLIN = $(shell ls *_lin.c)
-SRCS =
+EXESLIN = $(SRCSLIN:.c=)
-OBJS = $(SRCS:.c=.o)
+OBJSLIN = $(SRCSLIN:.c=.o)
 
-CPPFLAGSMCK = -I$(HOME)/usr/include
+CPPFLAGSMCK =
-CCFLAGSMCK = -g -O0
+CFLAGSMCK = -Wall -Werror -g -O0
-LDFLAGSMCK = -static -lpthread
+LDFLAGSMCK =
-SRCSMCK = $(shell ls rusage*.c)
+SRCSMCK = $(shell ls *.c | grep -vE '_lin')
 EXESMCK = $(SRCSMCK:.c=)
 OBJSMCK = $(SRCSMCK:.c=.o)
 
-all: $(EXES) $(EXESMCK)
+all: $(EXESLIN) $(EXESMCK)
 
-rusage000: rusage000.o
+011_mck: 011_mck.o
-	$(CC) -o $@ $^ $(LDFLAGSMCK)
+	$(CC) -o $@ $^ $(LDFLAGSMCK) -L$(XPMEM_DIR)/lib -lxpmem
 
-rusage000.o: rusage000.c
+011_mck.o: 011_mck.c
-	$(CC) $(CCFLAGSMCK) $(CPPFLAGSMCK) -c $<
+	$(CC) $(CFLAGSMCK) $(CPPFLAGSMCK) -I$(XPMEM_DIR)/include -c $<
 
-rusage010: rusage010.o
+012_mck: 012_mck.o
-	$(CC) -o $@ $^ $(LDFLAGSMCK)
+	$(CC) -o $@ $^ $(LDFLAGSMCK) -L$(XPMEM_DIR)/lib -lxpmem -Wl,-rpath -Wl,$(XPMEM_DIR)/lib
 
-rusage010.o: rusage010.c
+012_mck.o: 012_mck.c
-	$(CC) $(CCFLAGSMCK) $(CPPFLAGSMCK) -c $<
+	$(CC) $(CFLAGSMCK) $(CPPFLAGSMCK) -I$(XPMEM_DIR)/include -c $<
 
-rusage020: rusage020.o
+10%_mck: 10%_mck.o
-	$(CC) -o $@ $^ $(LDFLAGSMCK)
+	$(CC) -o $@ $^ $(LDFLAGSMCK) -L$(MCK_DIR)/lib -lihk -Wl,-rpath -Wl,$(MCK_DIR)/lib
 
-rusage020.o: rusage020.c
+10%_mck.o:: 10%_mck.c
-	$(CC) $(CCFLAGSMCK) $(CPPFLAGSMCK) -c $<
+	$(CC) $(CFLAGSMCK) $(CPPFLAGSMCK) -I$(MCK_DIR)/include -c $<
 
-rusage030: rusage030.o
+20%_mck: 20%_mck.o
-	$(CC) -o $@ $^ $(LDFLAGSMCK)
+	$(CC) -o $@ $^ $(LDFLAGSMCK) -lpthread
 
-rusage030.o: rusage030.c
+20%_mck.o:: 20%_mck.c
-	$(CC) $(CCFLAGSMCK) $(CPPFLAGSMCK) -c $<
+	$(CC) $(CFLAGSMCK) $(CPPFLAGSMCK) -c $<
-
-rusage001: rusage001.o
-	$(CC) -o $@ $^ $(LDFLAGSMCK)
-
-rusage001.o: rusage001.c
-	$(CC) $(CCFLAGSMCK) $(CPPFLAGSMCK) -c $<
-
-rusage002: rusage002.o
-	$(CC) -o $@ $^ $(LDFLAGSMCK) -lrt
-
-rusage002.o: rusage002.c
-	$(CC) $(CCFLAGSMCK) $(CPPFLAGSMCK) -c $<
-
-rusage003: rusage003.o
-	$(CC) -o $@ $^ $(LDFLAGSMCK) -lrt
-
-rusage003.o: rusage003.c
-	$(CC) $(CCFLAGSMCK) $(CPPFLAGSMCK) -c $<
-
-rusage004: rusage004.o
-	$(CC) -o $@ $^ $(LDFLAGSMCK)
-
-rusage004.o: rusage004.c
-	$(CC) $(CCFLAGSMCK) $(CPPFLAGSMCK) -c $<
-
-rusage006: rusage006.o
-	$(CC) -o $@ $^ $(LDFLAGSMCK)
-
-rusage006.o: rusage006.c
-	$(CC) $(CCFLAGSMCK) $(CPPFLAGSMCK) -c $<
-
-rusage007: rusage007.o
-	$(CC) -o $@ $^ $(LDFLAGSMCK)
-
-rusage007.o: rusage007.c
-	$(CC) $(CCFLAGSMCK) $(CPPFLAGSMCK) -c $<
-
-rusage008: rusage008.o
-	$(CC) -o $@ $^ $(LDFLAGSMCK)
-
-rusage008.o: rusage008.c
-	$(CC) $(CCFLAGSMCK) $(CPPFLAGSMCK) -c $<
-
-rusage009: rusage009.o
-	$(CC) -o $@ $^ $(LDFLAGSMCK)
-
-rusage009.o: rusage009.c
-	$(CC) $(CCFLAGSMCK) $(CPPFLAGSMCK) -c $<
-
-rusage011: rusage011.o
-	$(CC) -o $@ $^ $(LDFLAGSMCK) -L/home/takagi/usr/lib -lxpmem
-
-rusage011.o: rusage011.c
-	$(CC) $(CCFLAGSMCK) $(CPPFLAGSMCK) -c $<
-
-rusage012: rusage012.o
-	$(CC) -o $@ $^ $(LDFLAGSMCK) -L/home/takagi/usr/lib -lxpmem
-
-rusage012.o: rusage012.c
-	$(CC) $(CCFLAGSMCK) $(CPPFLAGSMCK) -c $<
-
-rusage013: rusage013.o
-	$(CC) -o $@ $^ $(LDFLAGSMCK)
-
-rusage013.o: rusage013.c
-	$(CC) $(CCFLAGSMCK) $(CPPFLAGSMCK) -c $<
-
-rusage014: rusage014.o
-	$(CC) -o $@ $^ $(LDFLAGSMCK)
-
-rusage014.o: rusage014.c
-	$(CC) $(CCFLAGSMCK) $(CPPFLAGSMCK) -c $<
-
-rusage015: rusage015.o
-	$(CC) -o $@ $^ $(LDFLAGSMCK)
-
-rusage015.o: rusage015.c
-	$(CC) $(CCFLAGSMCK) $(CPPFLAGSMCK) -c $<
-
-rusage016: rusage016.o
-	$(CC) -o $@ $^ $(LDFLAGSMCK)
-
-rusage016.o: rusage016.c
-	$(CC) $(CCFLAGSMCK) $(CPPFLAGSMCK) -c $<
-
-rusage017: rusage017.o
-	$(CC) -o $@ $^ $(LDFLAGSMCK)
-
-rusage017.o: rusage017.c
-	$(CC) $(CCFLAGSMCK) $(CPPFLAGSMCK) -c $<
-
-rusage018: rusage018.o
-	$(CC) -o $@ $^ $(LDFLAGSMCK)
-
-rusage018.o: rusage018.c
-	$(CC) $(CCFLAGSMCK) $(CPPFLAGSMCK) -c $<
-
-rusage100: rusage100.o
-	$(CC) -o $@ $^ $(LDFLAGS)
-
-rusage100.o: rusage100.c
-	$(CC) $(CCFLAGS) $(CPPFLAGS) -c $<
-
-rusage101: rusage101.o
-	$(CC) -o $@ $^ $(LDFLAGS)
-
-rusage101.o: rusage101.c
-	$(CC) $(CCFLAGS) $(CPPFLAGS) -c $<
-
-rusage102: rusage102.o
-	$(CC) -o $@ $^ $(LDFLAGS)
-
-rusage102.o: rusage102.c
-	$(CC) $(CCFLAGS) $(CPPFLAGS) -c $<
-
-rusage103: rusage103.o
-	$(CC) -o $@ $^ $(LDFLAGS)
-
-rusage103.o: rusage103.c
-	$(CC) $(CCFLAGS) $(CPPFLAGS) -c $<
 
 %_mck: %_mck.o
 	$(CC) -o $@ $^ $(LDFLAGSMCK)
 
 %_mck.o:: %_mck.c
-	$(CC) $(CCFLAGSMCK) $(CPPFLAGSMCK) -c $<
+	$(CC) $(CFLAGSMCK) $(CPPFLAGSMCK) -c $<
+
 
 %_lin.o:: %_lin.c
-	$(CC) $(CCFLAGS) $(CPPFLAGS) -c $<
+	$(CC) $(CFLAGSLIN) $(CPPFLAGSLIN) -c $<
 
 %_lin: %_lin.o
-	$(CC) -o $@ $^ $(LDFLAGS)
+	$(CC) -o $@ $^ $(LDFLAGSLIN)
 
 clean:
-	rm -f core $(EXES) $(OBJS) $(EXESMCK) $(OBJSMCK)
+	rm -f core $(EXESLIN) $(OBJSLIN) $(EXESMCK) $(OBJSMCK)

test/rusage/README

@@ -1,10 +1,14 @@
 ==========
 How to run
 ==========
-./run.sh <rusagexxx>
+(1) cp <build>/mckernel/mck_test_config.sample \
-
+    ~/.mck_test_config
-Example:
+(2) cp <build>/ihk/mck_test_config.mk.sample \
-./run.sh rusage000
+    ~/.mck_test_config.mk
+(3) Edit the following line in Makefile:
+    XPMEM_DIR=/usr/
+(4) ./run.sh <test_id>
+    Example: ./run.sh 000
 
 ===================================
 How to judge it behaves as expected
@@ -14,7 +18,7 @@ Follow the instruction given by run.sh.
 =====================
 Descripation of tests
 =====================
-rusage000: Excercise the following execution paths:
+000: Excercise the following execution paths:
   args_envs()->set_range() text,data,arg,env[OK]
   args_envs()->set_range() !vdso [OK],
   args_envs()->set_range() stack[OK],
@@ -29,89 +33,89 @@ rusage000: Excercise the following execution paths:
   exit_group()->free_process_memory_range()->!vdso[OK],
   exit_group()->free_process_memory_range()->stack[OK],
 
-rusage010: Excercise the following execution paths:
+010: Excercise the following execution paths:
   app->mmap() 2M,anon,pre-page ->set_range()->munmap()->free_process_memory_range()->clear_range()[OK]
 
-rusage020: Excercise the following execution paths:
+020: Excercise the following execution paths:
   app->mmap() 1G,anon,private,demand-page -> pf -> set_range() [NA (failed to get 1GB page)],
   app->mmap() 1G,anon,private,demand-page -> pf -> set_range()->munmap()->free_process_memory_range()->clear_range()[NA (failed to get 1GB page)]
 
-rusage030: Excercise the following execution paths:
+030: Excercise the following execution paths:
   app->mmap() 128M,anon,private,demand-page(=zeroobj) -> pf -> set_range() [OK],
   app->mmap() 128M,anon,private,demand-page(=zeroobj) -> pf -> set_range()->munmap()->free_process_memory_range()->clear_range()[OK]
 
-rusage001: Excercise the following execution paths:
+001: Excercise the following execution paths:
   do_mmap(),file,demand-page->get_page(),ld->set_pte()->munmap()->clear_range() [OK]
   do_mmap(),file,demand-page->get_page(),ld->set_pte()->st->munmap()->clear_range() [OK]
   do_mmap(),file,demand-page->get_page(),st->set_pte()->flush()->munmap()->clear_range() [OK]
 
-rusage002: Excercise the following execution paths: 
+002: Excercise the following execution paths:
   do_mmap(),/dev/shm with --mpol_shm_premap,pre-page->get_page(),st->set_pte()->munmap()->clear_range() [OK]
 
-rusage003: Excercise the following execution paths: 
+003: Excercise the following execution paths:
   do_mmap(),/dev/shm without --mpol_shm_premap,pre-page->get_page(),st->set_pte()->munmap()->clear_range() [OK]
 
-rusage004: Excercise the following execution paths related to clone
+004: Excercise the following execution paths related to clone
   load segments->copy_user_ranges()->clear_range() [OK]
   filemap(demand-paging)->copy_user_ranges()->clear_range() [OK]
 
-rusage005: Excercise the following execution paths related to device file (ib ping-pong)
+005: Excercise the following execution paths related to device file (ib ping-pong)
   devobj()->get_page()->pf->munmap()->clear_range() [OK]
   remote page fault->cow->clear_range() [OK]
   ld-linux.so->mmap private->cow->clear_range() [OK]
 
-rusage006: Excercise the following execution paths related to clone
+006: Excercise the following execution paths related to clone
   filemap,/dev/shm with --mpol_shm_premap->copy_user_ranges()->clear_range() [OK]
 
-rusage007: Excercise the following execution paths related to clone
+007: Excercise the following execution paths related to clone
   filemap,/dev/shm without --mpol_shm_premap->copy_user_ranges()->clear_range() [OK]
 
-rusage008: Excercise the following execution paths related to sharing file-map page
+008: Excercise the following execution paths related to sharing file-map page
 fork()->filemap->pf->clear_range() [OK]
 
-rusage009: Excercise the following execution paths related to sharing shmget() page
+009: Excercise the following execution paths related to sharing shmget() page
 fork()->shmat()->pf->clear_range() [OK]
 
-rusage011: Excercise the following execution paths related to sharing xpmem page
+011: Excercise the following execution paths related to sharing xpmem page
 fork()->xpmem_attach()->pf->clear_range() [OK]
 
-rusage012: #925
+012: #925
 
-rusage013: Excercise the following execution paths: 
+013: Excercise the following execution paths:
 fileobj(prvate)->cow->set_pte()->clear_range() [OK]
 
-rusage014: Excercise the following execution paths related to remap_file_pages
+014: Excercise the following execution paths related to remap_file_pages
 do_mmap->fileobj-->remap_file_pages()->st->clear_range() [OK]
 
-rusage015: Excercise the following execution paths related to remap_file_pages
+015: Excercise the following execution paths related to remap_file_pages
 do_mmap->fileobj-->st-->remap_one_page()->clear_range() [OK]
 
-rusage016: Excercise the following execution paths related to mremap
+016: Excercise the following execution paths related to mremap
 mremap()->move_pte_range()-->clear_range() [OK]
 
-rusage017: Excercise the following execution paths related to split_process_memory_range, file-map
+017: Excercise the following execution paths related to split_process_memory_range, file-map
 mprotect()->split_process_memory_range()->change_prot_process_memory_range()->clear_range()/file_obj_release() [OK]
 
-rusage018: Excercise the following execution paths related to split_process_memory_range, 2M-page
+018: Excercise the following execution paths related to split_process_memory_range, 2M-page
 mprotect()->ihk_mc_pt_split()->change_prot_process_memory_range()->clear_range() [OK]
 
-rusage019: Run npb bt-mz.S.2
+019: Run npb bt-mz.S.2
 1-ppn x 2-tpn x 2-node[OK]
 
-rusage021: Run npb bt-mz.S.4
+021: Run npb bt-mz.S.4
 2-ppn x 2-tpn x 2-node (wallaby{14,15}) [OK]
 2-ppn x 1-tpn x 2-node (polaris,kochab) [OK]
 
-rusage100: Test ihk_os_getrusage()
+100: Test ihk_os_getrusage(), call from McKernel process
 anon mmap,num_threads=1 [OK]
 
-rusage101: Test ihk_os_getrusage()
+101: Test ihk_os_getrusage(), call from McKernel process
 anon mmap,num_threads=2 [OK]
 
-rusage102: Test ihk_os_getrusage()
+102: Test ihk_os_getrusage(), call from McKernel process
 file map,num_threads=1 [OK]
 
-rusage103: Test ihk_os_getrusage()
+103: Test ihk_os_getrusage(), call from McKernel process
 anon mmap@numa#1 [OK]
 
-rusage104: Test ihk_os_getrusage(), user time per CPU
+200: Test ihk_os_getrusage(), user time per CPU

test/rusage/run.sh

@@ -1,5 +1,7 @@
 #!/usr/bin/bash
 
+. ${HOME}/.mck_test_config
+
 testname=$1
 bootopt="-m 256M"
 mcexecopt=""
@@ -7,21 +9,19 @@ testopt=""
 kill="n"
 dryrun="n"
 sleepopt="0.4"
-home=$(eval echo \$\{HOME\})
-install=${home}/project/os/install
 
 echo Executing ${testname}
 
 case ${testname} in
-    rusage011 | rusage012)
+    011 | 012)
 	printf "*** Enable debug messages in rusage.h, memory.c, fileobj.c, shmobj.c, process.c by defining DEBUG macro, e.g. #define RUSAGE_DEBUG and then recompile IHK/McKernel.\n"
 	printf "*** Install xpmem by git-clone https://github.com/hjelmn/xpmem.\n"
 	;;
-    rusage100 | rusage101 | rusage102 | rusage103)
+    100 | 101 | 102 | 103)
 	printf "*** Refer to rusage100.patch to add syscall #900 by editing syscall_list.h and syscall.c and recompile IHK/McKernel.\n"
 	;;
-    rusage104)
+    200)
-	printf "*** Apply rusage104.patch to enable syscall #900"
+	printf "*** Apply rusage200.patch to enable syscall #900"
 	printf "which reports rusage values.\n"
 	;;
     *)
@@ -32,33 +32,34 @@ esac
 read -p "*** Hit return when ready!" key
 
 case ${testname} in
-    rusage005)
+    005)
-	ssh wallaby -c '(cd ${home}/project/src/rusage/verbs; make rdma_wr)'
+	ssh wallaby -c '(cd ${HOME}/project/src/rusage/verbs; make rdma_wr)'
-	bn=verbs/rdma_wr
+	bn_mck=verbs/rdma_wr
 	;;
-    rusage019)
+    019)
-	#ssh wallaby -c '(cd ${home}/project/src/rusage/npb/NPB3.3.1-MZ/NPB3.3-MZ-MPI; make bt-mz CLASS=S NPROCS=2)'
+	#ssh wallaby -c '(cd ${HOME}/project/src/rusage/npb/NPB3.3.1-MZ/NPB3.3-MZ-MPI; make bt-mz CLASS=S NPROCS=2)'
-	bn=npb/NPB3.3.1-MZ/NPB3.3-MZ-MPI/bin/bt-mz.S.2
+	bn_mck=npb/NPB3.3.1-MZ/NPB3.3-MZ-MPI/bin/bt-mz.S.2
 	perl -e 'print "wallaby14\nwallaby15\n"' > ./hostfile
 	;;
-    rusage021)
+    021)
 	if ! grep /var/log/local6 /etc/rsyslog.conf &>/dev/null; then
 	    echo "Insert a line of local6.* /var/log/local6 into /etc/rsyslog.conf"
 	    exit 255
 	fi
-	ssh wallaby bash -c '(cd ${home}/project/src/rusage/npb/NPB3.3.1-MZ/NPB3.3-MZ-MPI; make bt-mz CLASS=S NPROCS=4)'
+	ssh wallaby bash -c '(cd ${HOME}/project/src/rusage/npb/NPB3.3.1-MZ/NPB3.3-MZ-MPI; make bt-mz CLASS=S NPROCS=4)'
-	bn=npb/NPB3.3.1-MZ/NPB3.3-MZ-MPI/bin/bt-mz.S.4
+	bn_mck=npb/NPB3.3.1-MZ/NPB3.3-MZ-MPI/bin/bt-mz.S.4
 	perl -e 'print "polaris:2\nkochab:2\n"' > ./hostfile
 	;;
-    rusage104)
+    200)
-	bn=${testname}
+	bn_mck=${testname}_mck
+	bn_lin=${testname}_lin
 	make clean > /dev/null 2> /dev/null
-	make ${bn}_mck ${bn}_lin
+	make $bn_mck $bn_lin
 	;;
     *)
-	bn=${testname}
+	bn_mck=${testname}_mck
 	make clean > /dev/null 2> /dev/null
-	make ${bn}
+	make $bn_mck
 esac
 
 pid=`pidof mcexec`
@@ -67,91 +68,82 @@ if [ "${pid}" != "" ]; then
 fi
 
 case ${testname} in
-    rusage000)
+    000)
 	testopt="0"
 	;;
-    rusage010)
+    010)
 	testopt="1"
 	;;
-    rusage020)
+    020)
 	bootopt="-m 256M@0,1G@0"
 	testopt="2"
 	kill="y"
 	;;
-    rusage030)
+    030)
 	testopt="3"
 	;;
-    rusage001)
+    001)
-	cp ${bn} ./file
+	cp $bn_mck ./file
 	kill="n"
 	;;
-    rusage002)
+    002)
 	mcexecopt="--mpol-shm-premap"
 	;;
-    rusage003)
+    003)
 	;;
-    rusage004)
+    004)
-	cp ${bn} ./file
+	cp $bn_mck ./file
 	;;
-    rusage005)
+    005)
-	echo ssh wallaby15.aics-sys.riken.jp ${home}/project/src/verbs/rdma_wr -p 10000&
+	echo ssh wallaby15.aics-sys.riken.jp ${HOME}/project/src/verbs/rdma_wr -p 10000&
 	read -p "Run rdma_wr on wallaby15 and enter the port number." port
 	testopt="-s wallaby15.aics-sys.riken.jp -p ${port}"
 	;;
-    rusage006)
+    006)
 	mcexecopt="--mpol-shm-premap"
 	;;
-    rusage007)
+    007)
 	;;
-    rusage008)
+    008)
-	cp ${bn} ./file
+	cp $bn_mck ./file
 	;;
-    rusage009)
+    009)
 	;;
-    rusage011)
+    011)
 	sudo insmod /home/takagi/usr/lib/module/xpmem.ko
 	sudo chmod og+rw /dev/xpmem
 	dryrun="n"
 	kill="n"
 	sleepopt="5"
 	;;
-    rusage012)
+    012)
 	sudo insmod /home/takagi/usr/lib/module/xpmem.ko
 	sudo chmod og+rw /dev/xpmem
 	dryrun="n"
 	kill="n"
 	sleepopt="5"
 	;;
-    rusage013)
+    013 | 014 | 015 | 017)
-	cp ${bn} ./file
+	cp $bn_mck ./file
 	;;
-    rusage014)
+    016)
-	cp ${bn} ./file
 	;;
-    rusage015)
+    018)
-	cp ${bn} ./file
 	;;
-    rusage016)
+    019 | 021)
-	;;
-    rusage017)
-	cp ${bn} ./file
-	;;
-    rusage018)
-	;;
-    rusage019 | rusage021)
 	bootopt="-k 1 -m 256M"
 	;;
-    rusage100)
+    100)
 	;;
-    rusage101)
+    101)
 	;;
-    rusage102)
+    102)
-	cp ${bn} ./file
+	cp $bn_lin ./file
 	;;
-    rusage103)
+    103)
 	bootopt="-m 256M@1"
 	;;
-    rusage104)
+    200)
 	bootopt="-c 1,2,3 -m 256M"
 	;;
     *)
@@ -164,7 +156,7 @@ exit
 fi
 
 case ${testname} in
-    rusage019 | rusage021)
+    019 | 021)
 	sudo rm /var/log/local6
 	sudo touch /var/log/local6
 	sudo chmod 600 /var/log/local6
@@ -175,60 +167,69 @@ case ${testname} in
 esac
 
 case ${testname} in
-    rusage019 | rusage021)
+    019 | 021)
-	echo sudo ssh wallaby15 ${install}/sbin/mcstop+release.sh &&
+	echo sudo ssh wallaby15 ${MCK_DIR}/sbin/mcstop+release.sh &&
-	echo sudo ssh wallaby15 ${install}/sbin/mcreboot.sh
+	echo sudo ssh wallaby15 ${MCK_DIR}/sbin/mcreboot.sh
 	read -p "Boot mckernel on wallaby15." ans
 	;;
     *)
 	;;
 esac
-sudo ${install}/sbin/mcstop+release.sh &&
+sudo ${MCK_DIR}/sbin/mcstop+release.sh &&
-sudo ${install}/sbin/mcreboot.sh ${bootopt}
+sudo ${MCK_DIR}/sbin/mcreboot.sh ${bootopt}
 
 if [ ${kill} == "y" ]; then
-    ${install}/bin/mcexec ${mcexecopt} ./${bn} ${testopt} &
+    ${MCK_DIR}/bin/mcexec ${mcexecopt} ./${bn} ${testopt} &
     sleep ${sleepopt}
-    sudo ${install}/sbin/ihkosctl 0 kmsg > ./${testname}.log
+    sudo ${MCK_DIR}/sbin/ihkosctl 0 kmsg > ./${testname}.log
     pid=`pidof mcexec`
     if [ "${pid}" != "" ]; then
 	kill -9 ${pid} > /dev/null 2> /dev/null
     fi
 else
     case ${testname} in
-	rusage005)
+	005)
-	    ${install}/bin/mcexec ${mcexecopt} ./${bn} ${testopt}
+	    ${MCK_DIR}/bin/mcexec ${mcexecopt} ./${bn_mck} ${testopt}
 	    #read -p "Run rdma_wr." ans
-	    sudo ${install}/sbin/ihkosctl 0 kmsg > ./${testname}.log
+	    sudo ${MCK_DIR}/sbin/ihkosctl 0 kmsg > ./${testname}.log
 	    ;;
-	rusage019 | rusage021)
+	019 | 021)
-	    echo OMP_NUM_THREADS=2 mpiexec -machinefile ./hostfile ${install}/bin/mcexec ${mcexecopt} ./${bn} ${testopt}
+	    echo OMP_NUM_THREADS=2 mpiexec -machinefile ./hostfile ${MCK_DIR}/bin/mcexec ${mcexecopt} ./${bn_mck} ${testopt}
-	    read -p "Run ${bn} and hit return." ans
+	    read -p "Run ${bn_mck} and hit return." ans
 	    sleep 1.5
 	    sudo cat /var/log/local6 > ./${testname}.log
 	    ;;
-	rusage100 | rusage101 | rusage102 | rusage103)
+	100 | 101 | 102 | 103)
-	    ${install}/bin/mcexec ${mcexecopt} ./${bn} ${testopt} > ./${testname}.log
+	    ${MCK_DIR}/bin/mcexec ${mcexecopt} ./${bn_mck} ${testopt} > ./${testname}.log
 	    echo "================================================" >> ./${testname}.log
-	    sudo ${install}/sbin/ihkosctl 0 kmsg >> ./${testname}.log
+	    sudo ${MCK_DIR}/sbin/ihkosctl 0 kmsg >> ./${testname}.log
 	    ;;
-	rusage104)
+	200)
-	    ${install}/bin/mcexec ${mcexecopt} ./${bn}_mck
+	    ${MCK_DIR}/bin/mcexec ${mcexecopt} ./${bn_mck}
-	    ${install}/bin/mcexec ${mcexecopt} ./${bn}_lin
+	    ${MCK_DIR}/bin/mcexec ${mcexecopt} ./${bn_lin}
-	    sudo ${install}/sbin/ihkosctl 0 kmsg > ./${testname}.log
+	    sudo ${MCK_DIR}/sbin/ihkosctl 0 kmsg > ./${testname}.log
 	    grep user ./${testname}.log
 	    ;;
 	*)
-	    ${install}/bin/mcexec ${mcexecopt} ./${bn} ${testopt}
+	    ${MCK_DIR}/bin/mcexec ${mcexecopt} ./${bn_mck} ${testopt}
-	    sudo ${install}/sbin/ihkosctl 0 kmsg > ./${testname}.log
+	    sudo ${MCK_DIR}/sbin/ihkosctl 0 kmsg > ./${testname}.log
     esac
 fi
 
+
 case ${testname} in
-    rusage100 | rusage101 | rusage102 | rusage103)
+    011 | 012)
+	sudo rmmod xpmem
+	;;
+    *)
+	;;
+esac
+
+case ${testname} in
+    100 | 101 | 102 | 103)
 	printf "*** Check the ihk_os_getrusage() result (the first part of ${testname}.log) matches with the syscall #900 result (the second part) \n"
 	;;
-    rusage104)
+    200)
 	printf "*** It behaves as expected when there's no [NG] and "
 	printf "\"All tests finished\" is shown\n"
 	;;
@@ -238,4 +239,4 @@ case ${testname} in
 	;;
 esac
 
-sudo ${install}/sbin/mcstop+release.sh
+sudo ${MCK_DIR}/sbin/mcstop+release.sh

test/rusage/rusage000.c

@@ -1,67 +0,0 @@
-#include <unistd.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/mman.h>
-#include <string.h>
-
-#define DEBUG
-
-#ifdef DEBUG
-#define dprintf(...)                                            \
-    do {                                                        \
-	char msg[1024];                                         \
-	sprintf(msg, __VA_ARGS__);                              \
-	fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#define eprintf(...)                                            \
-    do {                                                        \
-	char msg[1024];                                         \
-	sprintf(msg, __VA_ARGS__);                              \
-	fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#else
-#define dprintf(...) do {  } while (0)
-#define eprintf(...) do {  } while (0)
-#endif
-
-#define CHKANDJUMP(cond, err, ...)                                      \
-    do {                                                                \
-		if(cond) {                                                      \
-			eprintf(__VA_ARGS__);                                       \
-			ret = err;                                                  \
-			goto fn_fail;                                               \
-		}                                                               \
-    } while(0)
-
-int sz_anon[] = {
-	4 * (1ULL<<10),
-	2 * (1ULL<<20),
-	1 * (1ULL<<30),
-	134217728};
-
-#define SZ_INDEX 0
-#define NUM_AREAS 1
-
-int main(int argc, char** argv) {
-	int i;
-	int sz_index;
-	void* anon[NUM_AREAS];
-	int ret = 0;
-	CHKANDJUMP(argc != 2, 255, "%s <sz_index>\n", argv[0]);
-	sz_index = atoi(argv[1]);
-	
-	for(i = 0; i < NUM_AREAS; i++) {
-		anon[i] = mmap(0, sz_anon[sz_index], PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
-		CHKANDJUMP(anon[i] == MAP_FAILED, 255, "mmap failed\n");
-		*((unsigned long*)anon[i]) = 0x123456789abcdef0;
-	}
-
-	for(i = 0; i < NUM_AREAS; i++) {
-		munmap(anon[i], sz_anon[sz_index]);
-	}
-	
- fn_exit:
-	return ret;
- fn_fail:
-	goto fn_exit;
-}

test/rusage/rusage001.c

@@ -1,72 +0,0 @@
-#include <unistd.h>
-#include <stdio.h>
-#include <sys/mman.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-
-#define DEBUG
-
-#ifdef DEBUG
-#define dprintf(...)                                            \
-    do {                                                        \
-	char msg[1024];                                         \
-	sprintf(msg, __VA_ARGS__);                              \
-	fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#define eprintf(...)                                            \
-    do {                                                        \
-	char msg[1024];                                         \
-	sprintf(msg, __VA_ARGS__);                              \
-	fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#else
-#define dprintf(...) do {  } while (0)
-#define eprintf(...) do {  } while (0)
-#endif
-
-#define CHKANDJUMP(cond, err, ...)                                      \
-    do {                                                                \
-		if(cond) {                                                      \
-			eprintf(__VA_ARGS__);                                       \
-			ret = err;                                                  \
-			goto fn_fail;                                               \
-		}                                                               \
-    } while(0)
-
-int sz_mem[] = {
-	4 * (1ULL<<10),
-	2 * (1ULL<<20),
-	1 * (1ULL<<30),
-	134217728};
-
-#define SZ_INDEX 0
-
-int main(int argc, char** argv) {
-	void* mem;
-	int ret = 0;
-	int fd;
-
-	fd = open("./file", O_RDWR);
-	CHKANDJUMP(fd == -1, 255, "open failed\n");
-
-	mem = mmap(0, sz_mem[SZ_INDEX], PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
-	CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
-
-	unsigned long val = *((unsigned long*)mem);
-	//memset(mem, 0, sz_mem[SZ_INDEX]);
-
-	*((unsigned long*)mem) = 0x123456789abcdef0;
-//ret = msync(mem, sz_mem[SZ_INDEX], MS_SYNC);
-//	*((unsigned long*)mem) = 0x123456789abcdef0;
-
-	munmap(mem, sz_mem[SZ_INDEX]);
-	//ret = close(fd);
-	//CHKANDJUMP(ret != 0, 255, "close failed\n");
-	
- fn_exit:
-	return ret;
- fn_fail:
-	goto fn_exit;
-}

test/rusage/rusage002.c

@@ -1,79 +0,0 @@
-#include <unistd.h>
-#include <stdio.h>
-#include <sys/mman.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <errno.h>
-
-#define DEBUG
-
-#ifdef DEBUG
-#define dprintf(...)                                            \
-    do {                                                        \
-	char msg[1024];                                         \
-	sprintf(msg, __VA_ARGS__);                              \
-	fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#define eprintf(...)                                            \
-    do {                                                        \
-	char msg[1024];                                         \
-	sprintf(msg, __VA_ARGS__);                              \
-	fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#else
-#define dprintf(...) do {  } while (0)
-#define eprintf(...) do {  } while (0)
-#endif
-
-#define CHKANDJUMP(cond, err, ...)                                      \
-    do {                                                                \
-		if(cond) {                                                      \
-			eprintf(__VA_ARGS__);                                       \
-			ret = err;                                                  \
-			goto fn_fail;                                               \
-		}                                                               \
-    } while(0)
-
-int sz_mem[] = {
-	4 * (1ULL<<10),
-	2 * (1ULL<<20),
-	1 * (1ULL<<30),
-	134217728};
-
-#define SZ_INDEX 0
-
-int main(int argc, char** argv) {
-	void* mem;
-	int ret = 0;
-	int fd;
-	char fn[256] = "/dev/shm/Intel_MPI";
-	
-	fd = open(fn, O_CREAT | O_TRUNC | O_RDWR, S_IRUSR | S_IWUSR);
-	CHKANDJUMP(fd == -1, 255, "shm_open failed,str=%s\n", strerror(errno));
-
-	ret = ftruncate(fd, sz_mem[SZ_INDEX]);
-	CHKANDJUMP(ret != 0, 255, "ftruncate failed\n");
-
-	mem = mmap(0, sz_mem[SZ_INDEX], PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
-	CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
-
-	//unsigned long val = *((unsigned long*)mem);
-	//memset(mem, 0, sz_mem[SZ_INDEX]);
-
-		*((unsigned long*)mem) = 0x123456789abcdef0;
-	//  ret = msync(mem, sz_mem[SZ_INDEX], MS_SYNC);
-	//	*((unsigned long*)mem) = 0x123456789abcdef0;
-
-	munmap(mem, sz_mem[SZ_INDEX]);
-	ret = close(fd);
-	CHKANDJUMP(ret != 0, 255, "close failed\n");
-	ret = unlink(fn);
-	CHKANDJUMP(ret != 0, 255, "shm_unlink failed\n");
-	
- fn_exit:
-	return ret;
- fn_fail:
-	goto fn_exit;
-}

test/rusage/rusage003.c

@@ -1 +0,0 @@
-rusage002.c

test/rusage/rusage004.c

@@ -1,78 +0,0 @@
-#include <unistd.h>
-#include <stdio.h>
-#include <sys/mman.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <sys/wait.h>
-
-#define DEBUG
-
-#ifdef DEBUG
-#define dprintf(...)                                            \
-    do {                                                        \
-	char msg[1024];                                         \
-	sprintf(msg, __VA_ARGS__);                              \
-	fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#define eprintf(...)                                            \
-    do {                                                        \
-	char msg[1024];                                         \
-	sprintf(msg, __VA_ARGS__);                              \
-	fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#else
-#define dprintf(...) do {  } while (0)
-#define eprintf(...) do {  } while (0)
-#endif
-
-#define CHKANDJUMP(cond, err, ...)                                      \
-    do {                                                                \
-		if(cond) {                                                      \
-			eprintf(__VA_ARGS__);                                       \
-			ret = err;                                                  \
-			goto fn_fail;                                               \
-		}                                                               \
-    } while(0)
-
-int sz_mem[] = {
-	4 * (1ULL<<10),
-	2 * (1ULL<<20),
-	1 * (1ULL<<30),
-	134217728};
-
-#define SZ_INDEX 0
-#define NUM_AREAS 1
-
-int main(int argc, char** argv) {
-	void* mem;
-	int ret = 0;
-	pid_t pid;
-	int status;
-	int fd;
-	
-	fd = open("./file", O_RDWR);
-	CHKANDJUMP(fd == -1, 255, "open failed\n");
-
-	mem = mmap(0, sz_mem[SZ_INDEX], PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
-	CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
-
-	unsigned long val = *((unsigned long*)mem);
-
-	pid = fork();
-	CHKANDJUMP(pid == -1, 255, "fork failed\n");
-	if(pid == 0) {
-		_exit(123);
-	} else {
-		ret = waitpid(pid, &status, 0);
-		CHKANDJUMP(ret == -1, 255, "waitpid failed\n");
-		printf("exit status=%d\n", WEXITSTATUS(status));
-	}
-	
- fn_exit:
-	return ret;
- fn_fail:
-	goto fn_exit;
-}

test/rusage/rusage006.c

@@ -1,85 +0,0 @@
-#include <unistd.h>
-#include <stdio.h>
-#include <sys/mman.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <sys/wait.h>
-
-#define DEBUG
-
-#ifdef DEBUG
-#define dprintf(...)                                            \
-    do {                                                        \
-	char msg[1024];                                         \
-	sprintf(msg, __VA_ARGS__);                              \
-	fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#define eprintf(...)                                            \
-    do {                                                        \
-	char msg[1024];                                         \
-	sprintf(msg, __VA_ARGS__);                              \
-	fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#else
-#define dprintf(...) do {  } while (0)
-#define eprintf(...) do {  } while (0)
-#endif
-
-#define CHKANDJUMP(cond, err, ...)                                      \
-    do {                                                                \
-		if(cond) {                                                      \
-			eprintf(__VA_ARGS__);                                       \
-			ret = err;                                                  \
-			goto fn_fail;                                               \
-		}                                                               \
-    } while(0)
-
-int sz_mem[] = {
-	4 * (1ULL<<10),
-	2 * (1ULL<<20),
-	1 * (1ULL<<30),
-	134217728};
-
-#define SZ_INDEX 0
-#define NUM_AREAS 1
-
-int main(int argc, char** argv) {
-	void* mem;
-	int ret = 0;
-	pid_t pid;
-	int status;
-	int fd;
-	
-	char fn[256] = "/dev/shm/Intel_MPI";
-	
-	fd = open(fn, O_CREAT | O_TRUNC | O_RDWR, S_IRUSR | S_IWUSR);
-	CHKANDJUMP(fd == -1, 255, "shm_open failed,str=%s\n", strerror(errno));
-
-	ret = ftruncate(fd, sz_mem[SZ_INDEX]);
-	CHKANDJUMP(ret != 0, 255, "ftruncate failed\n");
-
-	mem = mmap(0, sz_mem[SZ_INDEX], PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
-	CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
-
-	//unsigned long val = *((unsigned long*)mem);
-	*((unsigned long*)mem) = 0x123456789abcdef0;
-
-	pid = fork();
-	CHKANDJUMP(pid == -1, 255, "fork failed\n");
-	if(pid == 0) {
-		_exit(123);
-	} else {
-		ret = waitpid(pid, &status, 0);
-		CHKANDJUMP(ret == -1, 255, "waitpid failed\n");
-		printf("exit status=%d\n", WEXITSTATUS(status));
-	}
-
-	
- fn_exit:
-	return ret;
- fn_fail:
-	goto fn_exit;
-}

test/rusage/rusage007.c

@@ -1 +0,0 @@
-rusage006.c

test/rusage/rusage008.c

@@ -1,86 +0,0 @@
-#include <unistd.h>
-#include <stdio.h>
-#include <sys/mman.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <sys/wait.h>
-
-#define DEBUG
-
-#ifdef DEBUG
-#define dprintf(...)                                            \
-    do {                                                        \
-	char msg[1024];                                         \
-	sprintf(msg, __VA_ARGS__);                              \
-	fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#define eprintf(...)                                            \
-    do {                                                        \
-	char msg[1024];                                         \
-	sprintf(msg, __VA_ARGS__);                              \
-	fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#else
-#define dprintf(...) do {  } while (0)
-#define eprintf(...) do {  } while (0)
-#endif
-
-#define CHKANDJUMP(cond, err, ...)                                      \
-    do {                                                                \
-		if(cond) {                                                      \
-			eprintf(__VA_ARGS__);                                       \
-			ret = err;                                                  \
-			goto fn_fail;                                               \
-		}                                                               \
-    } while(0)
-
-int sz_mem[] = {
-	4 * (1ULL<<10),
-	2 * (1ULL<<20),
-	1 * (1ULL<<30),
-	134217728};
-
-#define SZ_INDEX 0
-#define NUM_AREAS 1
-
-int main(int argc, char** argv) {
-	void* mem;
-	int ret = 0;
-	pid_t pid;
-	int status;
-	int fd;
-	
-	pid = fork();
-	CHKANDJUMP(pid == -1, 255, "fork failed\n");
-	if(pid == 0) {
-		fd = open("./file", O_RDWR);
-		CHKANDJUMP(fd == -1, 255, "open failed\n");
-		
-		mem = mmap(0, sz_mem[SZ_INDEX], PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
-		CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
-		
-		unsigned long val = *((unsigned long*)mem);
-
-		_exit(123);
-	} else {
-		fd = open("./file", O_RDWR);
-		CHKANDJUMP(fd == -1, 255, "open failed\n");
-		
-		mem = mmap(0, sz_mem[SZ_INDEX], PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
-		CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
-		
-		unsigned long val = *((unsigned long*)mem);
-
-		ret = waitpid(pid, &status, 0);
-		CHKANDJUMP(ret == -1, 255, "waitpid failed\n");
-		printf("exit status=%d\n", WEXITSTATUS(status));
-	}
-	
- fn_exit:
-	return ret;
- fn_fail:
-	goto fn_exit;
-}

test/rusage/rusage009.c

@@ -1,97 +0,0 @@
-#include <unistd.h>
-#include <stdio.h>
-#include <sys/mman.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <sys/wait.h>
-#include <sys/ipc.h>
-#include <sys/shm.h>
-
-#define DEBUG
-
-#ifdef DEBUG
-#define dprintf(...)                                            \
-    do {                                                        \
-	char msg[1024];                                         \
-	sprintf(msg, __VA_ARGS__);                              \
-	fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#define eprintf(...)                                            \
-    do {                                                        \
-	char msg[1024];                                         \
-	sprintf(msg, __VA_ARGS__);                              \
-	fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#else
-#define dprintf(...) do {  } while (0)
-#define eprintf(...) do {  } while (0)
-#endif
-
-#define CHKANDJUMP(cond, err, ...)                                      \
-    do {                                                                \
-		if(cond) {                                                      \
-			eprintf(__VA_ARGS__);                                       \
-			ret = err;                                                  \
-			goto fn_fail;                                               \
-		}                                                               \
-    } while(0)
-
-int sz_mem[] = {
-	4 * (1ULL<<10),
-	2 * (1ULL<<20),
-	1 * (1ULL<<30),
-	134217728};
-
-#define SZ_INDEX 0
-
-int main(int argc, char** argv) {
-	void* mem;
-	int ret = 0;
-	pid_t pid;
-	int status;
-	key_t key = ftok(argv[0], 0);
-	int shmid;
-	
-	shmid = shmget(key, sz_mem[SZ_INDEX], IPC_CREAT | 0660);
-	CHKANDJUMP(shmid == -1, 255, "shmget failed: %s\n", strerror(errno));
-	
-	pid = fork();
-	CHKANDJUMP(pid == -1, 255, "fork failed\n");
-	if(pid == 0) {
-		mem = shmat(shmid, NULL, 0);
-		CHKANDJUMP(mem == (void*)-1, 255, "shmat failed: %s\n", strerror(errno));
-		
-		*((unsigned long*)mem) = 0x1234;
-
-		ret = shmdt(mem);
-		CHKANDJUMP(ret == -1, 255, "shmdt failed\n");
-
-		_exit(123);
-	} else {
-		mem = shmat(shmid, NULL, 0);
-		CHKANDJUMP(mem == (void*)-1, 255, "shmat failed: %s\n", strerror(errno));
-		
-
-		ret = waitpid(pid, &status, 0);
-		CHKANDJUMP(ret == -1, 255, "waitpid failed\n");
-
-		printf("%lx\n", *((unsigned long*)mem));
-
-#if 0
-		struct shmid_ds buf;
-		ret = shmctl(shmid, IPC_RMID, &buf);
-		CHKANDJUMP(ret == -1, 255, "shmctl failed\n");
-#endif
-
-		ret = shmdt(mem);
-		CHKANDJUMP(ret == -1, 255, "shmdt failed\n");
-	}
-	
- fn_exit:
-	return ret;
- fn_fail:
-	goto fn_exit;
-}

test/rusage/rusage010.c

@@ -1 +0,0 @@
-rusage000.c

test/rusage/rusage011.c

@@ -1,126 +0,0 @@
-#include <unistd.h>
-#include <stdio.h>
-#include <sys/mman.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <sys/wait.h>
-#include <sys/ipc.h>
-#include <sys/shm.h>
-#include <xpmem.h>
-
-#define DEBUG
-
-#ifdef DEBUG
-#define dprintf(...)                                            \
-    do {                                                        \
-	char msg[1024];                                         \
-	sprintf(msg, __VA_ARGS__);                              \
-	fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#define eprintf(...)                                            \
-    do {                                                        \
-	char msg[1024];                                         \
-	sprintf(msg, __VA_ARGS__);                              \
-	fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#else
-#define dprintf(...) do {  } while (0)
-#define eprintf(...) do {  } while (0)
-#endif
-
-#define CHKANDJUMP(cond, err, ...)                                      \
-    do {                                                                \
-		if(cond) {                                                      \
-			eprintf(__VA_ARGS__);                                       \
-			ret = err;                                                  \
-			goto fn_fail;                                               \
-		}                                                               \
-    } while(0)
-
-int sz_mem[] = {
-	4 * (1ULL<<10),
-	2 * (1ULL<<20),
-	1 * (1ULL<<30),
-	134217728};
-
-#define SZ_INDEX 0
-
-int main(int argc, char** argv) {
-	void* mem;
-	int ret = 0;
-	pid_t pid;
-	int status;
-	key_t key = ftok(argv[0], 0);
-	int shmid;
-	xpmem_segid_t segid;
-
-	shmid = shmget(key, sz_mem[SZ_INDEX], IPC_CREAT | 0660);
-	CHKANDJUMP(shmid == -1, 255, "shmget failed: %s\n", strerror(errno));
-	
-	mem = mmap(0, sz_mem[SZ_INDEX], PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
-	CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
-	memset(mem, 0, sz_mem[SZ_INDEX]);
-	
-	pid = fork();
-	CHKANDJUMP(pid == -1, 255, "fork failed\n");
-	if(pid == 0) {
-		void *shm = shmat(shmid, NULL, 0);
-		CHKANDJUMP(shm == (void*)-1, 255, "shmat failed: %s\n", strerror(errno));
-
-		while((segid = *(xpmem_segid_t*)shm) == 0) { };
-
-		ret = shmdt(shm);
-		CHKANDJUMP(ret == -1, 255, "shmdt failed\n");
-
-		ret = xpmem_init();
-		CHKANDJUMP(ret != 0, 255, "xpmem_init failed: %s\n", strerror(errno));
-		
-		xpmem_apid_t apid = xpmem_get(segid, XPMEM_RDWR, XPMEM_PERMIT_MODE, NULL);
-		CHKANDJUMP(apid == -1, 255, "xpmem_get failed: %s\n", strerror(errno));
-
-		struct xpmem_addr addr = { .apid = apid, .offset = 0 };
-		void* attach = xpmem_attach(addr, sz_mem[SZ_INDEX], NULL);
-		CHKANDJUMP(attach == (void*)-1, 255, "xpmem_attach failed: %s\n", strerror(errno));
-		
-		*((unsigned long*)attach) = 0x1234;
-
-		ret = xpmem_detach(attach);
-		CHKANDJUMP(ret == -1, 255, "xpmem_detach failed\n");
-
-		_exit(123);
-	} else {
-		void *shm = shmat(shmid, NULL, 0);
-		CHKANDJUMP(mem == (void*)-1, 255, "shmat failed: %s\n", strerror(errno));
-
-		ret = xpmem_init();
-		CHKANDJUMP(ret != 0, 255, "xpmem_init failed: %s\n", strerror(errno));
-		
-		segid = xpmem_make(mem, sz_mem[SZ_INDEX], XPMEM_PERMIT_MODE, (void*)0666);
-		CHKANDJUMP(segid == -1, 255, "xpmem_ioctl failed: %s\n", strerror(errno));
-
-		*(xpmem_segid_t*)shm = segid;
-		
-		ret = waitpid(pid, &status, 0);
-		CHKANDJUMP(ret == -1, 255, "waitpid failed\n");
-
-		printf("%lx\n", *((unsigned long*)mem));
-
-		struct shmid_ds buf;
-		ret = shmctl(shmid, IPC_RMID, &buf);
-		CHKANDJUMP(ret == -1, 255, "shmctl failed\n");
-
-		ret = shmdt(shm);
-		CHKANDJUMP(ret == -1, 255, "shmdt failed\n");
-
-		ret = xpmem_remove(segid);
-		CHKANDJUMP(ret == -1, 255, "xpmem_remove failed\n");
-	}
-	
- fn_exit:
-	return ret;
- fn_fail:
-	goto fn_exit;
-}

test/rusage/rusage012.c

@@ -1,98 +0,0 @@
-#include <unistd.h>
-#include <stdio.h>
-#include <sys/mman.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <sys/wait.h>
-#include <sys/ipc.h>
-#include <sys/shm.h>
-#include <xpmem.h>
-
-#define DEBUG
-
-#ifdef DEBUG
-#define dprintf(...)                                            \
-    do {                                                        \
-	char msg[1024];                                         \
-	sprintf(msg, __VA_ARGS__);                              \
-	fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#define eprintf(...)                                            \
-    do {                                                        \
-	char msg[1024];                                         \
-	sprintf(msg, __VA_ARGS__);                              \
-	fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#else
-#define dprintf(...) do {  } while (0)
-#define eprintf(...) do {  } while (0)
-#endif
-
-#define CHKANDJUMP(cond, err, ...)                                      \
-    do {                                                                \
-		if(cond) {                                                      \
-			eprintf(__VA_ARGS__);                                       \
-			ret = err;                                                  \
-			goto fn_fail;                                               \
-		}                                                               \
-    } while(0)
-
-int sz_mem[] = {
-	4 * (1ULL<<10),
-	2 * (1ULL<<20),
-	1 * (1ULL<<30),
-	134217728};
-
-#define SZ_INDEX 0
-
-int main(int argc, char** argv) {
-	void* mem;
-	int ret = 0;
-	pid_t pid;
-	int status;
-	xpmem_segid_t segid;
-	
-	mem = mmap(0, sz_mem[SZ_INDEX], PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
-	CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
-	memset(mem, 0, sz_mem[SZ_INDEX]);
-	
-	ret = xpmem_init();
-	CHKANDJUMP(ret != 0, 255, "xpmem_init failed: %s\n", strerror(errno));
-
-	segid = xpmem_make(mem, sz_mem[SZ_INDEX], XPMEM_PERMIT_MODE, (void*)0666);
-	CHKANDJUMP(segid == -1, 255, "xpmem_ioctl failed: %s\n", strerror(errno));
-
-	pid = fork();
-	CHKANDJUMP(pid == -1, 255, "fork failed\n");
-	if(pid == 0) {
-		xpmem_apid_t apid = xpmem_get(segid, XPMEM_RDWR, XPMEM_PERMIT_MODE, NULL);
-		CHKANDJUMP(apid == -1, 255, "xpmem_get failed: %s\n", strerror(errno));
-
-		struct xpmem_addr addr = { .apid = apid, .offset = 0 };
-		void* attach = xpmem_attach(addr, sz_mem[SZ_INDEX], NULL);
-		CHKANDJUMP(attach == (void*)-1, 255, "xpmem_attach failed: %s\n", strerror(errno));
-		
-		*((unsigned long*)attach) = 0x1234;
-
-		ret = xpmem_detach(attach);
-		CHKANDJUMP(ret == -1, 255, "xpmem_detach failed\n");
-
-		_exit(123);
-	} else {
-		ret = waitpid(pid, &status, 0);
-		CHKANDJUMP(ret == -1, 255, "waitpid failed\n");
-
-		printf("%lx\n", *((unsigned long*)mem));
-
-		ret = xpmem_remove(segid);
-		CHKANDJUMP(ret == -1, 255, "xpmem_remove failed\n");
-	}
-	
- fn_exit:
-	return ret;
- fn_fail:
-	goto fn_exit;
-}

test/rusage/rusage013.c

@@ -1,72 +0,0 @@
-#include <unistd.h>
-#include <stdio.h>
-#include <sys/mman.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-
-#define DEBUG
-
-#ifdef DEBUG
-#define dprintf(...)                                            \
-    do {                                                        \
-	char msg[1024];                                         \
-	sprintf(msg, __VA_ARGS__);                              \
-	fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#define eprintf(...)                                            \
-    do {                                                        \
-	char msg[1024];                                         \
-	sprintf(msg, __VA_ARGS__);                              \
-	fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#else
-#define dprintf(...) do {  } while (0)
-#define eprintf(...) do {  } while (0)
-#endif
-
-#define CHKANDJUMP(cond, err, ...)                                      \
-    do {                                                                \
-		if(cond) {                                                      \
-			eprintf(__VA_ARGS__);                                       \
-			ret = err;                                                  \
-			goto fn_fail;                                               \
-		}                                                               \
-    } while(0)
-
-int sz_mem[] = {
-	4 * (1ULL<<10),
-	2 * (1ULL<<20),
-	1 * (1ULL<<30),
-	134217728};
-
-#define SZ_INDEX 0
-
-int main(int argc, char** argv) {
-	void* mem;
-	int ret = 0;
-	int fd;
-
-	fd = open("./file", O_RDWR);
-	CHKANDJUMP(fd == -1, 255, "open failed\n");
-
-	mem = mmap(0, sz_mem[SZ_INDEX], PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
-	CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
-
-	//unsigned long val = *((unsigned long*)mem);
-	//memset(mem, 0, sz_mem[SZ_INDEX]);
-
-	*((unsigned long*)mem) = 0x123456789abcdef0;
-//ret = msync(mem, sz_mem[SZ_INDEX], MS_SYNC);
-//	*((unsigned long*)mem) = 0x123456789abcdef0;
-
-	munmap(mem, sz_mem[SZ_INDEX]);
-	//ret = close(fd);
-	//CHKANDJUMP(ret != 0, 255, "close failed\n");
-	
- fn_exit:
-	return ret;
- fn_fail:
-	goto fn_exit;
-}

test/rusage/rusage014.c

@@ -1,71 +0,0 @@
-#include <unistd.h>
-#include <stdio.h>
-#include <sys/mman.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-
-#define DEBUG
-
-#ifdef DEBUG
-#define dprintf(...)                                            \
-    do {                                                        \
-	char msg[1024];                                         \
-	sprintf(msg, __VA_ARGS__);                              \
-	fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#define eprintf(...)                                            \
-    do {                                                        \
-	char msg[1024];                                         \
-	sprintf(msg, __VA_ARGS__);                              \
-	fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#else
-#define dprintf(...) do {  } while (0)
-#define eprintf(...) do {  } while (0)
-#endif
-
-#define CHKANDJUMP(cond, err, ...)                                      \
-    do {                                                                \
-		if(cond) {                                                      \
-			eprintf(__VA_ARGS__);                                       \
-			ret = err;                                                  \
-			goto fn_fail;                                               \
-		}                                                               \
-    } while(0)
-
-int sz_unit[] = {
-	4 * (1ULL<<10),
-	2 * (1ULL<<20),
-	1 * (1ULL<<30)};
-
-#define SZ_INDEX 0
-
-int main(int argc, char** argv) {
-	void* mem;
-	int ret = 0;
-	int fd;
-
-	fd = open("./file", O_RDWR);
-	CHKANDJUMP(fd == -1, 255, "open failed\n");
-
-	mem = mmap(0, 2 * sz_unit[SZ_INDEX], PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
-	CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
-
-	ret = remap_file_pages(mem + 0 * sz_unit[SZ_INDEX], sz_unit[SZ_INDEX], 0, 1, MAP_SHARED);
-	CHKANDJUMP(ret != 0, 255, "remap_file_pages failed\n");
-
-	ret = remap_file_pages(mem + 1 * sz_unit[SZ_INDEX], sz_unit[SZ_INDEX], 0, 0, MAP_SHARED);
-	CHKANDJUMP(ret != 0, 255, "remap_file_pages failed\n");
-
-	*((unsigned long*)mem) = 0x123456789abcdef0;
-	*(unsigned long*)((char*)mem + 1 * sz_unit[SZ_INDEX]) = 0x123456789abcdef0;
-
-	munmap(mem, 2 * sz_unit[SZ_INDEX]);
-	
- fn_exit:
-	return ret;
- fn_fail:
-	goto fn_exit;
-}

test/rusage/rusage015.c

@@ -1,74 +0,0 @@
-#include <unistd.h>
-#include <stdio.h>
-#include <sys/mman.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-
-#define DEBUG
-
-#ifdef DEBUG
-#define dprintf(...)                                            \
-    do {                                                        \
-	char msg[1024];                                         \
-	sprintf(msg, __VA_ARGS__);                              \
-	fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#define eprintf(...)                                            \
-    do {                                                        \
-	char msg[1024];                                         \
-	sprintf(msg, __VA_ARGS__);                              \
-	fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#else
-#define dprintf(...) do {  } while (0)
-#define eprintf(...) do {  } while (0)
-#endif
-
-#define CHKANDJUMP(cond, err, ...)                                      \
-    do {                                                                \
-		if(cond) {                                                      \
-			eprintf(__VA_ARGS__);                                       \
-			ret = err;                                                  \
-			goto fn_fail;                                               \
-		}                                                               \
-    } while(0)
-
-int sz_unit[] = {
-	4 * (1ULL<<10),
-	2 * (1ULL<<20),
-	1 * (1ULL<<30)};
-
-#define SZ_INDEX 0
-
-int main(int argc, char** argv) {
-	void* mem;
-	int ret = 0;
-	int fd;
-
-	fd = open("./file", O_RDWR);
-	CHKANDJUMP(fd == -1, 255, "open failed\n");
-
-	mem = mmap(0, 2 * sz_unit[SZ_INDEX], PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
-	CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
-
-	*((unsigned long*)mem) = 0x123456789abcdef0;
-	*(unsigned long*)((char*)mem + 1 * sz_unit[SZ_INDEX]) = 0xbeefbeefbeefbeef;
-
-	ret = remap_file_pages(mem + 0 * sz_unit[SZ_INDEX], sz_unit[SZ_INDEX], 0, 1, MAP_SHARED);
-	CHKANDJUMP(ret != 0, 255, "remap_file_pages failed\n");
-
-	ret = remap_file_pages(mem + 1 * sz_unit[SZ_INDEX], sz_unit[SZ_INDEX], 0, 0, MAP_SHARED);
-	CHKANDJUMP(ret != 0, 255, "remap_file_pages failed\n");
-
-	*((unsigned long*)mem) = 0x123456789abcdef0;
-	*(unsigned long*)((char*)mem + 1 * sz_unit[SZ_INDEX]) = 0xbeefbeefbeefbeef;
-
-	munmap(mem, 2 * sz_unit[SZ_INDEX]);
-	
- fn_exit:
-	return ret;
- fn_fail:
-	goto fn_exit;
-}

test/rusage/rusage016.c

@@ -1,67 +0,0 @@
-#define _GNU_SOURCE         /* See feature_test_macros(7) */
-
-#include <unistd.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/mman.h>
-#include <string.h>
-
-#define DEBUG
-
-#ifdef DEBUG
-#define dprintf(...)                                            \
-    do {                                                        \
-	char msg[1024];                                         \
-	sprintf(msg, __VA_ARGS__);                              \
-	fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#define eprintf(...)                                            \
-    do {                                                        \
-	char msg[1024];                                         \
-	sprintf(msg, __VA_ARGS__);                              \
-	fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#else
-#define dprintf(...) do {  } while (0)
-#define eprintf(...) do {  } while (0)
-#endif
-
-#define CHKANDJUMP(cond, err, ...)                                      \
-    do {                                                                \
-		if(cond) {                                                      \
-			eprintf(__VA_ARGS__);                                       \
-			ret = err;                                                  \
-			goto fn_fail;                                               \
-		}                                                               \
-    } while(0)
-
-int sz_anon[] = {
-	4 * (1ULL<<10),
-	2 * (1ULL<<20),
-	1 * (1ULL<<30),
-	134217728};
-
-#define SZ_INDEX 0
-#define NUM_AREAS 1
-
-int main(int argc, char** argv) {
-	int i;
-	void* mem;
-	void* newmem;
-	int ret = 0;
-
-	mem = mmap(0, sz_anon[SZ_INDEX], PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
-	CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
-	*((unsigned long*)mem) = 0x123456789abcdef0;
-
-	newmem = mremap(mem, sz_anon[SZ_INDEX], sz_anon[SZ_INDEX + 1], MREMAP_MAYMOVE);
-	CHKANDJUMP(newmem == MAP_FAILED, 255, "mmap failed\n");
-	*((unsigned long*)mem) = 0xbeefbeefbeefbeef;
-
-	munmap(newmem, sz_anon[SZ_INDEX + 1]);
-	
- fn_exit:
-	return ret;
- fn_fail:
-	goto fn_exit;
-}

test/rusage/rusage017.c

@@ -1,76 +0,0 @@
-#define _GNU_SOURCE         /* See feature_test_macros(7) */
-
-#include <unistd.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/mman.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-
-#define DEBUG
-
-#ifdef DEBUG
-#define dprintf(...)                                            \
-    do {                                                        \
-	char msg[1024];                                         \
-	sprintf(msg, __VA_ARGS__);                              \
-	fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#define eprintf(...)                                            \
-    do {                                                        \
-	char msg[1024];                                         \
-	sprintf(msg, __VA_ARGS__);                              \
-	fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#else
-#define dprintf(...) do {  } while (0)
-#define eprintf(...) do {  } while (0)
-#endif
-
-#define CHKANDJUMP(cond, err, ...)                                      \
-    do {                                                                \
-		if(cond) {                                                      \
-			eprintf(__VA_ARGS__);                                       \
-			ret = err;                                                  \
-			goto fn_fail;                                               \
-		}                                                               \
-    } while(0)
-
-int sz_mem[] = {
-	4 * (1ULL<<10),
-	2 * (1ULL<<20),
-	1 * (1ULL<<30),
-	134217728};
-
-#define SZ_INDEX 0
-#define NUM_AREAS 1
-
-int main(int argc, char** argv) {
-	int i;
-	void* mem;
-	void* newmem;
-	int ret = 0;
-	int fd;
-
-	fd = open("./file", O_RDWR);
-	CHKANDJUMP(fd == -1, 255, "open failed\n");
-
-	mem = mmap(0, 3 * sz_mem[SZ_INDEX], PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
-	CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
-
-	*(unsigned long*)((char*)mem + 0) = 0x123456789abcdef0;
-	*(unsigned long*)((char*)mem + sz_mem[SZ_INDEX]) = 0xbeefbeefbeefbeef;
-	*(unsigned long*)((char*)mem + 2 * sz_mem[SZ_INDEX]) = 0xbeefbeefbeefbeef;
-
-	ret = mprotect(mem + sz_mem[SZ_INDEX], sz_mem[SZ_INDEX], PROT_READ | PROT_EXEC);
-	CHKANDJUMP(ret != 0, 255, "mprotect failed\n");
-
-	munmap(mem, 3 * sz_mem[SZ_INDEX]);
-	
- fn_exit:
-	return ret;
- fn_fail:
-	goto fn_exit;
-}

test/rusage/rusage018.c

@@ -1,73 +0,0 @@
-#define _GNU_SOURCE         /* See feature_test_macros(7) */
-
-#include <unistd.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/mman.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-
-#define DEBUG
-
-#ifdef DEBUG
-#define dprintf(...)                                            \
-    do {                                                        \
-	char msg[1024];                                         \
-	sprintf(msg, __VA_ARGS__);                              \
-	fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#define eprintf(...)                                            \
-    do {                                                        \
-	char msg[1024];                                         \
-	sprintf(msg, __VA_ARGS__);                              \
-	fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#else
-#define dprintf(...) do {  } while (0)
-#define eprintf(...) do {  } while (0)
-#endif
-
-#define CHKANDJUMP(cond, err, ...)                                      \
-    do {                                                                \
-		if(cond) {                                                      \
-			eprintf(__VA_ARGS__);                                       \
-			ret = err;                                                  \
-			goto fn_fail;                                               \
-		}                                                               \
-    } while(0)
-
-int sz_mem[] = {
-	4 * (1ULL<<10),
-	2 * (1ULL<<20),
-	1 * (1ULL<<30),
-	134217728};
-
-#define SZ_INDEX 1
-#define NUM_AREAS 1
-
-int main(int argc, char** argv) {
-	int i;
-	void* mem;
-	void* newmem;
-	int ret = 0;
-	int fd;
-
-	mem = mmap(0, 3 * sz_mem[SZ_INDEX], PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
-	CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
-
-	*(unsigned long*)((char*)mem + 0) = 0x123456789abcdef0;
-	*(unsigned long*)((char*)mem + sz_mem[SZ_INDEX]) = 0xbeefbeefbeefbeef;
-	*(unsigned long*)((char*)mem + 2 * sz_mem[SZ_INDEX]) = 0xbeefbeefbeefbeef;
-
-	ret = mprotect(mem + sz_mem[SZ_INDEX - 1], sz_mem[SZ_INDEX - 1], PROT_READ | PROT_EXEC);
-	CHKANDJUMP(ret != 0, 255, "mprotect failed\n");
-
-	munmap(mem, 3 * sz_mem[SZ_INDEX]);
-	
- fn_exit:
-	return ret;
- fn_fail:
-	goto fn_exit;
-}

test/rusage/rusage020.c

@@ -1 +0,0 @@
-rusage000.c

test/rusage/rusage030.c

@@ -1 +0,0 @@
-rusage000.c

test/rusage/rusage100.c

@@ -1,81 +0,0 @@
-#include <stdio.h>
-#include <sys/mman.h>
-#include <unistd.h>
-#include <sys/syscall.h>   /* For SYS_xxx definitions */
-#include "ihklib.h"
-#include "mckernel/ihklib_rusage.h"
-
-#define DEBUG
-
-#ifdef DEBUG
-#define dprintf(...)                                            \
-    do {                                                        \
-		char msg[1024];                                         \
-		sprintf(msg, __VA_ARGS__);                              \
-		fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#else
-#define dprintf(...) do {  } while (0)
-#endif
-
-#define CHKANDJUMP(cond, err, ...)                                      \
-    do {                                                                \
-		if(cond) {                                                      \
-			dprintf(__VA_ARGS__);                                       \
-			ret = err;                                                  \
-			goto fn_fail;                                               \
-		}                                                               \
-    } while(0)
-
-int sz_anon[] = {
-	4 * (1ULL<<10),
-	2 * (1ULL<<20),
-	1 * (1ULL<<30),
-	134217728};
-
-#define SZ_INDEX 0
-#define NLOOP 2
-
-int main(int argc, char** argv) {
-	int i, j, ret = 0, ret_ihklib;
-	void* mem;
-	struct mckernel_rusage rusage;
-	
-	for (j = 0; j < NLOOP; j++) {
-		mem = mmap(0, sz_anon[SZ_INDEX], PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
-		CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
-		*((unsigned long*)mem) = 0x123456789abcdef0;
-
-		ret = syscall(900);
-		CHKANDJUMP(ret != 0, 255, "syscall failed\n");
-
-		ret  = ihk_os_getrusage(0, &rusage, sizeof(rusage));
-		CHKANDJUMP(ret != 0, 255, "ihk_os_getrusage failed\n");
-
-		for (i = 0; i < IHK_MAX_NUM_PGSIZES; i++) {
-			printf("memory_stat_rss[%d]=%ld\n", i, rusage.memory_stat_rss[i]);
-			printf("memory_stat_mapped_file[%d]=%ld\n", i, rusage.memory_stat_mapped_file[i]);
-		}
-		printf("memory_max_usage=%ld\n", rusage.memory_max_usage);
-		printf("memory_kmem_usage=%ld\n", rusage.memory_kmem_usage);
-		printf("memory_kmem_max_usage=%ld\n", rusage.memory_kmem_max_usage);
-#define NUM_NUMA_NODES 2
-		for (i = 0; i < NUM_NUMA_NODES; i++) {
-			printf("memory_numa_stat[%d]=%ld\n", i, rusage.memory_numa_stat[i]);
-		}
-#define NUM_CPUS 2
-		for (i = 0; i < NUM_CPUS; i++) {
-			printf("cpuacct_usage_percpu[%d]=%ld\n", i, rusage.cpuacct_usage_percpu[i]);
-		}
-		printf("cpuacct_stat_system=%ld\n", rusage.cpuacct_stat_system);
-		printf("cpuacct_stat_user=%ld\n", rusage.cpuacct_stat_user);
-		printf("cpuacct_usage=%ld\n", rusage.cpuacct_usage);
-
-		printf("num_threads=%d\n", rusage.num_threads);
-		printf("max_num_threads=%d\n", rusage.max_num_threads);
-	}
- fn_exit:
-	return ret;
- fn_fail:
-	goto fn_exit;
-}

test/rusage/rusage101.c

@@ -1,93 +0,0 @@
-#include <stdio.h>
-#include <sys/mman.h>
-#include <unistd.h>
-#include <sys/syscall.h>   /* For SYS_xxx definitions */
-#include "ihklib.h"
-#include "mckernel/ihklib_rusage.h"
-
-#define DEBUG
-
-#ifdef DEBUG
-#define dprintf(...)                                            \
-    do {                                                        \
-		char msg[1024];                                         \
-		sprintf(msg, __VA_ARGS__);                              \
-		fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#else
-#define dprintf(...) do {  } while (0)
-#endif
-
-#define CHKANDJUMP(cond, err, ...)                                      \
-    do {                                                                \
-		if(cond) {                                                      \
-			dprintf(__VA_ARGS__);                                       \
-			ret = err;                                                  \
-			goto fn_fail;                                               \
-		}                                                               \
-    } while(0)
-
-int sz_anon[] = {
-	4 * (1ULL<<10),
-	2 * (1ULL<<20),
-	1 * (1ULL<<30),
-	134217728};
-
-#define SZ_INDEX 0
-#define NLOOP 2
-
-int main(int argc, char** argv) {
-	int i, j, ret = 0, ret_ihklib;
-	void* mem;
-	struct mckernel_rusage rusage;
-	pid_t pid;
-	int status;
-	
-	pid = fork();
-	CHKANDJUMP(pid == -1, 255, "fork failed");
-	if (pid == 0) {
-		
-		for (j = 0; j < NLOOP; j++) {
-			mem = mmap(0, sz_anon[SZ_INDEX], PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
-			CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
-			*((unsigned long*)mem) = 0x123456789abcdef0;
-
-			ret = syscall(900);
-			CHKANDJUMP(ret != 0, 255, "syscall failed\n");
-
-			ret  = ihk_os_getrusage(0, &rusage, sizeof(rusage));
-			CHKANDJUMP(ret != 0, 255, "ihk_os_getrusage failed\n");
-
-			for (i = 0; i < IHK_MAX_NUM_PGSIZES; i++) {
-				printf("memory_stat_rss[%d]=%ld\n", i, rusage.memory_stat_rss[i]);
-				printf("memory_stat_mapped_file[%d]=%ld\n", i, rusage.memory_stat_mapped_file[i]);
-			}
-			printf("memory_max_usage=%ld\n", rusage.memory_max_usage);
-			printf("memory_kmem_usage=%ld\n", rusage.memory_kmem_usage);
-			printf("memory_kmem_max_usage=%ld\n", rusage.memory_kmem_max_usage);
-#define NUM_NUMA_NODES 2
-			for (i = 0; i < NUM_NUMA_NODES; i++) {
-				printf("memory_numa_stat[%d]=%ld\n", i, rusage.memory_numa_stat[i]);
-			}
-#define NUM_CPUS 2
-			for (i = 0; i < NUM_CPUS; i++) {
-				printf("cpuacct_usage_percpu[%d]=%ld\n", i, rusage.cpuacct_usage_percpu[i]);
-			}
-			printf("cpuacct_stat_system=%ld\n", rusage.cpuacct_stat_system);
-			printf("cpuacct_stat_user=%ld\n", rusage.cpuacct_stat_user);
-			printf("cpuacct_usage=%ld\n", rusage.cpuacct_usage);
-
-			printf("num_threads=%d\n", rusage.num_threads);
-			printf("max_num_threads=%d\n", rusage.max_num_threads);
-		}
-		_exit(123);
-	} else {
-		ret = waitpid(pid, &status, 0);
-		CHKANDJUMP(ret == -1, 255, "waitpid failed\n");
-	}
-
- fn_exit:
-	return ret;
- fn_fail:
-	goto fn_exit;
-}

test/rusage/rusage102.c

@@ -1,89 +0,0 @@
-#include <stdio.h>
-#include <sys/mman.h>
-#include <unistd.h>
-#include <sys/syscall.h>   /* For SYS_xxx definitions */
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include "ihklib.h"
-#include "mckernel/ihklib_rusage.h"
-
-#define DEBUG
-
-#ifdef DEBUG
-#define dprintf(...)                                            \
-    do {                                                        \
-		char msg[1024];                                         \
-		sprintf(msg, __VA_ARGS__);                              \
-		fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#else
-#define dprintf(...) do {  } while (0)
-#endif
-
-#define CHKANDJUMP(cond, err, ...)                                      \
-    do {                                                                \
-		if(cond) {                                                      \
-			dprintf(__VA_ARGS__);                                       \
-			ret = err;                                                  \
-			goto fn_fail;                                               \
-		}                                                               \
-    } while(0)
-
-int sz_mem[] = {
-	4 * (1ULL<<10),
-	2 * (1ULL<<20),
-	1 * (1ULL<<30),
-	134217728};
-
-#define SZ_INDEX 0
-#define NLOOP 2
-
-int main(int argc, char** argv) {
-	int i, j, ret = 0, ret_ihklib;
-	void* mem;
-	int fd;
-	struct mckernel_rusage rusage;
-	
-	fd = open("./file", O_RDWR);
-	CHKANDJUMP(fd == -1, 255, "open failed\n");
-
-	for (j = 0; j < NLOOP; j++) {
-		
-		mem = mmap(0, sz_mem[SZ_INDEX], PROT_READ|PROT_WRITE, MAP_SHARED, fd, sz_mem[SZ_INDEX] * j);
-		CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
-		*((unsigned long*)mem) = 0x123456789abcdef0;
-
-		ret = syscall(900);
-		CHKANDJUMP(ret != 0, 255, "syscall failed\n");
-
-		ret  = ihk_os_getrusage(0, &rusage, sizeof(rusage));
-		CHKANDJUMP(ret != 0, 255, "ihk_os_getrusage failed\n");
-
-		for (i = 0; i < IHK_MAX_NUM_PGSIZES; i++) {
-			printf("memory_stat_rss[%d]=%ld\n", i, rusage.memory_stat_rss[i]);
-			printf("memory_stat_mapped_file[%d]=%ld\n", i, rusage.memory_stat_mapped_file[i]);
-		}
-		printf("memory_max_usage=%ld\n", rusage.memory_max_usage);
-		printf("memory_kmem_usage=%ld\n", rusage.memory_kmem_usage);
-		printf("memory_kmem_max_usage=%ld\n", rusage.memory_kmem_max_usage);
-#define NUM_NUMA_NODES 2
-		for (i = 0; i < NUM_NUMA_NODES; i++) {
-			printf("memory_numa_stat[%d]=%ld\n", i, rusage.memory_numa_stat[i]);
-		}
-#define NUM_CPUS 2
-		for (i = 0; i < NUM_CPUS; i++) {
-			printf("cpuacct_usage_percpu[%d]=%ld\n", i, rusage.cpuacct_usage_percpu[i]);
-		}
-		printf("cpuacct_stat_system=%ld\n", rusage.cpuacct_stat_system);
-		printf("cpuacct_stat_user=%ld\n", rusage.cpuacct_stat_user);
-		printf("cpuacct_usage=%ld\n", rusage.cpuacct_usage);
-
-		printf("num_threads=%d\n", rusage.num_threads);
-		printf("max_num_threads=%d\n", rusage.max_num_threads);
-	}
- fn_exit:
-	return ret;
- fn_fail:
-	goto fn_exit;
-}

test/rusage/rusage103.c

@@ -1,81 +0,0 @@
-#include <stdio.h>
-#include <sys/mman.h>
-#include <unistd.h>
-#include <sys/syscall.h>   /* For SYS_xxx definitions */
-#include "ihklib.h"
-#include "mckernel/ihklib_rusage.h"
-
-#define DEBUG
-
-#ifdef DEBUG
-#define dprintf(...)                                            \
-    do {                                                        \
-		char msg[1024];                                         \
-		sprintf(msg, __VA_ARGS__);                              \
-		fprintf(stderr, "%s,%s", __FUNCTION__, msg);            \
-    } while (0);
-#else
-#define dprintf(...) do {  } while (0)
-#endif
-
-#define CHKANDJUMP(cond, err, ...)                                      \
-    do {                                                                \
-		if(cond) {                                                      \
-			dprintf(__VA_ARGS__);                                       \
-			ret = err;                                                  \
-			goto fn_fail;                                               \
-		}                                                               \
-    } while(0)
-
-int sz_anon[] = {
-	4 * (1ULL<<10),
-	2 * (1ULL<<20),
-	1 * (1ULL<<30),
-	134217728};
-
-#define SZ_INDEX 0
-#define NLOOP 2
-
-int main(int argc, char** argv) {
-	int i, j, ret = 0, ret_ihklib;
-	void* mem;
-	struct mckernel_rusage rusage;
-	
-	for (j = 0; j < NLOOP; j++) {
-		mem = mmap(0, sz_anon[SZ_INDEX], PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
-		CHKANDJUMP(mem == MAP_FAILED, 255, "mmap failed\n");
-		*((unsigned long*)mem) = 0x123456789abcdef0;
-
-		ret = syscall(900);
-		CHKANDJUMP(ret != 0, 255, "syscall failed\n");
-
-		ret  = ihk_os_getrusage(0, &rusage, sizeof(rusage));
-		CHKANDJUMP(ret != 0, 255, "ihk_os_getrusage failed\n");
-
-		for (i = 0; i < IHK_MAX_NUM_PGSIZES; i++) {
-			printf("memory_stat_rss[%d]=%ld\n", i, rusage.memory_stat_rss[i]);
-			printf("memory_stat_mapped_file[%d]=%ld\n", i, rusage.memory_stat_mapped_file[i]);
-		}
-		printf("memory_max_usage=%ld\n", rusage.memory_max_usage);
-		printf("memory_kmem_usage=%ld\n", rusage.memory_kmem_usage);
-		printf("memory_kmem_max_usage=%ld\n", rusage.memory_kmem_max_usage);
-#define NUM_NUMA_NODES 2
-		for (i = 0; i < NUM_NUMA_NODES; i++) {
-			printf("memory_numa_stat[%d]=%ld\n", i, rusage.memory_numa_stat[i]);
-		}
-#define NUM_CPUS 2
-		for (i = 0; i < NUM_CPUS; i++) {
-			printf("cpuacct_usage_percpu[%d]=%ld\n", i, rusage.cpuacct_usage_percpu[i]);
-		}
-		printf("cpuacct_stat_system=%ld\n", rusage.cpuacct_stat_system);
-		printf("cpuacct_stat_user=%ld\n", rusage.cpuacct_stat_user);
-		printf("cpuacct_usage=%ld\n", rusage.cpuacct_usage);
-
-		printf("num_threads=%d\n", rusage.num_threads);
-		printf("max_num_threads=%d\n", rusage.max_num_threads);
-	}
- fn_exit:
-	return ret;
- fn_fail:
-	goto fn_exit;
-}

test/rusage/util.h

@@ -7,7 +7,7 @@
 #define dprintf(...) do {			 \
 	char msg[1024];			 \
 	sprintf(msg, __VA_ARGS__);		 \
-	fprintf(stderr, "%s,%s", __func__, msg); \
+	fprintf(stderr, "%s: %s", __func__, msg); \
 } while (0)
 #else
 #define dprintf(...) do {  } while (0)
@@ -16,7 +16,7 @@
 #define eprintf(...) do {			 \
 	char msg[1024];			 \
 	sprintf(msg, __VA_ARGS__);		 \
-	fprintf(stderr, "%s,%s", __func__, msg); \
+	fprintf(stderr, "%s: ERROR: %s", __func__, msg); \
 } while (0)
 
 #define CHKANDJUMP(cond, err, ...) do { \
@@ -36,7 +36,7 @@
 		printf("[ NG ] ");			\
 		printf(__VA_ARGS__);			\
 		ret = -EINVAL;				\
-		goto out;				\
+		goto fn_fail;				\
 	}						\
 } while (0)