Merge pull request #141 from OlehKniaziev/73-free-server-connections

Free server connections

Author: OlehKniaziev

src/Core/ok.hpp

@@ -71,57 +71,67 @@
 #define OK_ASSERT(x) do { \
     if (!(x)) { \
         OK_LOG_ERROR("%s:%d: Assertion failed: %s\n", __FILE__, __LINE__, #x); \
+        /* @Portability */ \
         __builtin_trap(); \
     } \
 } while(0)
 #endif // OK_ASSERT
 #else
 #define OK_ASSERT(x)
-#endif // OK_DEBUG
+#endif // OK_STRIP_ASSERTIONS
 
+// NOTE(oleh): All of thsse are pretty much duplicates.
 #define OK_VERIFY(x) do { \
     if (!(x)) { \
         OK_LOG_ERROR("%s:%d: Verification failed: %s\n", __FILE__, __LINE__, #x); \
+        /* @Portability */ \
         __builtin_trap(); \
     } \
 } while(0)
 
 #define OK_TODO() do { \
     OK_LOG_ERROR("%s:%d: TODO: Not implemented\n", __FILE__, __LINE__); \
+        /* @Portability */ \
     __builtin_trap(); \
 } while (0)
 
 #define OK_TODO_MSG(msg) do { \
     OK_LOG_ERROR("%s:%d: TODO: " msg "\n", __FILE__, __LINE__); \
+        /* @Portability */ \
     __builtin_trap(); \
 } while (0)
 
 #define OK_TODO_MSG_FMT(fmt, ...) do { \
     OK_LOG_ERROR("%s:%d: TODO: " fmt "\n", __FILE__, __LINE__, __VA_ARGS__); \
+        /* @Portability */ \
     __builtin_trap(); \
 } while (0)
 
 #define OK_UNUSED(arg) (void)(arg)
 
 #define OK_UNREACHABLE() do { \
     OK_LOG_ERROR("%s:%d: Encountered unreachable code\n", __FILE__, __LINE__); \
+        /* @Portability */ \
     __builtin_trap(); \
 } while (0)
 
 #define OK_PANIC(msg) do { \
     OK_LOG_ERROR("%s:%d: PROGRAM PANICKED: %s\n", __FILE__, __LINE__, (msg)); \
+        /* @Portability */ \
     __builtin_trap(); \
 } while (0)
 
 #define OK_PANIC_FMT(fmt, ...) do { \
     OK_LOG_ERROR("%s:%d: PROGRAM PANICKED: " fmt "\n", __FILE__, __LINE__, __VA_ARGS__); \
+        /* @Portability */ \
     __builtin_trap(); \
 } while (0)
 
 #define OK_ARR_LEN(xs) (sizeof((xs)) / sizeof((xs)[0]))
 
 #if defined(__unix__) || defined(__unix) || defined(__APPLE__)
 
+// NOTE(oleh): No need for values here.
 #define OK_UNIX 1
 #define OK_WINDOWS 0
 
@@ -130,10 +140,12 @@
 #include <unistd.h>
 #include <spawn.h>
 
+// @Customization
 #define OK_ALLOC_PAGE(sz) (mmap(NULL, (sz), PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0))
 #define OK_DEALLOC_PAGE(page, size) (munmap((page), (size)))
 #define OK_ALLOC_SMOL(sz) (sbrk((sz)))
 
+// @Customization
 #define OK_PAGE_SIZE 4096
 #define OK_PAGE_ALIGN OK_PAGE_SIZE
 
@@ -151,15 +163,18 @@
 #undef max
 #undef min
 
+// @Customization
 #define OK_PAGE_SIZE 4096
 #define OK_PAGE_ALIGN (64 * 1024)
 
+// @Customization
 #define OK_ALLOC_PAGE(sz) (VirtualAlloc(nullptr, (sz), MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE))
 #define OK_DEALLOC_PAGE(page, size) (VirtualFree((page), 0, MEM_RELEASE))
 #define OK_ALLOC_SMOL(sz) (HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (sz)))
 
 #elif defined(__wasm__)
 
+// NOTE(oleh): Once again, these should be empty defs.
 #define OK_UNIX 0
 #define OK_WINDOWS 0
 #define OK_WASM 1
@@ -175,7 +190,7 @@
 #elif SIZE_MAX == UINT64_MAX
 #  define OK_BITS_64
 #else
