Merge pull request #95 from Electrostat-Lab/arithmos-eca

Arithmos Maps: Hashmaps library and Map ADT

Author: pavly-gerges

.github/workflows/build-test.yml

@@ -79,6 +79,9 @@ jobs:
         - name: Testing "hello_contiguous_buffer.c"
           run: ./helper-scripts/ci-cd/test-electrostatic.sh "hello_lists.c" "hello-listadt"
 
+        - name: Testing "hello_hashmaps.c"
+          run: ./helper-scripts/ci-cd/test-electrostatic.sh "hello_hashmaps.c" "hello-hashmaps"
+
         - name: Testing "hello_unittest.c"
           run: ./helper-scripts/ci-cd/test-electrostatic.sh "hello_unittest.c" "hello-unittest"
 

sdk/core/src/include/electronetsoft/arithmos/adt/list.h

@@ -47,27 +47,35 @@ struct list_element {
   void *data;
   void *metadata;
   size_t size;
+  element_type type;
 };
 
 struct list_info {
-  uint64_t start_index;
+  uint64_t index;
   uint64_t length;
   uint64_t rate;
+  void *metadata;
 };
 
 struct list {
   list_element **elements;
   list_function_table *function_table;
   list_type type;
   memory_partition elements_memory;
-  uint64_t length;
+  uint64_t position;
   uint64_t limit;
+  uint64_t hash_key;
 };
 
 struct list_function_table {
   status_code (*contains)(list *, list_element *);
-  status_code (*iterator)(list *, list_info, void (*callback)(list *, list_element *));
+  status_code (*iterator)(list *, list_info,
+          status_code (*callback)(list *, list_info, list_element *));
   status_code (*add)(list *, list_element *);
+  status_code (*insert)(list *, list_element *, uint64_t);
+  status_code (*on_collision)(list *, uint64_t, list_element *);
+  status_code (*insert_overwrite)(list *, list_element *, uint64_t);
+  status_code (*on_collision_overwrite)(list *, uint64_t, list_element *);
   status_code (*get)(list *, uint64_t, list_element **);
   status_code (*index_of)(list *, list_element *, uint64_t *);
   status_code (*resize)(list *, uint16_t);

sdk/core/src/include/electronetsoft/arithmos/adt/map.h

@@ -0,0 +1,63 @@
+#ifndef _MAP_H_
+#define _MAP_H_
+
+#include <stddef.h>
+#include <stdint.h>
+#include <inttypes.h>
+#include <stddef.h>
+#include <electronetsoft/arithmos/adt/list.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct map_element {
+    char *key;
+    list_element *value;
+};
+
+struct map_processors {
+    status_code (*on_initialization)(map *);
+    status_code (*on_deinitialization)(map *);
+    status_code (*on_insertion)(map *, map_element *, uint64_t);
+    status_code (*on_resize_dispatch)(map *, list_element **);
+    status_code (*on_removal)(map *, list *, uint64_t);
+    status_code (*on_collision)(list *,
+                                uint64_t,
+                                list_element *);
+    status_code (*on_collision_resolution)(list *,
+                                           uint64_t,
+                                           list_element *);
+};
+
+struct map {
+    map_function_table *function_table;
+    map_type type;
+    list *adt;
+    map_processors *processors;
+    uint64_t count;
+};
+
+struct map_function_table {
+    status_code (*insert)(map *, map_element *);
+    status_code (*insert_all)(map *, map_element **);
+    status_code (*remove)(map *, const char *);
+    status_code (*remove_all)(map *, const char **);
+    status_code (*resize)(map *, uint64_t);
+    status_code (*contains)(map *, const char *);
+    status_code (*contains_all)(map *, const char **);
+    status_code (*get)(map *, const char *key, map_element *);
+    status_code (*iterator)(map *, status_code (*callback)(map *, map_element *));
+};
+
+status_code init_map_function_table(map *, map_function_table *,
+                                    api_lifecycle *);
+
+status_code map_get_lambda_factor(map *, float *);
+
+status_code deinit_map_function_table(map *, api_lifecycle *);
+
+#ifdef __cplusplus
+};
+#endif
+#endif

sdk/core/src/include/electronetsoft/arithmos/map/hashmap.h

@@ -0,0 +1,19 @@
+#ifndef _HASH_MAP_H_
+#define _HASH_MAP_H_
+
+#include <electronetsoft/arithmos/adt/map.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+status_code hashmap_init(map *, map_function_table *,
+                               api_lifecycle *);
+
+
+status_code hashmap_deinit(map *, api_lifecycle *);
+
+#ifdef __cplusplus
+};
+#endif
+#endif

sdk/core/src/include/electronetsoft/util/types.h

@@ -70,6 +70,8 @@ typedef enum status_code {
     EDLLSYMFAIL = (EDLLOPENFAIL + 1),
     EDLLCONVENTIONCALLRETURN = (EDLLSYMFAIL + 1),
     UNEXPECTED_ERROR = (EDLLCONVENTIONCALLRETURN + 1),
+    EBUFFER_EXISTS = (UNEXPECTED_ERROR + 1),
+    INVALID_OP = (EBUFFER_EXISTS + 1),
     ASSERTION_SUCCESS = 1,
     ASSERTION_FAILURE = 0
 } status_code;
