template.h File Reference

#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <derive-c/core.h>
#include <derive-c/panic.h>
#include <derive-c/self.h>
#include <derive-c/structures/hashmap/utils.h>

Include dependency graph for template.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	KEY_ENTRY
struct	SELF
struct	KV_PAIR
struct	KV_PAIR_CONST

Macros
#define	K   derive_c_parameter_key
#define	K_DELETE   derive_c_parameter_key_delete
#define	V   derive_c_parameter_value
#define	V_DELETE   derive_c_parameter_value_delete
#define	HASH   derive_c_parameter_hash
#define	EQ   derive_c_parameter_eq
#define	KEY_ENTRY   NAME(SELF, key_entry)
#define	KV_PAIR   NAME(SELF, kv)
#define	KV_PAIR_CONST   NAME(SELF, kv_const)

Functions
static SELF	new_with_capacity_for (size_t capacity)
static SELF	new ()
static SELF	shallow_clone (SELF const *self)
static void	delete (SELF *self)
static V *	insert (SELF *self, K key, V value)
static void	extend_capacity_for (SELF *self, size_t expected_items)
static V *	try_insert (SELF *self, K key, V value)
static V *	try_write (SELF *self, K key)
static V *	write (SELF *self, K key)
static V const *	try_read (SELF const *self, K key)
static V const *	read (SELF const *self, K key)
static bool	try_remove (SELF *self, K key, V *destination)
static V	remove (SELF *self, K key)
static void	delete_entry (SELF *self, K key)
static size_t	size (SELF const *self)
static KV_PAIR	next (ITER *iter)
static size_t	position (ITER const *iter)
static bool	empty (ITER const *iter)
static ITER	get_iter (SELF *self)
static KV_PAIR_CONST	next (ITER_CONST *iter)
static size_t	position (ITER_CONST const *iter)
static bool	empty (ITER_CONST const *iter)
static ITER_CONST	get_iter_const (SELF const *self)

Macro Definition Documentation

EQ

#define EQ   derive_c_parameter_eq

Definition at line 43 of file template.h.

HASH

#define HASH   derive_c_parameter_hash

Definition at line 36 of file template.h.

K

#define K   derive_c_parameter_key

Definition at line 18 of file template.h.

K_DELETE

#define K_DELETE   derive_c_parameter_key_delete

Definition at line 20 of file template.h.

KEY_ENTRY

#define KEY_ENTRY   NAME(SELF, key_entry)

Definition at line 54 of file template.h.

KV_PAIR

#define KV_PAIR   NAME(SELF, kv)

Definition at line 316 of file template.h.

KV_PAIR_CONST

#define KV_PAIR_CONST   NAME(SELF, kv_const)

Definition at line 389 of file template.h.

V

#define V   derive_c_parameter_value

Definition at line 28 of file template.h.

V_DELETE

#define V_DELETE   derive_c_parameter_value_delete

Definition at line 30 of file template.h.

Function Documentation

delete()

static void delete ( SELF * self )

static

Definition at line 371 of file template.h.

                                           {
    DEBUG_ASSERT(self);
    ITER iter = NAME(SELF, get_iter)(self);
 
    for (size_t i = 0; i < self->capacity; i++) {
        if (self->keys[i].present) {
            K_DELETE(&self->keys[i].key);
            V_DELETE(&self->values[i]);
        }
    }
 
    free(self->keys);
    free(self->values);
}

Here is the call graph for this function:

delete_entry()

static void delete_entry ( SELF * self, K key )

static

Definition at line 306 of file template.h.

                                                        {
    V value = NAME(SELF, remove)(self, key);
    V_DELETE(&value);
}

Here is the call graph for this function:

empty() [1/2]

static bool empty ( ITER const * iter )

static

Definition at line 353 of file template.h.

                                                {
    DEBUG_ASSERT(iter);
    return iter->index >= iter->map->capacity;
}

Here is the call graph for this function:

empty() [2/2]

static bool empty ( ITER_CONST const * iter )

static

Definition at line 426 of file template.h.

                                                            {
    DEBUG_ASSERT(iter);
    return iter->index >= iter->map->capacity;
}

Here is the call graph for this function:

extend_capacity_for()

static void extend_capacity_for ( SELF * self, size_t expected_items )

static

