[QNX] mmap+cache/nocache+memcpy/asm

[QNX] mmap+cache/nocache+memcpy/asm_memcpy速度对比

mmap nocache介绍

以linux系统的nocache介绍：

在Linux系统中，使用mmap映射文件到内存时可以指定不使用缓存。这可以通过在调用mmap时将MAP_NOCACHE标志传递给mmap函数来实现。
MAP_NOCACHE标志告诉内核不要将映射的内存页缓存到文件系统缓存中，而是直接将内存与文件关联。这对于需要频繁读写大量数据的应用程序是有益的，因为它避免了在读写数据时额外的缓存开销。

例如：

#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
int main() {int fd = open("file.txt", O_RDWR);char *ptr = mmap(NULL, 100, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_NOCACHE, fd, 0);// use ptr to read and write data directly from/to the file...munmap(ptr, 100);close(fd);return 0;
}

qnx系统介绍：
https://www.qnx.com/developers/docs/7.1/#com.qnx.doc.neutrino.lib_ref/topic/p/posix_typed_mem_open.html

数据

memcpy cached speed: 2133.333333 MB/s （千兆级别）
memcpy nocached speed: 116.363636 MB/s （百兆级别）
invalidate memcpy cached speed: 1333.333333 MB/s （千兆级别）
invalidate memcpy nocached speed: 112.280702 MB/s （百兆级别）
asm memcpy cached speed: 2133.333333 MB/s （千兆级别）
asm memcpy nocached speed: 225.352113 MB/s （百兆级别）

名词

mmap cached指mmap使用PROT_READ | PROT_WRITE这个flag

mmap nocached是指mmap使用PROT_READ | PROT_WRITE | PROT_NOCACHE这个flag

memcpy是指单纯调用memcpy，如

for (size_t i = 0; i < count; i++) {memcpy(dst, src[i], bytes);
}

invalidate memcpy是指memcpy前先用msync设置共享内存属性，如

for (size_t i = 0; i < count; i++) {msync(src[i], bytes, MS_INVALIDATE);memcpy(dst, src[i], bytes);
}

asm memcpy是指汇编版本的memcpy，如

inline void aarch64_fast_memcpy(void *dst, const void *src, size_t size) {
#ifdef _QNX_void *ss = (void *)src, *dd = (void *)dst;size_t sz = size;asm volatile("loop_start: ""ldp q3, q4,[%0,#0x0]\n""ldp q5, q6,  [%0,#0x20]\n""ldp q7, q8,  [%0,#0x40]\n""ldp q9, q10, [%0,#0x60]\n""stp q3, q4,  [%1,#0x0]\n""stp q5, q6,  [%1,#0x20]\n""stp q7, q8, [%1,#0x40]\n""stp q9, q10, [%1,#0x60]\n""add %0, %0, #0x80\n""add %1, %1, #0x80\n""subs %2, %2, #0x80\n""b.ne loop_start\n""dsb sy\n": /* no output */: "r"(ss), "r"(dd), "r"(sz));
#endif
}
// ......   
for (size_t i = 0; i < count; i++) {aarch64_fast_memcpy(dst, src[i], bytes);
}

(完整代码见后面长源码文件)

结论

cached情况下：memcpy和asm memcpy差不多快（没有明显区别），invalidate memcpy最慢。

nocached情况下，asm memcpy最快，memcpy第二快，invalidate memcpy最慢。

测试源码

