Add itlb_size test

Author: jiegec

meson.build

@@ -71,6 +71,7 @@ progs = [
 	['elimination', false, true, true],
 	['find_branch_misses_pmu', false, false, true],
 	['ghr_size', false, true, true],
+	['itlb_size', false, true, true],
 	['phr_branch_bits_location', true, false, true],
 	['phr_size', false, true, true],
 	['phr_target_bits_location', true, false, true],

src/itlb_size.cpp

@@ -0,0 +1,37 @@
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+extern void itlb_size(FILE *fp);
+extern bool avoid_hugepage_merging;
+extern int stride;
+extern int fake_page_size;
+int main(int argc, char *argv[]) {
+  int opt;
+  while ((opt = getopt(argc, argv, "hs:f:")) != -1) {
+    switch (opt) {
+    case 'h':
+      avoid_hugepage_merging = true;
+      break;
+    case 's':
+      sscanf(optarg, "%d", &stride);
+      break;
+    case 'f':
+      sscanf(optarg, "%d", &fake_page_size);
+      break;
+    default:
+      fprintf(stderr, "Usage: %s [-h] [-s stride] [-f page_size]\n", argv[0]);
+      fprintf(stderr, "\t-h: avoid huge page merging\n");
+      fprintf(stderr, "\t-s stride: set branch address stride\n");
+      fprintf(stderr, "\t-f page_size: fake page size\n");
+      exit(EXIT_FAILURE);
+    }
+  }
+
+  FILE *fp = fopen("itlb_size.csv", "w");
+  assert(fp);
+  itlb_size(fp);
+  printf("Results are written to itlb_size.csv\n");
+  return 0;
+}

src/itlb_size_gen.cpp

@@ -0,0 +1,8 @@
+#include <cstdio>
+
+int main(int argc, char *argv[]) {
+  FILE *fp = fopen(argv[1], "w");
+  // jit only
+  fclose(fp);
+  return 0;
+}

src/itlb_size_lib.cpp

@@ -0,0 +1,169 @@
+#include "include/jit.h"
+#include "include/utils.h"
+#include <assert.h>
+#include <cstdint>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <vector>
+
+// args: loop count
+typedef void (*gadget)(size_t);
+
+bool avoid_hugepage_merging = false;
+int stride = 64;
+int fake_page_size = -1;
+
+void itlb_size(FILE *fp) {
+  int loop_count = 1000;
+  uint64_t min_size = 1;
+  uint64_t max_size = 4096;
+  bind_to_core();
+  setup_perf_cycles();
+
+  size_t page_size = getpagesize();
+  if (fake_page_size != -1) {
+    page_size = fake_page_size;
+  }
+  printf("Page Size: %ld\n", page_size);
+
+  if (avoid_hugepage_merging) {
+    printf("Avoiding hugepage merging\n");
+    printf("Please disable THP via: echo never "
+           ">/sys/kernel/mm/transparent_hugepage/enabled\n");
+  }
+  printf("Branch stride: %dB\n", stride);
+
+  fprintf(fp, "size,min,avg,max\n");
+  for (uint64_t size = min_size; size <= max_size; size++) {
+    gadget entry = NULL;
+    jit *jit_main = NULL;
+    std::vector<jit *> jit_pages;
+    if (avoid_hugepage_merging) {
+      // create each page separately
+      // generate addresses
+      std::vector<size_t> page_addrs;
+      std::vector<size_t> addrs;
+      size_t start_addr = 0x100000000;
+      addrs.push_back(start_addr);
+      page_addrs.push_back(start_addr);
+      for (uint64_t i = 1; i < size; i++) {
+        size_t addr = page_addrs[page_addrs.size() - 1];
+        addr += page_size;
+        // span over multiple cachelines to avoid hitting icache capacity
+        page_addrs.push_back(addr);
+        addrs.push_back(addr + (i * stride) % page_size);
+      }
+      uint8_t *start = (uint8_t *)start_addr;
+      for (uint64_t i = 0; i < size; i++) {
+        jit *jit_page = new jit((void *)page_addrs[i], page_size);
+
+        uint8_t *begin = (uint8_t *)addrs[i];
+        uint8_t *target = (uint8_t *)addrs[(i + 1) % addrs.size()];
+        jit_page->set_cur(begin);
+        if (i < size - 1) {
+#if defined(HOST_AARCH64)
+          jit_page->b(target);
+#elif defined(HOST_AMD64)
+          jit_page->jmp5(target);
+#endif
+        } else {
+#if defined(HOST_AARCH64)
+          // subs x0, x0, #1
+          jit_page->subs64(0, 0, 1);
+          uint8_t *end = jit_page->get_cur() + 8;
+          // cbnz has limited imm range
+          jit_page->cbz32(0, end);
+          jit_page->b(start);
+          // end:
+          jit_page->ret();
+#elif defined(HOST_AMD64)
+          jit_page->dec_r32(jit::DI);
+          jit_page->jnz6(start);
+          jit_page->ret();
+#endif
+        }
+        jit_page->protect();
+        jit_pages.push_back(jit_page);
+      }
+      entry = (gadget)start;
+    } else {
+      size_t mapped_size = page_size * size;
+      mapped_size = (mapped_size + 0x10000) & -0x10000;
+      uint8_t *start = (uint8_t *)0x100000000;
+      jit_main = new jit(start, mapped_size);
+      for (uint64_t i = 0; i < size; i++) {
+        // span over multiple cachelines to avoid hitting icache capacity
+        uint8_t *begin = start + i * page_size + (i * stride) % page_size;
+        uint8_t *target =
+            start + (i + 1) * page_size + ((i + 1) * stride) % page_size;
+        jit_main->set_cur(begin);
+        if (i < size - 1) {
+#if defined(HOST_AARCH64)
+          jit_main->b(target);
+#elif defined(HOST_AMD64)
+          jit_main->jmp5(target);
+#endif
+        } else {
+#if defined(HOST_AARCH64)
+          // subs x0, x0, #1
+          jit_main->subs64(0, 0, 1);
+          uint8_t *end = jit_main->get_cur() + 8;
+          // cbnz has limited imm range
+          jit_main->cbz32(0, end);
+          jit_main->b(start);
+          // end:
+          jit_main->ret();
+#elif defined(HOST_AMD64)
+          jit_main->dec_r32(jit::DI);
+          jit_main->jnz6(start);
+          jit_main->ret();
+#endif
+        }
+      }
+      jit_main->protect();
+      // jit_main->dump();
+      entry = (gadget)start;
+    }
+
+    std::vector<double> history;
+    int iterations = 30;
+    history.reserve(iterations);
+
+    double sum = 0;
+    // run several times
+    for (int i = 0; i < iterations; i++) {
+      uint64_t begin = perf_read_cycles();
+      entry(loop_count);
+      uint64_t elapsed = perf_read_cycles() - begin;
+
+      // skip warmup
+      if (i >= 10) {
+        double time = (double)elapsed / loop_count / size;
+        history.push_back(time);
+        sum += time;
+      }
+    }
+
+    if (jit_main) {
+      delete jit_main;
+    }
+    for (jit *page : jit_pages) {
+      delete page;
+    }
+
+    double min = history[0];
+    double max = history[0];
+    for (size_t i = 0; i < history.size(); i++) {
+      if (min > history[i]) {
+        min = history[i];
+      }
+      if (max < history[i]) {
+        max = history[i];
+      }
+    }
+    fprintf(fp, "%ld,%.2lf,%.2lf,%.2lf\n", size, min, sum / history.size(),
+            max);
+    fflush(fp);
+  }
+}