Definition at line 118 of file template.h.

                                                                               {
    DEBUG_ASSERT(self);
    size_t target_capacity = apply_capacity_policy(expected_items);
    if (target_capacity > self->capacity) {
        SELF new_map = NAME(SELF, new_with_capacity_for)(expected_items);
        for (size_t index = 0; index < self->capacity; index++) {
            KEY_ENTRY* entry = &self->keys[index];
            if (entry->present) {
                NAME(SELF, insert)(&new_map, entry->key, self->values[index]);
            }
        }
        free(self->keys);
        free(self->values);
        *self = new_map;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_iter()

static ITER get_iter ( SELF * self )

static

Definition at line 358 of file template.h.

                                             {
    DEBUG_ASSERT(self);
    size_t first_index = 0;
    while (first_index < self->capacity && !self->keys[first_index].present) {
        first_index++;
    }
    return (ITER){
        .map = self,
        .index = first_index,
        .pos = 0,
    };
}

Here is the call graph for this function:

get_iter_const()

static ITER_CONST get_iter_const ( SELF const * self )

static

Definition at line 431 of file template.h.

                                                               {
    DEBUG_ASSERT(self);
    size_t first_index = 0;
    while (first_index < self->capacity && !self->keys[first_index].present) {
        first_index++;
    }
    return (ITER_CONST){
        .map = self,
        .index = first_index,
        .pos = 0,
    };
}

Here is the call graph for this function:

insert()

static V * insert ( SELF * self, K key, V value )

static

Definition at line 188 of file template.h.

                                                         {
    V* value_ptr = NAME(SELF, try_insert)(self, key, value);
    ASSERT(value_ptr);
    return value_ptr;
}

Here is the call graph for this function:

new()

static SELF new ( )

static

Definition at line 89 of file template.h.

{ return NAME(SELF, new_with_capacity_for)(INITIAL_CAPACITY); }

Here is the call graph for this function:

new_with_capacity_for()

static SELF new_with_capacity_for ( size_t capacity )

static

Definition at line 71 of file template.h.

                                                               {
    ASSERT(capacity > 0);
    size_t real_capacity = apply_capacity_policy(capacity);
    ASSERT(real_capacity > 0);
    // JUSTIFY: calloc of keys
    //  - A cheap way to get all precense flags as zeroed (os & allocater supported get zeroed page)
    //  - for the values, we do not need this (no precense checks are done on values)
    KEY_ENTRY* keys = (KEY_ENTRY*)calloc(sizeof(KEY_ENTRY), real_capacity);
    V* values = (V*)malloc(sizeof(V) * real_capacity);
    ASSERT(keys && values);
    return (SELF){
        .capacity = real_capacity,
        .items = 0,
        .keys = keys,
        .values = values,
    };
}

Here is the call graph for this function:

next() [1/2]

static KV_PAIR next ( ITER * iter )

static

Definition at line 331 of file template.h.

                                            {
    DEBUG_ASSERT(iter);
    if (iter->index < iter->map->capacity) {
        KV_PAIR ret_val = {.key = &iter->map->keys[iter->index].key,
                           .value = &iter->map->values[iter->index]};
        iter->pos++;
        iter->index++;
        while (iter->index < iter->map->capacity && !iter->map->keys[iter->index].present) {
            iter->index++;
        }
 
        return ret_val;
    } else {
        return (KV_PAIR){.key = NULL, .value = NULL};
    }
}

Here is the call graph for this function:

next() [2/2]

static KV_PAIR_CONST next ( ITER_CONST * iter )

static

Definition at line 404 of file template.h.

                                                              {
    DEBUG_ASSERT(iter);
    if (iter->index < iter->map->capacity) {
        KV_PAIR_CONST ret_val = {.key = &iter->map->keys[iter->index].key,
                                 .value = &iter->map->values[iter->index]};
        iter->pos++;
        iter->index++;
        while (iter->index < iter->map->capacity && !iter->map->keys[iter->index].present) {
            iter->index++;
        }
 
        return ret_val;
    } else {
        return (KV_PAIR_CONST){.key = NULL, .value = NULL};
    }
}

Here is the call graph for this function:

position() [1/2]

static size_t position ( ITER const * iter )

static

Definition at line 348 of file template.h.

                                                     {
    DEBUG_ASSERT(iter);
    return iter->pos;
}

Here is the call graph for this function:

position() [2/2]

static size_t position ( ITER_CONST const * iter )

static

Definition at line 421 of file template.h.

                                                                 {
    DEBUG_ASSERT(iter);
    return iter->pos;
}

Here is the call graph for this function:

read()

static V const * read ( SELF const * self, K key )

static

Definition at line 238 of file template.h.

                                                          {
    V const* value = NAME(SELF, try_read)(self, key);
    ASSERT(value);
    return value;
}

Here is the call graph for this function:

remove()

static V remove ( SELF * self, K key )

static

Definition at line 300 of file template.h.

                                               {
    V value;
    ASSERT(NAME(SELF, try_remove)(self, key, &value));
    return value;
}

Here is the call graph for this function:

shallow_clone()

static SELF shallow_clone ( SELF const * self )

static

Definition at line 91 of file template.h.

                                                        {
    DEBUG_ASSERT(self);
 
    // JUSTIFY: Naive copy
    //           - We could resize (potentially a smaller map) and rehash
    //           - Not confident it would be any better than just a copy.
    // JUSTIFY: Individually copy keys
    //           - Many entries are zeroed, no need to copy uninit data
 
    KEY_ENTRY* keys = (KEY_ENTRY*)calloc(sizeof(KEY_ENTRY), self->capacity);
    V* values = (V*)malloc(sizeof(V) * self->capacity);
    ASSERT(keys && values);
 
    for (size_t i = 0; i < self->capacity; i++) {
        if (self->keys[i].present) {
            keys[i] = self->keys[i];
            values[i] = self->values[i];
        }
    }
 
    return (SELF){.capacity = self->capacity, .items = self->items, .keys = keys, .values = values};
}

Here is the call graph for this function:

size()

static size_t size ( SELF const * self )

static

Definition at line 311 of file template.h.

                                                 {
    DEBUG_ASSERT(self);
    return self->items;
}

Here is the call graph for this function:

try_insert()

static V * try_insert ( SELF * self, K key, V value )

static

Definition at line 135 of file template.h.

                                                             {
    DEBUG_ASSERT(self);
    if (apply_capacity_policy(self->items) > self->capacity / 2) {
        NAME(SELF, extend_capacity_for)(self, self->items * 2);
    }
 
    uint16_t distance_from_desired = 0;
    size_t hash = HASH(&key);
    size_t index = modulus_capacity(hash, self->capacity);
    V* placed_entry = NULL;
    for (;;) {
        KEY_ENTRY* entry = &self->keys[index];
        DEBUG_ASSERT(distance_from_desired < self->capacity);
 
        if (entry->present) {
            if (EQ(&entry->key, &key)) {
                return NULL;
            }
 
            if (entry->distance_from_desired < distance_from_desired) {
                K switch_key = entry->key;
                uint16_t switch_distance_from_desired = entry->distance_from_desired;
                V switch_value = self->values[index];
 
                entry->key = key;
                entry->distance_from_desired = distance_from_desired;
                self->values[index] = value;
 
                key = switch_key;
                distance_from_desired = switch_distance_from_desired;
                value = switch_value;
 
                if (!placed_entry) {
                    placed_entry = &self->values[index];
                }
            }
 
            distance_from_desired++;
            index = modulus_capacity(index + 1, self->capacity);
        } else {
            entry->present = true;
            entry->distance_from_desired = distance_from_desired;
            entry->key = key;
            self->values[index] = value;
            if (!placed_entry) {
                placed_entry = &self->values[index];
            }
            self->items++;
            return placed_entry;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

try_read()

static V const * try_read ( SELF const * self, K key )

static

Definition at line 219 of file template.h.

                                                              {
    DEBUG_ASSERT(self);
    size_t hash = HASH(&key);
    size_t index = modulus_capacity(hash, self->capacity);
 
    for (;;) {
        KEY_ENTRY* entry = &self->keys[index];
        if (entry->present) {
            if (EQ(&entry->key, &key)) {
                return &self->values[index];
            } else {
                index = modulus_capacity(index + 1, self->capacity);
            }
        } else {
            return NULL;
        }
    }
}

Here is the call graph for this function:

try_remove()

static bool try_remove ( SELF * self, K key, V * destination )

static

Definition at line 244 of file template.h.

                                                                      {
    DEBUG_ASSERT(self);
    size_t hash = HASH(&key);
    size_t index = modulus_capacity(hash, self->capacity);
 
    for (;;) {
        KEY_ENTRY* entry = &self->keys[index];
        if (entry->present) {
            if (EQ(&entry->key, &key)) {
                self->items--;
 
                *destination = self->values[index];
                K_DELETE(&entry->key);
 
                // NOTE: For robin hood hashing, we need probe chains to be unbroken
                //        - Need to find the entries that might use this chain (
                //          distance_to_desired > 0 until the next not-present or
                //          distance_to_desired=0 slot)
                //        hence we shift entries the left (being careful with modulus index)
 
                size_t free_index = index;
                KEY_ENTRY* free_entry = entry;
 
                size_t check_index = modulus_capacity(free_index + 1, self->capacity);
                KEY_ENTRY* check_entry = &self->keys[check_index];
 
                while (check_entry->present && check_entry->distance_from_desired > 0) {
                    free_entry->key = check_entry->key;
                    free_entry->distance_from_desired = check_entry->distance_from_desired - 1;
                    self->values[free_index] = self->values[check_index];
 
                    free_index = check_index;
                    free_entry = check_entry;
 
                    check_index = modulus_capacity(free_index + 1, self->capacity);
                    check_entry = &self->keys[check_index];
                }
 
                // JUSTIFY: Only setting free entry to false
                //           - We remove, then shift down an index
                //           - The removed entry already has the flag set
                //           - the free entry was the last one removed/moved down an index, so it
                //             should be false.
 
                free_entry->present = false;
 
                return true;
            } else {
                index = modulus_capacity(index + 1, self->capacity);
            }
        } else {
            return false;
        }
    }
}

Here is the call graph for this function:

try_write()

static V * try_write ( SELF * self, K key )

static

Definition at line 194 of file template.h.

                                                   {
    DEBUG_ASSERT(self);
    size_t hash = HASH(&key);
    size_t index = modulus_capacity(hash, self->capacity);
 
    for (;;) {
        KEY_ENTRY* entry = &self->keys[index];
        if (entry->present) {
            if (EQ(&entry->key, &key)) {
                return &self->values[index];
            } else {
                index = modulus_capacity(index + 1, self->capacity);
            }
        } else {
            return NULL;
        }
    }
}

Here is the call graph for this function:

write()

static V * write ( SELF * self, K key )

static

Definition at line 213 of file template.h.

                                               {
    V* value = NAME(SELF, try_write)(self, key);
    ASSERT(value);
    return value;
}

Here is the call graph for this function: