Implemented QuART_tail, QuART_xtail, QuART_lil and refactored codebase

.gitignore

@@ -1,4 +1,5 @@
 **/*.csv
 build/
 .DS_Store
-.vscode
+.vscode
+results/

ART.h

@@ -34,19 +34,21 @@ namespace ART {
 
     class ART {
         public:
-            ArtNode* root;  // pointer to root node
-            ArtNode* fp; // fast path
-            std::array<ArtNode*, maxPrefixLength> fp_path; // fp path
-            size_t fp_path_length; // stores real length of fp path
-            ArtNode* fp_leaf; 
+            ArtNode* root = nullptr;
+            ArtNode* fp = nullptr; 
+            std::array<ArtNode*, maxPrefixLength> fp_path = {nullptr};
+            size_t fp_path_length = 0; 
+            ArtNode* fp_leaf = nullptr;  
+            size_t fp_depth = 0; 
+            ArtNode** fp_ref = nullptr; 
 
             //constructor
             ART() {
                 root = NULL;
             }
 
             void insert(uint8_t key[], uintptr_t value) {
-                insert(this, root, &root, key, 0, value, maxPrefixLength);
+                insert_recursive(this, root, &root, key, 0, value, maxPrefixLength);
             }
 
             ArtNode* lookup(uint8_t key[]) {
@@ -57,11 +59,15 @@ namespace ART {
                 uint8_t h_keyLength, unsigned depth, unsigned maxKeyLength) {
                     return rangelookup(this, root, l_key, l_keyLength, h_key, h_keyLength, depth, maxKeyLength);
             }
+
+            void printTree() { 
+                printTree(this->root, 0);
+            }
 
 
         private:
             // Void insert function
-            void insert(ART* tree, ArtNode* node, ArtNode** nodeRef, uint8_t key[], unsigned depth,
+            void insert_recursive(ART* tree, ArtNode* node, ArtNode** nodeRef, uint8_t key[], unsigned depth,
                             uintptr_t value, unsigned maxKeyLength) {
                 // Insert the leaf value into the tree
 
@@ -127,7 +133,7 @@ namespace ART {
                 // Recurse
                 ArtNode** child = findChild(node, key[depth]);
                 if (*child) {
-                    insert(tree, *child, child, key, depth + 1, value, maxKeyLength);
+                    insert_recursive(tree, *child, child, key, depth + 1, value, maxKeyLength);
                     return;
                 }
 
@@ -299,7 +305,144 @@ namespace ART {
                 }
                 delete queue;
                 return result;
-            }        
+            }    
+
+            void printTree(ArtNode* node, int depth) {
+                if (!node) return;
+
+                // Indent based on depth
+                for (int i = 0; i < depth; i++) {
+                    printf("  ");
+                }
+
+                if (isLeaf(node)) {
+                    printf("Leaf(%lu)\n", getLeafValue(node));
+                    return;
+                }
+
+                switch (node->type) {
+                    case NodeType4: {
+                        Node4* n = static_cast<Node4*>(node);
+                        printf("Node4 [%p]\n", static_cast<void*>(n));
+                        for (unsigned i = 0; i < n->count; i++) {
+                            printTree(n->child[i], depth + 1);
+                        }
+                        break;
+                    }
+                    case NodeType16: {
+                        Node16* n = static_cast<Node16*>(node);
+                        printf("Node16 [%p]\n", static_cast<void*>(n));
+                        for (unsigned i = 0; i < n->count; i++) {
+                            printTree(n->child[i], depth + 1);
+                        }
+                        break;
+                    }
+                    case NodeType48: {
+                        Node48* n = static_cast<Node48*>(node);
+                        printf("Node48 [%p]\n", static_cast<void*>(n));
+                        for (unsigned i = 0; i < 256; i++) {
+                            if (n->childIndex[i] != emptyMarker) {
+                                printTree(n->child[n->childIndex[i]], depth + 1);
+                            }
+                        }
+                        break;
+                    }
+                    case NodeType256: {
+                        Node256* n = static_cast<Node256*>(node);
+                        printf("Node256 [%p]\n", static_cast<void*>(n));
+                        for (unsigned i = 0; i < 256; i++) {
+                            if (n->child[i]) {
+                                printTree(n->child[i], depth + 1);
+                            }
+                        }
+                        break;
+                    }
+                }
+            }
+
+            // Method to verify the tail path after each insertion
+            bool verifyTailPath() {
+                if (this->fp_path_length == 0) {
+                    return true;
+                }
+
+                ArtNode* current = this->root;
+                // Traverse the tree following the fp_path
+                for (size_t i = 0; i < this->fp_path_length; i++) {
+                    if (i == this->fp_path_length - 1) {
+                        if (current == this->fp) {
+                            if (getLeafValue(maximum(current)) == getLeafValue(this->fp_leaf)) {
+                                //printf("Success: fp_path is correct.\n");
+                                return true;
+                            } else {
+                                printf("Error: fp_leaf mismatch. Expected %lu, got %lu.\n",
+                                    getLeafValue(maximum(current)), getLeafValue(this->fp_leaf));
+                                return false;
+                            }
+                        } else {
+                            printf("Error: last node in fp_path is not the fp. Expected %p, got %p.\n",
+                                static_cast<void*>(current), static_cast<void*>(this->fp));
+                            return false;
+                        }
+                    }
+
+                    // Move to the rightmost child
+                    switch (current->type) {
+                        case NodeType4: {
+                            Node4* node = static_cast<Node4*>(current);
+                            if (node->count > 0) {
+                                current = node->child[node->count - 1];
+                            } else {
+                                printf("Error: NodeType4 has no children.\n");
+                                return false;
+                            }
+                            break;
+                        }
+                        case NodeType16: {
+                            Node16* node = static_cast<Node16*>(current);
+                            if (node->count > 0) {
+                                current = node->child[node->count - 1];
+                            } else {
+                                printf("Error: NodeType16 has no children.\n");
+                                return false;
+                            }
+                            break;
+                        }
+                        case NodeType48: {
+                            Node48* node = static_cast<Node48*>(current);
+                            unsigned pos = 255;
+                            while (pos > 0 && node->childIndex[pos] == emptyMarker) pos--;
+                            if (node->childIndex[pos] != emptyMarker) {
+                                current = node->child[node->childIndex[pos]];
+                            } else {
+                                printf("Error: NodeType48 has no valid children.\n");
+                                return false;
+                            }
+                            break;
+                        }
+                        case NodeType256: {
+                            Node256* node = static_cast<Node256*>(current);
+                            unsigned pos = 255;
+                            while (pos > 0 && !node->child[pos]) pos--;
+                            if (node->child[pos]) {
+                                current = node->child[pos];
+                            } else {
+                                printf("Error: NodeType256 has no valid children.\n");
+                                return false;
+                            }
+                            break;
+                        }
+                        default:
+                            printf("Error: Unknown node type.\n");
+                            return false;
+                    }
+                }
+
+                // If we exit the loop without returning, the path is incorrect
+                printf("Error: fp_path does not lead to the fp.\n");
+                return false;
+            }
+
 
     };
 }  // namespace ART

ArtNode.h

@@ -18,7 +18,7 @@
  #include <chrono>
 
  #include "Helper.h" 
- 
+
  #include <cassert>
  #include <cstdio>
  #include <fstream>
@@ -27,7 +27,7 @@
  #include <memory>
  #include <stdexcept>
 
- #include <vector>
+ #include <array>
 
  namespace ART {   
     class ART; 
@@ -73,7 +73,16 @@
 
          void insertNode4(ART* tree, ArtNode** nodeRef, uint8_t keyByte,
              ArtNode* child);
+         void insertNode4Tail(ART* tree, ArtNode** nodeRef, uint8_t keyByte,
+             ArtNode* child, std::array<ArtNode*, maxPrefixLength>& temp_fp_path,
+             size_t& temp_fp_path_length, size_t depth_prev);
+         void insertNode4OnlyUpdateFp(ART* tree, ArtNode** nodeRef, uint8_t keyByte,
+             ArtNode* child);
+         void insertNode4AlwaysChangeFp(ART* tree, ArtNode** nodeRef, uint8_t keyByte,
+             ArtNode* child, std::array<ArtNode*, maxPrefixLength>& temp_fp_path,
+             size_t& temp_fp_path_length, size_t depth_prev);
          void eraseNode4(ART* tree, ArtNode** nodeRef, ArtNode** leafPlace);
+
      };
 
      // Node with up to 16 children
@@ -88,7 +97,16 @@
 
          void insertNode16(ART* tree, ArtNode** nodeRef, uint8_t keyByte,
              ArtNode* child);
+         void insertNode16Tail(ART* tree, ArtNode** nodeRef, uint8_t keyByte,
+             ArtNode* child, std::array<ArtNode*, maxPrefixLength>& temp_fp_path,
+             size_t& temp_fp_path_length, size_t depth_prev);
+         void insertNode16OnlyUpdateFp(ART* tree, ArtNode** nodeRef, uint8_t keyByte,
+             ArtNode* child);
+        void insertNode16AlwaysChangeFp(ART* tree, ArtNode** nodeRef, uint8_t keyByte,
+             ArtNode* child, std::array<ArtNode*, maxPrefixLength>& temp_fp_path,
+             size_t& temp_fp_path_length, size_t depth_prev);
          void eraseNode16(ART* tree, ArtNode** nodeRef, ArtNode** leafPlace);
+
      };
 
      // Node with up to 48 children
@@ -103,7 +121,16 @@
 
          void insertNode48(ART* tree, ArtNode** nodeRef, uint8_t keyByte,
              ArtNode* child);
+         void insertNode48Tail(ART* tree, ArtNode** nodeRef, uint8_t keyByte,
+             ArtNode* child, std::array<ArtNode*, maxPrefixLength>& temp_fp_path,
+             size_t& temp_fp_path_length, size_t depth_prev);
+         void insertNode48OnlyUpdateFp(ART* tree, ArtNode** nodeRef, uint8_t keyByte,
+             ArtNode* child);
+         void insertNode48AlwaysChangeFp(ART* tree, ArtNode** nodeRef, uint8_t keyByte,
+             ArtNode* child, std::array<ArtNode*, maxPrefixLength>& temp_fp_path,
+             size_t& temp_fp_path_length, size_t depth_prev);
          void eraseNode48(ART* tree, ArtNode** nodeRef, uint8_t keyByte);
+
      };
 
      // Node with up to 256 children
@@ -114,8 +141,16 @@
 
          void insertNode256(ART* tree, ArtNode** nodeRef, uint8_t keyByte,
              ArtNode* child);
+         void insertNode256Tail(ART* tree, ArtNode** nodeRef, uint8_t keyByte,
+            ArtNode* child, std::array<ArtNode*, maxPrefixLength>& temp_fp_path,
+            size_t& temp_fp_path_length, size_t depth_prev);
+         void insertNode256OnlyUpdateFp(ART* tree, ArtNode** nodeRef, uint8_t keyByte,
+            ArtNode* child);
+         void insertNode256AlwaysChangeFp(ART* tree, ArtNode** nodeRef, uint8_t keyByte,
+             ArtNode* child, std::array<ArtNode*, maxPrefixLength>& temp_fp_path,
+             size_t& temp_fp_path_length, size_t depth_prev);
          void eraseNode256(ART* tree, ArtNode** nodeRef, uint8_t keyByte);
- 
+
      };
 
      void copyPrefix(ArtNode* src, ArtNode* dst) {
@@ -306,6 +341,7 @@
          this->child[keyByte] = child;
      }  
 
+
      void Node256::eraseNode256(ART* tree, ArtNode** nodeRef, uint8_t keyByte) {
          // Delete leaf from inner node
          this->child[keyByte] = NULL;
@@ -362,8 +398,7 @@
              }
          }
          throw;  // Unreachable
-     }
-
+     }     
 
      ArtNode* minimum(ArtNode* node) {
          // Find the leaf with smallest key
@@ -481,5 +516,34 @@
 
          return NULL;
      }    
+
+     void printFpPath(std::array<ArtNode*, maxPrefixLength> path, size_t path_length) {
+        // Print the fp path for debugging
+        for (size_t i = 0; i < path_length; i++) {
+            if (isLeaf(path[i])) {
+                printf("Leaf(%lu)\n", getLeafValue(path[i]));
+            } 
+            else {
+                switch (path[i]->type) {
+                case NodeType4:
+                    printf("Node4 %p\n", path[i]);
+                    break;
+                case NodeType16:
+                    printf("Node16 %p\n", path[i]);
+                    break;
+                case NodeType48:
+                    printf("Node48 %p\n", path[i]);
+                    break;
+                case NodeType256:
+                    printf("Node256 %p\n", path[i]);
+                    break;
+                default:
+                    printf("Unknown NodeType %p\n", path[i]);
+                    break;
+                }
+            }
+        }
+    }
+
 
  }