feat: eval heap ready

Author: yimingx

test/evaluation/km/Makefile

@@ -12,12 +12,15 @@ init_ll.o: llbench_bpf.c
 lookup_ll.o: llbench_lookup_bpf.c
 	clang -O2 -I/usr/include/$(shell uname -m)-linux-gnu -target bpf -g -c $< -o lookup_ll.o
 
+delete_ll.o: llbench_delete_bpf.c
+	clang -O2 -I/usr/include/$(shell uname -m)-linux-gnu -target bpf -g -c $< -o delete_ll.o
+
 cleanobj:
-	rm -f init_ll.o lookup_ll.o
+	rm -f init_ll.o lookup_ll.o delete_ll.o
 	sudo rm -f /sys/fs/bpf/llbench
 
-autoattach: cleanobj init_ll.o lookup_ll.o
-	sudo bpftool prog load init_ll.o /sys/fs/bpf/llbench autoattach
+autoattach: cleanobj init_ll.o lookup_ll.o delete_ll.o
+	sudo bpftool prog load lookup_ll.o /sys/fs/bpf/llbench autoattach
 
 clean:
 	$(MAKE) -C $(KDIR) M=$(PWD) clean

test/evaluation/km/llbench.c

@@ -4,7 +4,7 @@
 #include <linux/random.h>
 #include <linux/ktime.h>
 
