移动内存页面比mremap（）更快的方法？

我一直在试验mremap（）。 我希望能够高速移动虚拟内存页面。 至less比复制速度快。 我有一些可以利用能够快速移动内存页面的algorithm。 问题是，下面的程序显示，mremap（）是非常慢的 – 至less在我的i7笔记本电脑 – 相比之下，实际上是逐字节地拷贝相同的内存页面。

testing源代码如何工作？ mmap（）256 MB的内存比CPU上的高速caching大。 迭代20万次。 在每次迭代中，使用特定的交换方法交换两个随机内存页面。 运行一次，使用基于mremap（）的页面交换方法。 再次使用逐字节复制交换方式运行时间。 事实certificate，mremap（）仅pipe理每秒71,577次页面交换，而逐字节复制pipe理每秒高达287,879次页面交换。 所以mremap（）比字节复制慢4倍！

问题：

为什么mremap（）这么慢？

• 如何解释/ proc / mounts？
• Java程序运行一段时间后变慢了
• 在Linux程序中跟踪积极使用的内存
• Linux中的select性核心转储 – 如何select转储的部分？
• 在Docker容器中运行的JVM的驻留集大小（RSS）和Java总承诺内存（NMT）之间的差异

是否有另一个用户的土地或内核可调用页面映射操作API可能会更快？

是否有另一个用户地址或内核地址可调用页面映射操作API，允许在一次调用中重新映射多个非连续页面？

有没有支持这种事情的内核扩展？