@@ -119,6 +121,27 @@ typedef struct mat3_processors (mat3_processors);
 
 typedef struct caller_graph (caller_graph);
 
+typedef struct map (map);
+typedef struct map_element (map_element);
+typedef enum map_type {
+    MAP_TYPE_HASHMAP = COLUMN_CONVENTION_ITERATOR - 1,
+    MAP_TYPE_TREEMAP = MAP_TYPE_HASHMAP - 1
+} map_type;
+typedef struct map_function_table (map_function_table);
+typedef struct map_processors (map_processors);
+typedef struct hash_component (hash_component);
+
+typedef struct automaton (automaton);
+typedef struct automaton_state (automaton_state);
+typedef struct automaton_input (automaton_input);
+typedef struct automaton_zeta (automaton_zeta);
+typedef struct automaton_component (automaton_component);
+
+typedef enum {
+    ELEMENT_LIST = MAP_TYPE_TREEMAP - 1,
+    ELEMENT_MAP_ITEM = ELEMENT_LIST - 1,
+} element_type;
+
 #ifdef __cplusplus
 };
 #endif

sdk/core/src/include/electronetsoft/util/utilities.h

@@ -41,6 +41,12 @@ struct api_lifecycle {
     void (*on_operation_failed)(void *api, void *caller, status_code cause);
 };
 
+struct hash_component {
+    char *key;
+    uint64_t *hash;
+    uint64_t user_key;
+};
+
 /**
  * Uses a pointer as an r-value for safe
  * comparison reasons.
@@ -104,43 +110,86 @@ static inline typed_pointer get_typed_pointer(void *address, pointer_type type)
     return pointer;
 }
 
-/**
- * @brief Improved spreading: uses a 64-bit Mixer (MurmurHash3 style)
- * to distribute entropy across the entire 64-bit range.
- */
 static inline status_code spread_64(uint64_t in, uint64_t *out) {
     if (rvalue(out) == NULL) {
         return EUNDEFINEDBUFFER;
     }
 
-    in = (in ^ (in >> 30)) * 0xbf58476d1ce4e5b9ULL;
-    in = (in ^ (in >> 27)) * 0x94d049bb133111ebULL;
-    in = in ^ (in >> 31);
+    in = in ^ ((in ^ (in >> 32)) >> 32);
     *out = in;
 
     return PASS;
 }
 
-static inline status_code hash_key(const char *key, uint64_t *hash) {
-    if (rvalue((void *) key) == NULL || rvalue(hash) == NULL) {
+static inline status_code hash_key(hash_component hasher) {
+    if (rvalue((void *) hasher.key) == NULL ||
+            rvalue(hasher.hash) == NULL) {
         return EUNDEFINEDBUFFER;
     }
 
     // Use a large prime constant to initialize (FNV-1a style)
     uint64_t h = 0xcbf29ce484222325ULL;
 
     // Process every character
-    for (const char *address = key; *address != '\0'; address++) {
+    // Algorithm for polynomial hashing using Horner's rule
+    for (const char *address = hasher.key; *address != '\0'; address++) {
+        // use reverse Horner's Rule to compute the hash
         // 1. XOR the character into the hash
-        h ^= (uint8_t) (*address);
-        // 2. Multiply by a large prime (this spreads the bits)
-        h *= 0x100000001b3ULL;
+        h ^= (*address);
+        // 2. Multiply by 2^5 (aka 32) which is the same as left-shifting by
+        // 5 bits using Cyclic Shift Hashcode
+        h = (h << 5) | (h >> (64 - 5));
+        // 4. Combine MSB Component with LSB Component
+        h = (h >> 32) ^ h;
     }
 
     // Apply your spread_64 as a finalizer to ensure high entropy
-    return spread_64(h, hash);
+    return spread_64(h ^ hasher.user_key, hasher.hash);
 }
 
+static inline uint64_t hash_compress(uint64_t hash,
+                                     uint64_t limit) {
+    // the equivalent of modulus operation
+    // finds the remainder of an integer division operation
+    return hash - (((uint64_t) (hash/limit)) * limit);
+}
+
+static inline uint64_t generate_next_odd(uint64_t n) {
+    return (n * 2) + 1;
+}
+
+static inline status_code hashkey_compress64(hash_component hasher,
+                                             uint64_t limit) {
+    if (rvalue((void *) hasher.key) == NULL ||
+        rvalue(hasher.hash) == NULL) {
+        return EUNDEFINEDBUFFER;
+    }
+
+    status_code __code = hash_key(hasher);
+    if (PASS != __code) {
+        return __code;
+    }
+    *(hasher.hash) = hash_compress(*(hasher.hash), limit);
+
+    return PASS;
+}
+
+//static inline status_code is_prime(uint64_t n) {
+//    return PASS;
+//}
+//
+//static inline uint64_t generate_next_prime(uint64_t n) {
+//    uint64_t next_odd = n;
+//
+//    while (1) {
+//        next_odd = generate_next_odd(next_odd);
+//        if (is_prime(next_odd)) {
+//            return next_odd;
+//        }
+//    }
+//    return n;
+//}
+
 #ifdef __cplusplus
 };
 #endif