create a map for leaves

Author: Davidson-Souza

contrib/format.sh

@@ -2,7 +2,7 @@
 
 set -e 
 
-for file in $(find src/ include/ -name *.h)
+for file in $(find src/ include/ -name *.[h,c])
 do 
 	clang-format -i $file
 done

src/flat_file.h

@@ -58,7 +58,7 @@ struct utreexo_forest_file {
 
 /* Things we need to keep through different sessions, they are persisted at the
  * beginning of a file
- * */
+ */
 struct utreexo_forest_file_header {
   uint64_t magic;
   struct utreexo_forest_page_header *wrt_page; // Which page are we on
@@ -69,26 +69,24 @@ struct utreexo_forest_file_header {
 } __attribute__((__packed__));
 
 /* The size of a page minus it's header */
-const inline uint64_t utreexo_page_data_size() {
+static inline uint64_t utreexo_page_data_size() {
   return NODES_PER_PAGE * sizeof(utreexo_forest_node);
 }
 
 /* The size of a whole page */
-const inline uint64_t utreexo_page_size() {
+static inline uint64_t utreexo_page_size() {
   return utreexo_page_data_size() + sizeof(struct utreexo_forest_page_header);
 }
 
 /* A pointer to the page's data (excludes the header) */
-const inline utreexo_forest_node *utreexo_page_data(char *data, size_t n) {
+static inline utreexo_forest_node *utreexo_page_data(char *data, size_t n) {
   return (utreexo_forest_node *)(data + (utreexo_page_size() * n) +
                                  sizeof(struct utreexo_forest_page_header));
 }
 
 /* A pointer to the page's data */
-const inline struct utreexo_forest_page_header *utreexo_page(char *data,
-                                                             size_t n) {
-  return (struct utreexo_forest_page_header *)(data +
-                                               (utreexo_page_size() * n));
+static inline void *utreexo_page(char *data, size_t n) {
+  return (void *)(data + (utreexo_page_size() * n));
 }
 
 /* Close the file, and free the memory */

src/flat_file_impl.h

@@ -40,6 +40,7 @@ static inline void utreexo_forest_file_init(struct utreexo_forest_file **file,
 
   struct utreexo_forest_file *pfile =
       (struct utreexo_forest_file *)malloc(sizeof(struct utreexo_forest_file));
+
   if (pfile == NULL) {
     perror("malloc");
     exit(1);

src/forest_test.c

@@ -5,6 +5,7 @@
 
 #include "flat_file.h"
 #include "forest_node.h"
+#include "leaf_map.h"
 #include "map_forest_impl.h"
 #include "parent_hash.h"
 #include "test_utils.h"
@@ -15,8 +16,16 @@ static inline struct utreexo_forest get_test_forest(const char *filename) {
 
   utreexo_forest_file_init(&file, &heap, filename);
   uint8_t *roots = ((uint8_t *)heap) + sizeof(uint64_t);
+
+  char map_name[100];
+  sprintf(map_name, "map_%s", filename);
+
+  utreexo_leaf_map map;
+  utreexo_leaf_map_new(&map, map_name, O_CREAT | O_RDWR);
+
   struct utreexo_forest p = {
       .data = file,
+      .leaf_map = map,
       .roots = (utreexo_forest_node **)(roots),
       .nLeaf = heap,
   };
@@ -145,12 +154,17 @@ void test_add_single() {
   TEST_BEGIN("add_single");
   utreexo_node_hash leaf = {.hash = {0}};
   hash_from_u8(leaf.hash, 0);
+
   void *heap = NULL;
   struct utreexo_forest_file *file = NULL;
   utreexo_forest_file_init(&file, &heap, "add_single.bin");
 
+  utreexo_leaf_map leaf_map;
+  utreexo_leaf_map_new(&leaf_map, "leaves_single.bin", O_CREAT | O_RDWR);
+
   struct utreexo_forest p = {
       .data = file,
+      .leaf_map = leaf_map,
       .roots = (utreexo_forest_node **)(((uint8_t *)heap) + sizeof(uint64_t)),
       .nLeaf = heap,
   };
@@ -197,6 +211,32 @@ void test_add_many() {
   TEST_END;
 }
 
+void test_delete_with_map() {
+  TEST_BEGIN("delete with map");
+  const unsigned char expected_root[] = {
+      0x72, 0x6f, 0xdd, 0x3b, 0x43, 0x2c, 0xc5, 0x9e, 0x68, 0x48, 0x7d,
+      0x12, 0x6e, 0x70, 0xf0, 0xdb, 0x74, 0xa2, 0x36, 0x26, 0x7f, 0x8d,
+      0xae, 0xae, 0x30, 0xb3, 0x18, 0x39, 0xa4, 0xe7, 0xeb, 0xed};
+  struct utreexo_forest p = get_test_forest("delete_with_map.bin");
+  uint8_t values[] = {0, 1, 2, 3, 4, 5, 6, 7};
+  for (int i = 0; i < 8; i++) {
+    utreexo_node_hash leaf = {.hash = {0}};
+    hash_from_u8(leaf.hash, values[i]);
+    utreexo_forest_add(&p, leaf);
+  }
+
+  utreexo_node_hash leaf = {.hash = {0}};
+  hash_from_u8(leaf.hash, values[0]);
+
+  utreexo_forest_node *pnode = NULL;
+  utreexo_leaf_map_get(&p.leaf_map, &pnode, leaf);
+  delete_single(&p, pnode);
+
+  ASSERT_ARRAY_EQ(expected_root, p.roots[3]->hash.hash, 32);
+
+  TEST_END;
+}
+
 /* Tests from https://github.com/mit-dci/rustreexo */
 void test_from_test_cases(void) {
   TEST_BEGIN("rustreexo test suite");
@@ -267,9 +307,10 @@ void test_delete_some() {
     utreexo_forest_add(&p, leaf);
   }
 
-  delete_single(&p, 0);
-  delete_single(&p, 2);
-  delete_single(&p, 9);
+  delete_single_pos(&p, 0);
+  delete_single_pos(&p, 2);
+  delete_single_pos(&p, 9);
+
   ASSERT_ARRAY_EQ(p.roots[3]->hash.hash, expected_root, 32);
   TEST_END;
 }
@@ -390,7 +431,7 @@ void test_deletion_cases() {
     }
 
     for (size_t i = 0; i < test_case->n_target_values; ++i) {
-      delete_single(&p, test_case->target_values[i]);
+      delete_single_pos(&p, test_case->target_values[i]);
     }
 
     size_t n_mached = 0;
@@ -420,5 +461,7 @@ int main() {
   test_grab_node();
   test_delete_some();
   test_deletion_cases();
+  test_delete_with_map();
+
   return 0;
 }

src/leaf_map.h

@@ -0,0 +1,53 @@
+/*
+ * COPYRIGHT (C) 2023 Davidson Souza. All Rights Reserved.
+ *
+ * In utreexo, we hold all UTXOs as leaves inside some trees. While we still
+ * have trees, they are not sorted by leaf hashes and leaves can move upwards as
+ * nodes gets deleted. Thus, making it hard to track individual leaves inside
+ * the accumulator. To solve that, we hold a map from leaf_hash -> *leaf, where
+ * *leaf is a pointer to that leaf inside the accumulator.
+ *
+ * When nodes are added and removed, it's only a pointer operation, and no data
+ * gets moved arround, therefore, it's fair to keep pointers and derreference
+ * them to get a (undeleted) node.
+ *
+ * This is a simple disk-based universal hashing hash map, we allocate a
+ * gigantic file at the beggining (64GB) but use a sparse file, where we
+ * "pretend" we have 64GB, but the OS doesn't allocate that until we actually
+ * use the space. This file starts with zero bytes and grows as we go.
+ */
+#ifndef LEAF_MAP_H
+#define LEAF_MAP_H
+
+#include "forest_node.h"
+
+typedef struct {
+  int fd;
+} utreexo_leaf_map;
+
+/* Creates a new leaf_map. This function doesn't allocate any memory, since
+ * utreexo_leaf_map isn't particularly big. Filename is the file we'll store
+ * stuff in and flags are the flags for that file on our FS
+ */
+static inline void utreexo_leaf_map_new(utreexo_leaf_map *map,
+                                        const char *filename,
+                                        const unsigned int flags);
+
+/* Gets a node's reference from the map. You should pass a pointer to a pointer
+ * to a utreexo_forest_node. That's because you'll end-up with a
+ * utreexo_forest_node*, the actual thing is inside the mmap-ed file, taking it
+ * by value would create a copy that isn't what you whant.
+ */
+static inline void utreexo_leaf_map_get(utreexo_leaf_map *map,
+                                        utreexo_forest_node **node,
+                                        utreexo_leaf_hash leaf);
+
+/* Sets a key to a given pointer */
+static inline void utreexo_leaf_map_set(utreexo_leaf_map *map,
+                                        utreexo_forest_node *node,
+                                        utreexo_leaf_hash hash);
+/* Delete a leaf from the map */
+static inline void utreexo_leaf_delete(utreexo_leaf_map *map,
+                                       utreexo_node_hash hash);
+
+#endif // LEAF_MAP_H

src/leaf_map_impl.h

@@ -0,0 +1,97 @@
+#include <assert.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "forest_node.h"
+#include "leaf_map.h"
+
+static inline unsigned int hash(unsigned char value[36]) {
+  unsigned long hash = 5381;
+  int c;
+
+  for (size_t i = 0; i < 36; ++i)
+    hash = ((hash << 5) + hash) + value[i];
+
+  return hash & 0xffffffff;
+}
+
+static inline void utreexo_leaf_map_new(utreexo_leaf_map *map,
+                                        const char *filename,
+                                        const unsigned int flags) {
+  int fd = open(filename, flags, 0666);
+  if (fd == -1) {
+    perror("open");
+    exit(EXIT_FAILURE);
+  }
+
+  lseek(fd, 0xff, SEEK_SET);
+
+  char end = 0;
+  write(fd, &end, sizeof(char));
+
+  *map = (utreexo_leaf_map){
+      .fd = fd,
+  };
+}
+
+static inline void utreexo_leaf_map_get(utreexo_leaf_map *map,
+                                        utreexo_forest_node **node,
+                                        utreexo_leaf_hash leaf) {
+  utreexo_forest_node *pnode = NULL;
+  unsigned char key[36] = {0};
+
+  memmove(key, leaf.hash, 32);
+
+  do {
+    unsigned long position = hash(key) * sizeof(void *);
+    lseek(map->fd, position, SEEK_SET);
+    read(map->fd, &pnode, sizeof(utreexo_forest_node *));
+    ++(*(unsigned int *)&key[32]);
+  } while (pnode != NULL && memcmp(pnode->hash.hash, leaf.hash, 32) != 0);
+  *node = pnode;
+}
+
+static inline void utreexo_leaf_map_set(utreexo_leaf_map *map,
+                                        utreexo_forest_node *node,
+                                        utreexo_leaf_hash leaf) {
+  utreexo_forest_node *pnode = NULL;
+  unsigned char key[36] = {0};
+  unsigned long position = 0;
+
+  memmove(key, leaf.hash, 32);
+
+  do {
+    position = hash(key) * sizeof(utreexo_forest_node **);
+    lseek(map->fd, position, SEEK_SET);
+    read(map->fd, pnode, sizeof(utreexo_forest_node **));
+    ++(*(unsigned int *)&key[32]);
+  } while (pnode != NULL);
+
+  assert(pnode == NULL);
+
+  lseek(map->fd, position, SEEK_SET);
+  write(map->fd, &node, sizeof(utreexo_forest_node *));
+}
+
+static inline void utreexo_leaf_delete(utreexo_leaf_map *map,
+                                       utreexo_node_hash leaf) {
+  utreexo_forest_node *pnode = NULL;
+  unsigned char key[36] = {0};
+  unsigned long position = 0;
+
+  memmove(key, leaf.hash, 32);
+
+  do {
+    position = hash(key) * sizeof(void *);
+    lseek(map->fd, position, SEEK_SET);
+    read(map->fd, pnode, sizeof(utreexo_forest_node **));
+    ++(*(unsigned int *)&key[32]);
+  } while (pnode != NULL && memcmp(pnode->hash.hash, leaf.hash, 32) != 0);
+
+  pnode = NULL;
+  lseek(map->fd, position, SEEK_SET);
+  write(map->fd, pnode, sizeof(utreexo_forest_node **));
+}