#include <stdio.h> #include <string.h> #define __USE_GNU #include <unistd.h> #include <sys/mman.h> #include <sys/types.h> #include <sys/errno.h> #include <asm/ldt.h> #include <asm/unistd.h> // gcc mremap.c && perl -MTime::HiRes -e '$t1=Time::HiRes::time;system(q[TEST_MREMAP=1 ./a.out]);$t2=Time::HiRes::time;printf qq[%u per second\n],(1/($t2-$t1))*200_000;' // page size = 4096 // allocating 256 MB // before 0x7f8e060bd000=0 // before 0x7f8e060be000=1 // before 0x7f8e160bd000 // after 0x7f8e060bd000=41 // after 0x7f8e060be000=228 // 71577 per second // gcc mremap.c && perl -MTime::HiRes -e '$t1=Time::HiRes::time;system(q[TEST_COPY=1 ./a.out]);$t2=Time::HiRes::time;printf qq[%u per second\n],(1/($t2-$t1))*200_000;' // page size = 4096 // allocating 256 MB // before 0x7f1a9efa5000=0 // before 0x7f1a9efa6000=1 // before 0x7f1aaefa5000 // sizeof(i)=8 // after 0x7f1a9efa5000=41 // after 0x7f1a9efa6000=228 // 287879 per second // gcc mremap.c && perl -MTime::HiRes -e '$t1=Time::HiRes::time;system(q[TEST_MEMCPY=1 ./a.out]);$t2=Time::HiRes::time;printf qq[%u per second\n],(1/($t2-$t1))*200_000;' // page size = 4096 // allocating 256 MB // before 0x7faf7c979000=0 // before 0x7faf7c97a000=1 // before 0x7faf8c979000 // sizeof(i)=8 // after 0x7faf7c979000=41 // after 0x7faf7c97a000=228 // 441911 per second /* * Algorithm: * - Allocate 256 MB of memory * - loop 200,000 times * - swap a random 4k block for a random 4k block * Run the test twice; once for swapping using page table, once for swapping using CPU copying! */ #define PAGES (1024*64) int main() { int PAGE_SIZE = getpagesize(); char* m = NULL; unsigned char* p[PAGES]; void* t; printf("page size = %d\n", PAGE_SIZE); printf("allocating %u MB\n", PAGE_SIZE*PAGES / 1024 / 1024); m = (char*)mmap(0, PAGE_SIZE*(1+PAGES), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0); t = &m[PAGES*PAGE_SIZE]; { unsigned long i; for (i=0; i<PAGES; i++) { p[i] = &m[i*PAGE_SIZE]; memset(p[i], i & 255, PAGE_SIZE); } } printf("before %p=%u\n", p[0], p[0][0]); printf("before %p=%u\n", p[1], p[1][0]); printf("before %p\n", t); if (getenv("TEST_MREMAP")) { unsigned i; for (i=0; i<200001; i++) { unsigned p1 = random() % PAGES; unsigned p2 = random() % PAGES; // mremap(void *old_address, size_t old_size, size_t new_size,int flags, /* void *new_address */); mremap(p[p2], PAGE_SIZE, PAGE_SIZE, MREMAP_FIXED | MREMAP_MAYMOVE, t ); mremap(p[p1], PAGE_SIZE, PAGE_SIZE, MREMAP_FIXED | MREMAP_MAYMOVE, p[p2]); mremap(t , PAGE_SIZE, PAGE_SIZE, MREMAP_FIXED | MREMAP_MAYMOVE, p[p1]); // p3 no longer exists after this! } /* for() */ } else if (getenv("TEST_MEMCPY")) { unsigned long * pu[PAGES]; unsigned long i; for (i=0; i<PAGES; i++) { pu[i] = (unsigned long *)p[i]; } printf("sizeof(i)=%lu\n", sizeof(i)); for (i=0; i<200001; i++) { unsigned p1 = random() % PAGES; unsigned p2 = random() % PAGES; unsigned long * pa = pu[p1]; unsigned long * pb = pu[p2]; unsigned char t[PAGE_SIZE]; //memcpy(void *dest, const void *src, size_t n); memcpy(t , pb, PAGE_SIZE); memcpy(pb, pa, PAGE_SIZE); memcpy(pa, t , PAGE_SIZE); } /* for() */ } else if (getenv("TEST_MODIFY_LDT")) { unsigned long * pu[PAGES]; unsigned long i; for (i=0; i<PAGES; i++) { pu[i] = (unsigned long *)p[i]; } printf("sizeof(i)=%lu\n", sizeof(i)); // int modify_ldt(int func, void *ptr, unsigned long bytecount); // // modify_ldt(int func, void *ptr, unsigned long bytecount); // modify_ldt() reads or writes the local descriptor table (ldt) for a process. The ldt is a per-process memory management table used by the i386 processor. For more information on this table, see an Intel 386 processor handbook. // // When func is 0, modify_ldt() reads the ldt into the memory pointed to by ptr. The number of bytes read is the smaller of bytecount and the actual size of the ldt. // // When func is 1, modify_ldt() modifies one ldt entry. ptr points to a user_desc structure and bytecount must equal the size of this structure. // // The user_desc structure is defined in <asm/ldt.h> as: // // struct user_desc { // unsigned int entry_number; // unsigned long base_addr; // unsigned int limit; // unsigned int seg_32bit:1; // unsigned int contents:2; // unsigned int read_exec_only:1; // unsigned int limit_in_pages:1; // unsigned int seg_not_present:1; // unsigned int useable:1; // }; // // On success, modify_ldt() returns either the actual number of bytes read (for reading) or 0 (for writing). On failure, modify_ldt() returns -1 and sets errno to indicate the error. unsigned char ptr[20000]; int result; result = modify_ldt(0, &ptr[0], sizeof(ptr)); printf("result=%d, errno=%u\n", result, errno); result = syscall(__NR_modify_ldt, 0, &ptr[0], sizeof(ptr)); printf("result=%d, errno=%u\n", result, errno); // todo: how to get these calls returning a non-zero value? } else { unsigned long * pu[PAGES]; unsigned long i; for (i=0; i<PAGES; i++) { pu[i] = (unsigned long *)p[i]; } printf("sizeof(i)=%lu\n", sizeof(i)); for (i=0; i<200001; i++) { unsigned long j; unsigned p1 = random() % PAGES; unsigned p2 = random() % PAGES; unsigned long * pa = pu[p1]; unsigned long * pb = pu[p2]; unsigned long t; for (j=0; j<(4096/8/8); j++) { t = *pa; *pa ++ = *pb; *pb ++ = t; t = *pa; *pa ++ = *pb; *pb ++ = t; t = *pa; *pa ++ = *pb; *pb ++ = t; t = *pa; *pa ++ = *pb; *pb ++ = t; t = *pa; *pa ++ = *pb; *pb ++ = t; t = *pa; *pa ++ = *pb; *pb ++ = t; t = *pa; *pa ++ = *pb; *pb ++ = t; t = *pa; *pa ++ = *pb; *pb ++ = t; } } /* for() */ } printf("after %p=%u\n", p[0], p[0][0]); printf("after %p=%u\n", p[1], p[1][0]); return 0; } 

更新：所以我们不需要质疑“kernelspace”往返速度有多快，下面是一个更进一步的性能testing程序，它显示我们可以连续调用3次getpid（），每秒处理81916192次i7笔记本电脑：

 #include <stdio.h> #include <sys/types.h> #include <unistd.h> // gcc getpid.c && perl -MTime::HiRes -e '$t1=Time::HiRes::time;system(q[TEST_COPY=1 ./a.out]);$t2=Time::HiRes::time;printf qq[%u per second\n],(1/($t2-$t1))*100_000_000;' // running_total=8545800085458 // 81916192 per second /* * Algorithm: * - Call getpid() 100 million times. */ int main() { unsigned i; unsigned long running_total = 0; for (i=0; i<100000001; i++) { /* 123123123 */ running_total += getpid(); running_total += getpid(); running_total += getpid(); } /* for() */ printf("running_total=%lu\n", running_total); } 

更新2：我添加了WIP代码来调用我发现的名为modify_ldt（）的函数。 手册页暗示页面操作可能是可能的。 但是，无论我尝试什么，那么函数总是返回零，当我期待它返回读取的字节数。 'man modify_ldt'表示“成功时，modify_ldt（）返回实际读取的字节数（读取）或0（写入）。失败时，modify_ldt（）返回-1并设置errno来指示错误。 任何想法（a）modify_ldt（）是否会替代mremap（）？ 和（b）如何获得modify_ldt（）的工作？