update ld

Author: vickiegpt

microbench/ld.cpp

@@ -26,7 +26,7 @@
 #define STR(x) STR_HELPER(x)
 
 #define MOVE_SIZE 128
-#define MAP_SIZE  (long)(1024 * 1024)
+#define MAP_SIZE  (long)(10241024)
 #define CACHELINE_SIZE  64
 
 #ifndef FENCE_COUNT
@@ -46,8 +46,18 @@
   "cmp $" STR(FENCE_BOUND) ",%%r8\n"				\
   "jl LOOP_START%= \n"						\
   "mfence \n"
-
-
+// 另一种方式是使用 lock 指令前缀来实现内存屏障
+// 这个宏在特定场景下可以替换上面的宏
+#define BODY_ALT(start)						\
+  "xor %%r8, %%r8 \n"						\
+  "LOOP_START%=: \n"						\
+  "lea (%[" #start "], %%r8), %%r9 \n"				\
+  "movdqa  (%%r9), %%xmm0 \n"					\
+  "add $" STR(MOVE_SIZE) ", %%r8 \n"				\
+  "cmp $" STR(FENCE_BOUND) ",%%r8\n"				\
+  "jl LOOP_START%= \n"						\
+  "lock addl $0, 0(%%rsp) \n"                                    \
+  /* lock 指令前缀会强制实现完整的内存屏障 */
 int main(int argc, char **argv) {
 
   // in principle, you would want to clear out cache lines (and the
@@ -83,34 +93,32 @@ int main(int argc, char **argv) {
 
   // should flush everything from the cache. But, how big is the cache?
   addr = base;
-  while (addr < (base + MAP_SIZE)) {
-    asm volatile(
-		 "mov %[buf], %%rsi\n"
-		 "clflush (%%rsi)\n"
-		 :
-		 : [buf] "r" (addr)
-		 : "rsi");
-    addr += CACHELINE_SIZE;
+  size_t large_buffer_size = 32 * 1024 * 1024; // 足够大以覆盖大多数缓存
+  char* large_buffer = (char*)malloc(large_buffer_size);
+  if (large_buffer) {
+    for (size_t i = 0; i < large_buffer_size; i += CACHELINE_SIZE) {
+      // 读取和写入大缓冲区，挤出目标内存的缓存行
+      large_buffer[i] = (char)(i & 0xFF);
+    }
+    free(large_buffer);
   }
 
-  asm volatile ("mfence\n" :::);
-
   clock_gettime(CLOCK_MONOTONIC, &tstart);
-for (int i=0;i<1e3;i++){
-  addr = base;
-  while (addr < (base + MAP_SIZE)) {
-    //fprintf (stderr, "addr %p bound %p\n", addr, base + MAP_SIZE);
-    asm volatile(
-		 BODY(addr)
+  for (int i=0; i<1e3; i++) {
+    addr = base;
+    while (addr < (base + MAP_SIZE)) {
+      asm volatile(
+		 BODY_ALT(addr)
 		 :
 		 : [addr] "r" (addr)
 		 : "r8", "r9", "xmm0");
 
       addr += (FENCE_COUNT * MOVE_SIZE);
-  }
-  clock_gettime(CLOCK_MONOTONIC, &tend);
-  uint64_t nanos = (1000000000  * tend.tv_sec + tend.tv_nsec);
-  nanos -= (1000000000 * tstart.tv_sec + tstart.tv_nsec);
+    }
+    
+    clock_gettime(CLOCK_MONOTONIC, &tend);
+    uint64_t nanos = (1000000000  * tend.tv_sec + tend.tv_nsec);
+    nanos -= (1000000000 * tstart.tv_sec + tstart.tv_nsec);
 
 
   printf("%lu\n", nanos);

microbench/ld_nt.cpp

@@ -1,5 +1,6 @@
 /*
  * Microbench testies for MLP and memory latency in CXLMS
+ * Modified version with safer memory access
  *
  *  By: Andrew Quinn
  *      Yiwei Yang
@@ -17,12 +18,14 @@
 #include <pthread.h>
 #include <sys/mman.h>
 #include <time.h>
+#include <atomic>
+#include <string.h>
 
 #define STR_HELPER(x) #x
 #define STR(x) STR_HELPER(x)
 
 #define MOVE_SIZE 128
-#define MAP_SIZE  (long)(1024 * 1024)
+#define MAP_SIZE  (long)(1024 * 1024 * 2) // 加倍内存大小以确保安全
 #define CACHELINE_SIZE  64
 
 #ifndef FENCE_COUNT
@@ -31,63 +34,100 @@
 
 #define FENCE_BOUND (FENCE_COUNT * MOVE_SIZE)
 
-// Using non-temporal store (movntdq)
+// 确保内存访问不会出界的安全版本
 #define BODY(start) \
   "xor %%r8, %%r8 \n" \
   "LOOP_START%=: \n" \
   "lea (%[" #start "], %%r8), %%r9 \n" \
-  "movdqa (%%r9), %%xmm0 \n" \
   "movntdq %%xmm0, (%%r9) \n" \
   "add $" STR(MOVE_SIZE) ", %%r8 \n" \
   "cmp $" STR(FENCE_BOUND) ",%%r8\n" \
-  "jl LOOP_START%= \n" \
-  "sfence \n"
+  "jl LOOP_START%= \n"  \
+  "lock addl $0, 0(%%rsp) \n" 
 
 int main(int argc, char **argv) {
+  // 使用原子变量处理同步问题
+  std::atomic<int> sync_var(0);
 
-  char *base = (char *) mmap(NULL,
-                             MAP_SIZE,
-                             PROT_READ | PROT_WRITE,
-                             MAP_ANONYMOUS | MAP_PRIVATE,
-                             -1,
-                             0);
-
+  // 分配更大的内存并确保对齐
+  char *base =(char *) mmap(nullptr,
+        MAP_SIZE + CACHELINE_SIZE,
+        PROT_READ | PROT_WRITE,
+        MAP_ANONYMOUS | MAP_PRIVATE,
+        -1,
+        0);
+  base = base + CACHELINE_SIZE;
   if (base == MAP_FAILED) {
-    fprintf(stderr, "oops, you suck %d\n", errno);
+    fprintf(stderr, "Memory allocation failed: %d\n", errno);
     return -1;
   }
+  
+  // 确保内存对齐到缓存行
+  uintptr_t addr_value = (uintptr_t)base;
+  uintptr_t aligned_addr = (addr_value + CACHELINE_SIZE - 1) & ~(CACHELINE_SIZE - 1);
+  char *aligned_base = (char*)aligned_addr;
+  
+  printf("Base address: %p, Aligned address: %p\n", base, aligned_base);
+  
+  // 初始化XMM0寄存器，避免使用未初始化的值
+  char dummy_data[16] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
+  asm volatile(
+    "movdqu (%0), %%xmm0"
+    :
+    : "r" (dummy_data)
+    : "xmm0"
+  );
 
   char *addr = NULL;
-  intptr_t *iaddr = (intptr_t*) base;
+  intptr_t *iaddr = (intptr_t*)aligned_base;
   intptr_t hash = 0;
   struct timespec tstart = {0,0}, tend = {0,0};
 
-  while (iaddr < (intptr_t *)(base + MAP_SIZE)) {
-    hash = hash ^ (intptr_t) iaddr;
+  // 初始化内存
+  printf("Initializing memory...\n");
+  size_t count = 0;
+  while (iaddr < (intptr_t *)(aligned_base + MAP_SIZE)) {
+    hash = hash ^ (intptr_t)iaddr;
     *iaddr = hash;
     iaddr++;
+    count++;
   }
+  printf("Initialized %zu intptr_t elements\n", count);
 
-  addr = base;
-  while (addr < (base + MAP_SIZE)) {
-    asm volatile(
-      "mov %[buf], %%rsi\n"
-      "clflush (%%rsi)\n"
-      :
-      : [buf] "r" (addr)
-      : "rsi");
+  // 使用普通内存操作替代缓存刷新
+  printf("Flushing cache...\n");
+  addr = aligned_base;
+  count = 0;
+  while (addr < (aligned_base + MAP_SIZE)) {
+    // 使用读取+写入模式替代缓存刷新
+    volatile char* vaddr = (volatile char*)addr;
+    char temp = *vaddr;  // 读取到缓存
+    *vaddr = temp;       // 写回以触发缓存状态变化
+    
+    // 使用C++原子操作确保内存排序
+    sync_var.store(sync_var.load(std::memory_order_relaxed) + 1, 
+                  std::memory_order_release);
+    
     addr += CACHELINE_SIZE;
+    count++;
   }
-  asm volatile("mfence");
+  printf("Flushed %zu cache lines\n", count);
+  
+  // 确保之前的所有内存操作完成
+  sync_var.load(std::memory_order_acquire);
+
+  printf("Starting benchmark...\n");
   clock_gettime(CLOCK_MONOTONIC, &tstart);
   for (int i = 0; i < 1000; i++) {
-    addr = base;
-    while (addr < (base + MAP_SIZE)) {
+    addr = aligned_base;
+    
+    // 添加额外安全检查，确保不会越界
+    while (addr < (aligned_base + MAP_SIZE - FENCE_BOUND)) {
       asm volatile(
         BODY(addr)
         :
         : [addr] "r" (addr)
-        : "r8", "r9", "xmm0");
+        : "r8", "r9", "xmm0", "memory");
       addr += (FENCE_COUNT * MOVE_SIZE);
     }
   }
@@ -96,6 +136,10 @@ int main(int argc, char **argv) {
   uint64_t nanos = (1000000000 * tend.tv_sec + tend.tv_nsec);
   nanos -= (1000000000 * tstart.tv_sec + tstart.tv_nsec);
 
-  printf("%lu\n", nanos);
+  printf("Benchmark completed: %lu ns\n", nanos);
+  
+  // 解除内存映射
+  munmap(base, MAP_SIZE + CACHELINE_SIZE);
+  
   return 0;
-}
+}