Initial Implementation of DenseUniqueValueMap

DenseUniqueValueMap is used to replace the OneToManyDict that is being
used in `ClientManager`. Given that `ClientManager` is the only user of
the original data structure, this commit aims to provide an alternative
to OneToManyDict that is less generic but more compact in terms of RAM
usage.

DenseUniqueValueMap does not provide all the APIs that OneToManyDict
provides. Instead, it provides only the API that is being used by the
user (aka. `ClientManager`). There are 4 APIs in total.

Current implementation of DenseUniqueValueMap is not final. There are
many things missing, for example proper `typedef`s are needed.

NOTE: There is another API that is being used in `ClientManager`. That
is `self._client_to_task_ids.get_values(client)`. The caller to this
API, however, is not being used in scaler. Perhaps it should be remove
later.

Signed-off-by: gxu <[email protected]>

Author: gxu

scaler/utility/DenseUniqueValueMap.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <cstdlib>
+#include <map>
+#include <vector>
+
+struct DenseUniqueValueMap {
+    using key_type      = int;     // IRL we store client here
+    using value_type    = size_t;  // IRL we store taskId here
+    using iterator_type = std::map<key_type, size_t>::iterator;
+    std::map<value_type, iterator_type> valueToKeyIter;
+    // Bunch of keys(clients), and number of tasks belongs to it
+    std::map<key_type, size_t> keyToRefCount;
+
+    key_type get_key(value_type value) {
+        if (!valueToKeyIter.contains(value)) {
+            // TODO: handle error more gracefully
+            exit(1);
+        }
+        auto keyIter = valueToKeyIter[value];
+        return keyIter->first;
+    }
+
+    void add(key_type key, value_type value) {
+        auto it = valueToKeyIter.find(value);
+        if (it != valueToKeyIter.end()) {
+            if (it->first != key) {
+                // TODO: handle error more gracefully
+                exit(1);
+            } else {
+                return;
+            }
+        }
+
+        auto [kIter, _] = keyToRefCount.insert_or_assign(key, ++keyToRefCount[key]);
+        it->second      = kIter;
+    }
+
+    key_type removeValue(value_type value) {
+        auto it = valueToKeyIter.find(value);
+        if (it == valueToKeyIter.end()) {
+            // TODO: handle error more gracefully
+            exit(1);
+        }
+        auto keysMapIter = it->second;
+        valueToKeyIter.erase(it);
+        auto key = keysMapIter->first;
+        if (keysMapIter->second == 1) {
+            keyToRefCount.erase(keysMapIter);
+        }
+        return key;
+    }
+
+    auto& getKeysRef() { return keyToRefCount; }
+};