increase index bucket count default, fix error-case memory leak

Author: Cryptkeeper

include/index.h

@@ -10,19 +10,27 @@
 /// @struct inode_s
 /// @brief Individual file node in the index map.
 struct inode_s {
-  char* fp;             ///< File path (string duplicated)
-  struct fsstat_s st;   ///< File stat info structure
-  struct inode_s* next; ///< Next node in the index map
+  char* fp;            ///< File path (string duplicated)
+  struct fsstat_s st;  ///< File stat info structure
+  struct inode_s* next;///< Next node in the index map
 };
 
 /// @def INDEXBUCKETS
 /// @brief The fixed number of buckets in the index map.
-#define INDEXBUCKETS 64
+/// @note This is a magic number, but via testing, performance is healthy around
+/// ~40 nodes per bucket, so this should roughly accommodate ~150k nodes.
+#define INDEXBUCKETS 4096
+
+/// @def INDEXBUCKETSMASK
+/// @brief The bitmask used for deriving the bucket index from the hash value.
+/// @note This should correspond to the number of buckets defined in
+/// `INDEXBUCKETS` (0xFFF, 0b1111_1111_1111, 2^12-1 = 4095).
+#define INDEXBUCKETSMASK 0xFFF ///< Maximum bucket index mask
 
 /// @struct index_s
 /// @brief Index map structure for storing file nodes.
 struct index_s {
-  struct inode_s* buckets[INDEXBUCKETS]; ///< Array of index buckets
+  struct inode_s* buckets[INDEXBUCKETS];///< Array of index buckets
   long size;                            ///< Number of sum nodes in the index
 };
 
@@ -48,7 +56,8 @@ int indexwrite(struct index_s* idx, FILE* s);
 /// is set.
 int indexread(struct index_s* idx, FILE* s);
 
-/// @brief Copies the node and inserts it into the index mapping.
+/// @brief Copies the node and inserts it into the index mapping. The copy is
+/// by assignment, so pointers within the node are retained (not duplicated).
 /// @param idx The index to insert into
 /// @param node The node to insert
 /// @return The pointer to the new node in the index map, otherwise NULL is

src/index.c

@@ -13,18 +13,28 @@
 /// @brief The maximum filepath length of a file in the index.
 #define INDEXMAXFP 512
 
-/// @brief Hashes the filepath string into an index bucket.
+/// @brief Hashes the filepath string.
+/// @note 64-bit FNV-1a implementation is used for hashing.
 /// @param fp The filepath string to hash
-/// @return The index bucket number.
-static int indexhash(const char* fp) {
-  int h = 0;
-  for (const char* p = fp; *p != '\0'; p++) h = (h << 5) - h + *p;
-  if (h < 0) h = -h;
-  return h % INDEXBUCKETS;
+/// @return The hashed value of the filepath.
+static uint64_t indexhash(const char* fp) {
+  uint64_t hash = 14695981039346656037u;// FNV offset basis
+  while (*fp) {
+    hash ^= (uint8_t) *fp;// XOR byte into hash
+    hash *= 1099511628211;// FNV prime
+    fp++;
+  }
+  return hash;
 }
 
+/// @def indexbucket
+/// @brief Maps and casts the hash value to a bucket index via the last N bits
+/// (where N is the number of buckets, `INDEXBUCKETS`).
+#define indexbucket(hash) ((int) (hash & INDEXBUCKETSMASK))
+
 struct inode_s* indexfind(const struct index_s* idx, const char* fp) {
-  struct inode_s* head = idx->buckets[indexhash(fp)];
+  const uint64_t hash = indexhash(fp);
+  struct inode_s* head = idx->buckets[indexbucket(hash)];
   while (head != NULL) {
     if (strcmp(head->fp, fp) == 0) return head;
     head = head->next;
@@ -72,8 +82,11 @@ int indexread(struct index_s* idx, FILE* s) {
                 &b.st.fsze) == 3) {
     // duplicate the string onto the heap
     if ((b.fp = strdup(b.fp)) == NULL) return -1;
-    if (indexput(idx, b) == NULL) return -1;
-    b.fp = fp;
+    if (indexput(idx, b) == NULL) {
+      free(b.fp);
+      return -1;
+    }
+    b.fp = fp;// reset to static buffer
   }
 
   return 0;
@@ -93,10 +106,11 @@ static struct inode_s* indexprepend(struct inode_s* idx,
 }
 
 struct inode_s* indexput(struct index_s* idx, const struct inode_s node) {
-  struct inode_s* bucket = idx->buckets[indexhash(node.fp)];
+  const int bi = indexbucket(indexhash(node.fp));
+  struct inode_s* bucket = idx->buckets[bi];
   struct inode_s* head = indexprepend(bucket, node);
   if (head == NULL) return NULL;
-  idx->buckets[indexhash(node.fp)] = head;
+  idx->buckets[bi] = head;
   idx->size++;
   return head;
 }