-#define LIST_SIZE  (10000)
+#define LIST_SIZE  (64 * 1000)
 
 struct ll_node {
     u32 key;
@@ -31,8 +31,8 @@ static struct ll_node *ll_lookup(u32 key)
 {
     struct ll_node *cur = head;
     while (cur) {
-        if (cur->key == key)
-            return cur;
+        // if (cur->key == key)
+        //     return cur;
         cur = cur->next;
     }
     return NULL;
@@ -89,11 +89,11 @@ static void benchmark(void)
 
     /* lookup test: 1K random accesses */
     t_start = now_ns();
-    // for (i = 0; i < LIST_SIZE; i++) {
-    ll_lookup(11111);
-    // }
+    for (i = 0; i < 100; i++) {
+        ll_lookup(11111);
+    }
     t_end = now_ns();
-    latency = t_end - t_start;
+    latency = (t_end - t_start)/100;
 
     pr_info("llbench: lookup: %llu ns\n", latency);
 

test/evaluation/km/llbench_bpf.c

@@ -2,7 +2,7 @@
 #include <bpf/bpf_helpers.h>
 #include <linux/bpf.h>
 
-#define META_SIZE 40960
+#define META_SIZE 65000
 #define META_BLOCK_SIZE 32
 #define HEAP_SIZE ((META_SIZE + 1) * META_BLOCK_SIZE)
 

test/evaluation/km/llbench_delete_bpf.c

@@ -0,0 +1,144 @@
+#include <linux/types.h>
+#include <bpf/bpf_helpers.h>
+#include <linux/bpf.h>
+
+#define META_SIZE 65000
+#define META_BLOCK_SIZE 32
+#define HEAP_SIZE ((META_SIZE + 1) * META_BLOCK_SIZE)
+
+struct {
+  __uint(type, BPF_MAP_TYPE_ARRAY);
+  __uint(max_entries, META_SIZE + 1);
+  __type(key, __u32);
+  __type(value, __u32);
+} meta SEC(".maps");
+
+struct {
+  __uint(type, BPF_MAP_TYPE_ARRAY);
+  __uint(max_entries, 1);
+  __type(key, __u32);
+  __type(value, char[HEAP_SIZE]);
+} data SEC(".maps");
+
+static __always_inline char *init_heap(long size) {
+  int i = 0;
+  char *head = bpf_map_lookup_elem(&data, &i);
+  return head;
+}
+
+static __u64 gettop() {
+  __u32 i = 0;
+  __u32 *head = bpf_map_lookup_elem(&meta, &i);
+  if (head == 0) {
+    return 0;
+  }
+  return *head * META_BLOCK_SIZE;
+}
+
+static __noinline __u64 malloc(__u32 size) {
+  __u32 i = 0;
+  // long rv = 0;
+  __u32 *head = bpf_map_lookup_elem(&meta, &i);
+  if (head == 0) {
+    return 0;
+  }
+  if (size >= HEAP_SIZE || size <= 1) {
+    return 0;
+  }
+  __u32 rid = *head + 1;
+
+  __u32 blocks = 1 + (size - 1) / META_BLOCK_SIZE;
+
+  if (*head + blocks >= META_SIZE) {
+    *head = 0;
+    // TODO find free space
+    return 0;
+  }
+  (*head) += blocks;
+  // Directly use head->pos
+  // int newpos = head->pos+1;
+  // We got a free space at idx head->pos and data pos head->size
+
+  __u32 *init_pos = bpf_map_lookup_elem(&meta, &rid);
+  if (init_pos == 0) {
+    return 0;
+  }
+  *init_pos = blocks;
+
+  for (int i = 1; i < META_SIZE; i++) {
+    if (i >= blocks) {
+      break;
+    }
+    __u32 check_idx = rid + i;
+    if (check_idx >= META_SIZE) {
+      // Out of space
+      return 0;
+    }
+    __u32 *check_pos = bpf_map_lookup_elem(&meta, &check_idx);
+    if (check_pos == 0) {
+      return 0;
+    }
+    *check_pos = 1;
+  }
+
+  return (rid - 1) * META_BLOCK_SIZE;
+}
+
+static __noinline void free(__u32 idx) {
+  __u32 block_idx = idx / META_BLOCK_SIZE + 1;
+  __u32 *meta_pos = bpf_map_lookup_elem(&meta, &block_idx);
+  if (meta_pos == 0) {
+    return;
+  }
+  __u32 blocks = *meta_pos;
+  if (blocks >= 1) {
+    __u32 *cur_pos = bpf_map_lookup_elem(&meta, &block_idx);
+    if (cur_pos == 0) {
+      return;
+    }
+    *cur_pos = 0;
+  }
+  // for (int i = 0; i < 2; i++) {
+  //   if (i >= blocks) {
+  //     return;
+  //   }
+  //   __u32 cur_idx = block_idx + i;
+  //   __u32 *cur_pos = bpf_map_lookup_elem(&meta, &cur_idx);
+  //   if (cur_pos == 0) {
+  //     return;
+  //   }
+  //   *cur_pos = 0;
+  // }
+}
+
+struct test_struct {
+  __u64 a;
+  __u64 next;
+};
+
+SEC("tracepoint/syscalls/sys_enter_mount")
+int delete_ll(void *ctx) {
+  char *data_ptr = init_heap(HEAP_SIZE);
+  if (data_ptr == NULL) {
+    return 0;
+  } // Lookup
+  __u64 top = gettop();
+  __u64 curr = top - META_BLOCK_SIZE;
+
+  long starttime = bpf_ktime_get_ns();
+  for (int i = 0; i < 2000; ++i) {
+    if (curr > HEAP_SIZE - 100) {
+      return 0;
+    }
+    struct test_struct *ts = (struct test_struct *)(data_ptr + curr);
+    free(curr);
+    curr = ts->next;
+  }
+  long endtime = bpf_ktime_get_ns();
+  bpf_printk("delete: %ld\n", endtime - starttime);
+  // bpf_printk("last curr: %llu\n", curr);
+
+  return 0;
+}
+
+char _license[] SEC("license") = "GPL";

test/evaluation/km/llbench_lookup_bpf.c

@@ -2,7 +2,7 @@
 #include <bpf/bpf_helpers.h>
 #include <linux/bpf.h>
 
-#define META_SIZE 40960
+#define META_SIZE 65000
 #define META_BLOCK_SIZE 32
 #define HEAP_SIZE ((META_SIZE + 1) * META_BLOCK_SIZE)
 
@@ -26,7 +26,7 @@ static __always_inline char *init_heap(long size) {
   return head;
 }
 
-static __noinline __u32 malloc(__u32 size) {
+static __noinline __u64 malloc(__u32 size) {
   __u32 i = 0;
   // long rv = 0;
   __u32 *head = bpf_map_lookup_elem(&meta, &i);
@@ -114,10 +114,10 @@ int lookup_ll(void *ctx) {
     return 0;
   } // Lookup
 
-  __u64 curr = 384064;
+  __u64 curr = 2048000;
   // long iter = 0;
   long starttime = bpf_ktime_get_ns();
-  for (int i = 0; i < 10000; ++i) {
+  for (int i = 0; i < 64000; ++i) {
     if (curr > HEAP_SIZE - 100) {
       break;
     }

test/evaluation/km/loader.c

@@ -22,11 +22,7 @@ void testcall() {
 #define DATA_PIN_PATH "/sys/fs/bpf/data"
 
 /* detach programs and cleanup pinned maps */
-void cleanup(struct bpf_link *link1, struct bpf_link *link2) {
-  if (link1)
-    bpf_link__destroy(link1);
-  if (link2)
-    bpf_link__destroy(link2);
+void cleanup() {
   unlink(META_PIN_PATH);
   unlink(DATA_PIN_PATH);
 }
@@ -101,9 +97,10 @@ int reuse_pinned_maps(struct bpf_object *obj) {
 }
 
 int main() {
-  cleanup(NULL, NULL);
-  struct bpf_link *link1 = NULL, *link2 = NULL;
+  cleanup();
+  struct bpf_link *link1 = NULL, *link2 = NULL, *link3 = NULL;
   struct bpf_object *obj2 = NULL;
+  struct bpf_object *obj3 = NULL;
 
   /* Step 1: Load first program and attach */
   if (attach_prog("init_ll.o", "init_ll", &link1) != 0)
@@ -112,9 +109,9 @@ int main() {
 
   /* Optional: run program briefly */
   sleep(1);
-  testcall();
-  testcall();
-  testcall();
+  for(int i = 0; i < 16;++i){
+    testcall();
+  }
   sleep(1);
 
   /* Step 3: Detach first program */
@@ -126,20 +123,20 @@ int main() {
   obj2 = bpf_object__open_file("lookup_ll.o", NULL);
   if (libbpf_get_error(obj2)) {
     fprintf(stderr, "Failed to open lookup_ll.o\n");
-    cleanup(NULL, NULL);
+    cleanup();
     return 1;
   }
   /* Step 5: Reuse pinned maps */
   if (reuse_pinned_maps(obj2) != 0) {
     fprintf(stderr, "Failed to reuse pinned maps\n");
-    cleanup(NULL, NULL);
+    cleanup();
     return 1;
   }
   printf("lookup_ll will use existing maps\n");
 
   if (bpf_object__load(obj2)) {
     fprintf(stderr, "Failed to load lookup_ll.o\n");
-    cleanup(NULL, NULL);
+    cleanup();
     return 1;
   }
 
@@ -149,17 +146,18 @@ int main() {
       bpf_object__find_program_by_name(obj2, "lookup_ll");
   if (!prog2) {
     fprintf(stderr, "lookup_ll program not found\n");
-    cleanup(NULL, NULL);
+    cleanup();
     return 1;
   }
 
   link2 = bpf_program__attach_tracepoint(prog2, "syscalls", "sys_enter_mount");
   if (libbpf_get_error(link2)) {
     fprintf(stderr, "Failed to attach lookup_ll\n");
-    cleanup(NULL, NULL);
+    cleanup();
     return 1;
   }
   printf("lookup_ll attached\n");
+  bpf_object__close(obj2);
 
   /* Run for some time */
   sleep(1);
@@ -168,11 +166,58 @@ int main() {
   }
   sleep(1);
 
+  bpf_link__destroy(link2);
+
+  obj3 = bpf_object__open_file("delete_ll.o", NULL);
+  if (libbpf_get_error(obj3)) {
+    fprintf(stderr, "Failed to open delete_ll.o\n");
+    cleanup();
+    return 1;
+  }
+  /* Step 5: Reuse pinned maps */
+  if (reuse_pinned_maps(obj3) != 0) {
+    fprintf(stderr, "Failed to reuse pinned maps\n");
+    cleanup();
+    return 1;
+  }
+  printf("lookup_ll will use existing maps\n");
+
+  if (bpf_object__load(obj3)) {
+    fprintf(stderr, "Failed to load delete_ll.o\n");
+    cleanup();
+    return 1;
+  }
+
+
+  /* Step 6: Attach second program */
+  struct bpf_program *prog3 =
+      bpf_object__find_program_by_name(obj3, "delete_ll");
+  if (!prog3) {
+    fprintf(stderr, "delete_ll program not found\n");
+    cleanup();
+    return 1;
+  }
+
+  link3 = bpf_program__attach_tracepoint(prog3, "syscalls", "sys_enter_mount");
+  if (libbpf_get_error(link3)) {
+    fprintf(stderr, "Failed to attach delete_ll\n");
+    cleanup();
+    return 1;
+  }
+  printf("delete_ll attached\n");
+  bpf_object__close(obj3);
+
+  /* Run for some time */
+  sleep(1);
+  for(int i = 0; i< 32;++i){
+    testcall();
+  }
+  sleep(1);
+
   /* Step 7: Detach second program and cleanup maps */
-  cleanup(NULL, link2);
+  cleanup();
   printf("lookup_ll detached, pinned maps removed\n");
 
-  bpf_object__close(obj2);
 
   return 0;
 }