// mmap_memcpy.c
#include <errno.h>
#include <fcntl.h>
#include <memory.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>#ifndef _QNX_
#define PROT_NOCACHE 0
#endifinline void aarch64_fast_memcpy(void *dst, const void *src, size_t size) {
#ifdef _QNX_void *ss = (void *)src, *dd = (void *)dst;size_t sz = size;asm volatile("loop_start: ""ldp q3, q4,[%0,#0x0]\n""ldp q5, q6,  [%0,#0x20]\n""ldp q7, q8,  [%0,#0x40]\n""ldp q9, q10, [%0,#0x60]\n""stp q3, q4,  [%1,#0x0]\n""stp q5, q6,  [%1,#0x20]\n""stp q7, q8, [%1,#0x40]\n""stp q9, q10, [%1,#0x60]\n""add %0, %0, #0x80\n""add %1, %1, #0x80\n""subs %2, %2, #0x80\n""b.ne loop_start\n""dsb sy\n": /* no output */: "r"(ss), "r"(dd), "r"(sz));
#endif
}off_t offset(unsigned int bytes) {static off_t base_offset = 0x1E000000;off_t return_base_offset = base_offset;base_offset += bytes;return return_base_offset;
}void *mmap_memory(unsigned int bytes, int flag) {int fd = open("/dev/mem", O_RDWR | O_SYNC);if (fd < 0) {printf("open /dev/mem failed: %s\n", strerror(errno));}void *ptr = mmap(NULL, bytes, flag, MAP_SHARED, fd, offset(bytes));close(fd);if (MAP_FAILED == ptr) {printf("mmap failed: %s\n", strerror(errno));}return ptr;
}void *mmap_memory_cached(unsigned int bytes) {return mmap_memory(bytes, PROT_READ | PROT_WRITE);
}void *mmap_memory_nocached(unsigned int bytes) {return mmap_memory(bytes, PROT_READ | PROT_WRITE | PROT_NOCACHE);
}// if C++
#ifdef __cplusplus
#include <chrono>
using namespace std::chrono;
#define start() auto start_ = high_resolution_clock::now();
#define end()                                                                  \auto end_ = high_resolution_clock::now();                                  \double bytes_mb = bytes * count / 1024.0 / 1024.0;                         \double cost_ns = duration_cast<nanoseconds>(end_ - start_).count();        \double mps = bytes_mb / cost_ns * 1e9;#else
#include <time.h>
#include <unistd.h>
double time_diff_ns(struct timespec start, struct timespec end) {return (end.tv_sec - start.tv_sec) * 1e9 + (end.tv_nsec - start.tv_nsec);
}
#define start()                                                                \struct timespec start_, end_;                                              \clock_gettime(CLOCK_REALTIME, &start_);#define end()                                                                  \clock_gettime(CLOCK_REALTIME, &end_);                                      \double bytes_mb = bytes * count / 1024.0 / 1024.0;                         \double cost_ns = time_diff_ns(start_, end_);                               \double mps = bytes_mb / cost_ns * 1e9;#endifdouble memcpy_speed(void *dst, void **src, unsigned int bytes,unsigned int count) {start();for (size_t i = 0; i < count; i++) {memcpy(dst, src[i], bytes);}end();return mps;
}double invalidate_memcpy_speed(void *dst, void **src, unsigned int bytes,unsigned int count) {start();for (size_t i = 0; i < count; i++) {msync(src[i], bytes, MS_INVALIDATE);memcpy(dst, src[i], bytes);}end();return mps;
}double asm_memcpy_speed(void *dst, void **src, unsigned int bytes,unsigned int count) {start();for (size_t i = 0; i < count; i++) {aarch64_fast_memcpy(dst, src[i], bytes);}end();return mps;
}int main(int argc, char *argv[]) {const unsigned int count = 2;unsigned int bytes = 128 * 1024; // 128 KBif (argc > 1) {bytes = atoi(argv[1]) * 1024;}printf("bytes: %d\n", bytes);printf("count: %d\n", count);void *mmap_cached_src[count];void *mmap_nocached_src[count];for (size_t i = 0; i < count; i++) {mmap_cached_src[i] = mmap_memory_cached(bytes);mmap_nocached_src[i] = mmap_memory_nocached(bytes);}void *dst = malloc(bytes);printf("memcpy cached speed: %f MB/s\n",memcpy_speed(dst, mmap_cached_src, bytes, count));printf("memcpy nocached speed: %f MB/s\n",memcpy_speed(dst, mmap_nocached_src, bytes, count));printf("invalidate memcpy cached speed: %f MB/s\n",invalidate_memcpy_speed(dst, mmap_cached_src, bytes, count));printf("invalidate memcpy nocached speed: %f MB/s\n",invalidate_memcpy_speed(dst, mmap_nocached_src, bytes, count));printf("asm memcpy cached speed: %f MB/s dst[0]=%d\n",asm_memcpy_speed(dst, mmap_cached_src, bytes, count), ((char *)dst)[0]);printf("asm memcpy nocached speed: %f MB/s\n",asm_memcpy_speed(dst, mmap_nocached_src, bytes, count));free(dst);for (size_t i = 0; i < count; i++) {munmap(mmap_cached_src[i], bytes);munmap(mmap_nocached_src[i], bytes);}return 0;
}