-#  error "Could not determine architecture bit size"
+#  error "Could not determine word size"
 #endif // word size check
 
 using U8 = uint8_t;
@@ -222,6 +237,7 @@ namespace ok {
 #       define OK_PAGE_ALIGN OK_PAGE_SIZE
 #   endif // OK_PAGE_ALIGN
 
+// NOTE(oleh): This should be optional.
 #   ifndef OK_VSNPRINTF
 #       error "you have to define `OK_VSNPRINTF` when compiling with `OK_NO_STDLIB`"
 #   endif // OK_VSNPRINTF
@@ -310,6 +326,7 @@ struct Allocator {
     Slice<T> alloc_slice(UZ);
 };
 
+// NOTE(oleh): This should be removed in favor of temp allocator handles.
 Allocator *temp_allocator();
 
 struct FixedBufferAllocator : public Allocator {
@@ -378,6 +395,7 @@ struct ArenaAllocator : public Allocator {
     }
 
     inline void free() {
+        // @Leak
         for (Region* r = head; r != nullptr; r = r->next) OK_DEALLOC_PAGE(head->data, head->size);
     }
 
@@ -576,6 +594,7 @@ Slice<T> Allocator::alloc_slice(UZ count) {
     return Slice<T>{ptr, count};
 }
 
+// NOTE(oleh): Just remove this. It's a mess.
 template <typename T>
 struct MultiListBase {
     T *items;
@@ -750,6 +769,7 @@ struct String;
 #define OK_SV_FMT "%.*s"
 #define OK_SV_ARG(sv) (int)(sv).count, reinterpret_cast<const char*>((sv).data)
 
+// NOTE(oleh): This needs more methods.
 template <typename Self, typename Char>
 struct StringBase : public ArrayBase<Self, Char> {
     inline bool starts_with(const char* prefix) const {
@@ -1062,20 +1082,23 @@ struct Pair {
     B b;
 };
 
+// NOTE(oleh): We need more hash implementations, or at least a better default.
 namespace hash {
 U64 fnv1(StringView);
 };
 
 template <typename T>
 struct Hash {
     static U64 hash(const T& value) {
+        // NOTE(oleh): Just make this a function, not a method.
         return value.ok_hash_value();
     }
 };
 
 template <typename T>
 struct HashPtr {
     HashPtr(const T* v) : value{v} {}
+    // @Dead
     HashPtr(T* v) : value{v} {}
 
     inline bool operator ==(const T* ptr) const {
@@ -1085,7 +1108,10 @@ struct HashPtr {
     const T* value;
 };
 
+// NOTE(oleh): Remove these all in favor of `ok_hash_value`.
+
 // Default hash implementations
+// NOTE(oleh): Is this even needed?
 template <typename T>
 struct Hash<HashPtr<T>> {
     static U64 hash(const HashPtr<T>& ptr) {
@@ -1161,14 +1187,27 @@ struct Table {
 
     void put(const TKey& key, const TValue& value);
 
-    Optional<TValue> get(const TKey& key);
+    // NOTE(oleh): Not sure if we need the `get_ref` methods.
+    // Also not sure if we shouldn't just keep the template overloads?
+    Optional<TValue> get(const TKey& key) const;
+
     template <typename K>
-    Optional<TValue> get(const K& key);
+    Optional<TValue> get(const K& key) const;
+
+    Optional<TValue&> get_ref(const TKey& key);
+    Optional<const TValue&> get_ref(const TKey& key) const;
+
+    template <typename K>
+    Optional<TValue&> get_ref(const K& key);
+    template <typename K>
+    Optional<const TValue&> get_ref(const K& key) const;
 
     bool has(const TKey& key) const;
     template <typename K>
     bool has(const K& key) const;
 
+    bool remove(const TKey&);
+
     static constexpr UZ DEFAULT_CAPACITY = 47;
 
     inline void clear() {
@@ -1200,7 +1239,7 @@ struct Table {
         allocator->dealloc(keys, capacity);
         allocator->dealloc(values, capacity);
 
-        memset(this, 0, sizeof(this));
+        memset(this, 0, sizeof(*this));
     }
 
     TKey* keys;
@@ -1478,7 +1517,7 @@ void Table<K, V>::put(const K& key, const V& value) {
 }
 
 template <typename K, typename V>
-Optional<V> Table<K, V>::get(const K& key) {
+Optional<V> Table<K, V>::get(const K& key) const {
     U64 idx = Hash<K>::hash(key) % capacity;
     U64 initial_idx = idx;
 
@@ -1495,7 +1534,7 @@ Optional<V> Table<K, V>::get(const K& key) {
 
 template <typename TKey, typename TValue>
 template <typename K>
-Optional<TValue> Table<TKey, TValue>::get(const K& key) {
+Optional<TValue> Table<TKey, TValue>::get(const K& key) const {
     U64 idx = Hash<K>::hash(key) % capacity;
     U64 initial_idx = idx;
 
@@ -1510,6 +1549,72 @@ Optional<TValue> Table<TKey, TValue>::get(const K& key) {
     return Optional<TValue>::empty();
 }
 
+template <typename K, typename V>
+Optional<V&> Table<K, V>::get_ref(const K& key) {
+    U64 idx = Hash<K>::hash(key) % capacity;
+    U64 initial_idx = idx;
+
+    do {
+        if (OK_TAB_IS_OCCUPIED(meta[idx]) && keys[idx] == key) {
+            return values[idx];
+        }
+
+        idx = (idx + 1) % capacity;
+    } while (idx != initial_idx);
+
+    return Optional<V&>::empty();
+}
+
+template <typename K, typename V>
+Optional<const V&> Table<K, V>::get_ref(const K& key) const {
+    U64 idx = Hash<K>::hash(key) % capacity;
+    U64 initial_idx = idx;
+
+    do {
+        if (OK_TAB_IS_OCCUPIED(meta[idx]) && keys[idx] == key) {
+            return values[idx];
+        }
+
+        idx = (idx + 1) % capacity;
+    } while (idx != initial_idx);
+
+    return Optional<const V&>::empty();
+}
+
+template <typename TKey, typename TValue>
+template <typename K>
+Optional<TValue&> Table<TKey, TValue>::get_ref(const K& key) {
+    U64 idx = Hash<K>::hash(key) % capacity;
+    U64 initial_idx = idx;
+
+    do {
+        if (OK_TAB_IS_OCCUPIED(meta[idx]) && keys[idx] == key) {
+            return values[idx];
+        }
+
+        idx = (idx + 1) % capacity;
+    } while (idx != initial_idx);
+
+    return Optional<TValue&>::empty();
+}
+
+template <typename TKey, typename TValue>
+template <typename K>
+Optional<const TValue&> Table<TKey, TValue>::get_ref(const K& key) const {
+    U64 idx = Hash<K>::hash(key) % capacity;
+    U64 initial_idx = idx;
+
+    do {
+        if (OK_TAB_IS_OCCUPIED(meta[idx]) && keys[idx] == key) {
+            return values[idx];
+        }
+
+        idx = (idx + 1) % capacity;
+    } while (idx != initial_idx);
+
+    return Optional<const TValue&>::empty();
+}
+
 template <typename K, typename V>
 bool Table<K, V>::has(const K& key) const {
     U64 idx = Hash<K>::hash(key) % capacity;
@@ -1526,7 +1631,6 @@ bool Table<K, V>::has(const K& key) const {
     return false;
 }
 
-
 template <typename TKey, typename TValue>
 template <typename K>
 bool Table<TKey, TValue>::has(const K& key) const {
@@ -1544,6 +1648,16 @@ bool Table<TKey, TValue>::has(const K& key) const {
     return false;
 }
 
+// NOTE(oleh): Should we call destructors here?
+template <typename TKey, typename TValue>
+bool Table<TKey, TValue>::remove(const TKey& key) {
+    U64 idx = Hash<TKey>::hash(key) % capacity;
+    bool result = OK_TAB_IS_OCCUPIED(meta[idx]);
+    if (result) --count;
+    meta[idx] &= ~OK_TAB_META_OCCUPIED;
+    return result;
+}
+
 // SET IMPLEMENTATION
 template <typename T>
 Set<T> Set<T>::alloc(Allocator* a, UZ capacity) {
@@ -1715,6 +1829,7 @@ struct File {
 };
 
 // Procedures.
+// NOTE(oleh): These should accept format strings like `std::print`.
 void println(const char*);
 void println(StringView);
 void println(String);