Consistant hash & LRU Cache

Author: justcoding121

Advanced.Algorithms.Tests/Advanced.Algorithms.Tests.csproj

@@ -125,6 +125,8 @@
     <Compile Include="DataStructures\Tree\TestHelpers\BinarySearchTreeTester.cs" />
     <Compile Include="DataStructures\Tree\Tree_Tests.cs" />
     <Compile Include="DataStructures\Tree\BinaryTree_Tests.cs" />
+    <Compile Include="DistributedSystems\ConsistentHash_Tests.cs" />
+    <Compile Include="DistributedSystems\LRUCache_Tests.cs" />
     <Compile Include="Geometry\PointRotation_Tests.cs" />
     <Compile Include="GraphAlgorithms\ShortestPath\TravellingSalesman_Tests.cs" />
     <Compile Include="Miscellaneous\MatrixMultiplication_Tests.cs" />

Advanced.Algorithms.Tests/DistributedSystems/ConsistentHash_Tests.cs

@@ -0,0 +1,43 @@
+using Advanced.Algorithms.DistributedSystems;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+
+namespace Advanced.Algorithms.Tests.DistributedSystems
+{
+    [TestClass]
+    public class ConsistentHash_Tests
+    {
+
+        [TestMethod]
+        public void ConsistantHash_Smoke_Test()
+        {
+            var hash = new ConsistentHash<int>();
+
+            hash.AddNode(15);
+            hash.AddNode(25);
+            hash.AddNode(172);
+
+            for (int i = 200; i < 300; i++)
+            {
+                hash.AddNode(i);
+            }
+
+            hash.RemoveNode(15);
+            hash.RemoveNode(172);
+            hash.RemoveNode(25);
+
+            var rnd = new Random();
+            for (int i = 0; i < 1000; i++)
+            {
+                Assert.AreNotEqual(15, hash.GetNode(rnd.Next().ToString()));
+                Assert.AreNotEqual(25, hash.GetNode(rnd.Next().ToString()));
+                Assert.AreNotEqual(172, hash.GetNode(rnd.Next().ToString()));
+
+                var t = hash.GetNode(rnd.Next().ToString());
+                Assert.IsTrue(t >= 200 && t < 300);
+            }
+
+        }
+
+    }
+}

Advanced.Algorithms.Tests/DistributedSystems/LRUCache_Tests.cs

@@ -0,0 +1,30 @@
+using Advanced.Algorithms.DistributedSystems;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+
+namespace Advanced.Algorithms.Tests.DistributedSystems
+{
+    [TestClass]
+    public class LRUCache_Tests
+    {
+
+        [TestMethod]
+        public void LRUCache_Smoke_Test()
+        {
+            var cache = new LRUCache<int,int>(2);
+
+            cache.Put(1, 1);
+            cache.Put(2, 2);
+            Assert.AreEqual(1, cache.Get(1));
+
+            cache.Put(3, 3);
+            Assert.AreEqual(0, cache.Get(2));
+
+            cache.Put(4, 4);
+            Assert.AreEqual(0, cache.Get(1));
+            Assert.AreEqual(3, cache.Get(3));
+            Assert.AreEqual(4, cache.Get(4));
+        }
+
+    }
+}

Advanced.Algorithms/DistributedSystems/ConsistentHash.cs

@@ -0,0 +1,192 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Advanced.Algorithms.DistributedSystems
+{
+
+    /// <summary>
+    /// A consistant hash implementation with MurmurHash
+    /// Adapted from https://github.com/wsq003/consistent-hash/blob/master/ConsistentHash.cs
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public class ConsistentHash<T>
+    {
+        SortedDictionary<int, T> circle = new SortedDictionary<int, T>();
+        int[] circleKeys;
+        int replicas;
+
+        public ConsistentHash()
+            : this(new List<T>(), 100) { }
+
+        public ConsistentHash(IEnumerable<T> nodes, int replicas)
+        {
+            this.replicas = replicas;
+            foreach (T node in nodes)
+            {
+                AddNode(node);
+            }
+        }
+
+        /// <summary>
+        /// Add a new bucket
+        /// </summary>
+        /// <param name="node"></param>
+        public void AddNode(T node)
+        {
+            for (int i = 0; i < replicas; i++)
+            {
+                int hash = getHashCode(node.GetHashCode().ToString() + i);
+                circle[hash] = node;
+            }
+
+            circleKeys = circle.Keys.ToArray();
+        }
+
+        /// <summary>
+        /// Get the bucket for the given Key
+        /// </summary>
+        /// <param name="key"></param>
+        /// <returns></returns>
+        public T GetNode(string key)
+        {
+            int hash = getHashCode(key);
+            int first = Next_ClockWise(circleKeys, hash);
+            return circle[circleKeys[first]];
+        }
+
+        /// <summary>
+        /// Remove a bucket from lookUp
+        /// </summary>
+        /// <param name="node"></param>
+        public void RemoveNode(T node)
+        {
+            for (int i = 0; i < replicas; i++)
+            {
+                int hash = getHashCode(node.GetHashCode().ToString() + i);
+                if (!circle.Remove(hash))
+                {
+                    throw new Exception("Cannot remove a node that was never added.");
+                }
+            }
+
+            circleKeys = circle.Keys.ToArray();
+        }
+
+
+        /// <summary>
+        /// Move clockwise until we find a bucket with Key >= hashCode
+        /// </summary>
+        /// <param name="keys"></param>
+        /// <param name="hashCode"></param>
+        /// <returns>Returns the index of bucket</returns>
+        int Next_ClockWise(int[] keys, int hashCode)
+        {
+            int begin = 0;
+            int end = keys.Length - 1;
+
+            if (keys[end] < hashCode || keys[0] > hashCode)
+            {
+                return 0;
+            }
+
+            //do a binary search
+            int mid = begin;
+            while (end - begin > 1)
+            {
+                mid = (end + begin) / 2;
+                if (keys[mid] >= hashCode)
+                {
+                    end = mid;
+                }
+                else
+                {
+                    begin = mid;
+                }
+            }
+
+            return end;
+        }
+
+
+        private static int getHashCode(string key)
+        {
+            return (int)MurmurHash2.Hash(Encoding.Unicode.GetBytes(key));
+        }
+
+    }
+
+    internal class MurmurHash2
+    {
+        internal static UInt32 Hash(Byte[] data)
+        {
+            return Hash(data, 0xc58f1a7b);
+        }
+        const UInt32 m = 0x5bd1e995;
+        const Int32 r = 24;
+
+        [StructLayout(LayoutKind.Explicit)]
+        struct BytetoUInt32Converter
+        {
+            [FieldOffset(0)]
+            public Byte[] Bytes;
+
+            [FieldOffset(0)]
+            public UInt32[] UInts;
+        }
+
+        internal static UInt32 Hash(Byte[] data, UInt32 seed)
+        {
+            Int32 length = data.Length;
+            if (length == 0)
+                return 0;
+            UInt32 h = seed ^ (UInt32)length;
+            Int32 currentIndex = 0;
+            // array will be length of Bytes but contains Uints
+            // therefore the currentIndex will jump with +1 while length will jump with +4
+            UInt32[] hackArray = new BytetoUInt32Converter { Bytes = data }.UInts;
+            while (length >= 4)
+            {
+                UInt32 k = hackArray[currentIndex++];
+                k *= m;
+                k ^= k >> r;
+                k *= m;
+
+                h *= m;
+                h ^= k;
+                length -= 4;
+            }
+            currentIndex *= 4; // fix the length
+            switch (length)
+            {
+                case 3:
+                    h ^= (UInt16)(data[currentIndex++] | data[currentIndex++] << 8);
+                    h ^= (UInt32)data[currentIndex] << 16;
+                    h *= m;
+                    break;
+                case 2:
+                    h ^= (UInt16)(data[currentIndex++] | data[currentIndex] << 8);
+                    h *= m;
+                    break;
+                case 1:
+                    h ^= data[currentIndex];
+                    h *= m;
+                    break;
+                default:
+                    break;
+            }
+
+            // Do a few final mixes of the hash to ensure the last few
+            // bytes are well-incorporated.
+
+            h ^= h >> 13;
+            h *= m;
+            h ^= h >> 15;
+
+            return h;
+        }
+    }
+}
+

Advanced.Algorithms/DistributedSystems/LRUCache.cs

@@ -0,0 +1,67 @@
+using Advanced.Algorithms.DataStructures;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+
+namespace Advanced.Algorithms.DistributedSystems
+{
+    public class LRUCache<K, V>
+    {
+        private int capacity;
+
+        private Dictionary<K, DoublyLinkedListNode<Tuple<K, V>>> lookUp
+            = new Dictionary<K, DoublyLinkedListNode<Tuple<K, V>>>();
+
+        private DoublyLinkedList<Tuple<K, V>> dll = new DoublyLinkedList<Tuple<K, V>>();
+
+        public LRUCache(int capacity)
+        {
+            if (capacity <= 0)
+            {
+                throw new Exception("Capacity must be a positive integer.");
+            }
+            this.capacity = capacity;
+        }
+
+        /// <summary>
+        /// O(1) time complexity
+        /// </summary>
+        /// <param name="key"></param>
+        /// <returns></returns>
+        public V Get(K key)
+        {
+            if (!lookUp.ContainsKey(key))
+                return default(V);
+
+            var node = lookUp[key];
+
+            //move lately used node to beginning of ddl 
+            dll.Delete(node);
+            var newNode = dll.InsertFirst(node.Data);
+            lookUp[key] = newNode;
+
+            return node.Data.Item2;
+        }
+
+        /// <summary>
+        /// O(1) time complexity
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="value"></param>
+        public void Put(K key, V value)
+        {
+            //evict last node of ddl if capacity overflows
+            if (lookUp.Count == capacity)
+            {
+                var nodeToEvict = dll.Last();
+                lookUp.Remove(nodeToEvict.Item1);
+                dll.DeleteLast();
+            }
+
+            //insert
+            var newNode = dll.InsertFirst(new Tuple<K, V>(key, value));
+            lookUp.Add(key, newNode);
+        }
+    }
+}

README.md

@@ -244,6 +244,8 @@ Note: On a decent desktop, in given implementations here for +ive random input i
 ## Distributed Systems
 
 - [X] Circular Queue (Ring Buffer) ([Implementation](https://github.com/justcoding121/Advanced-Algorithms/tree/develop/Advanced.Algorithms/DistributedSystems/CircularQueue.cs) | [Tests](https://github.com/justcoding121/Advanced-Algorithms/tree/develop/Advanced.Algorithms.Tests/DistributedSystems/CircularQueue_Tests.cs))
+- [X] Consistant Hash ([Implementation](https://github.com/justcoding121/Advanced-Algorithms/tree/develop/Advanced.Algorithms/DistributedSystems/ConsistantHash.cs) | [Tests](https://github.com/justcoding121/Advanced-Algorithms/tree/develop/Advanced.Algorithms.Tests/DistributedSystems/ConsistantHash_Tests.cs))
+- [X] LRU Cache ([Implementation](https://github.com/justcoding121/Advanced-Algorithms/tree/develop/Advanced.Algorithms/DistributedSystems/LRUCache.cs) | [Tests](https://github.com/justcoding121/Advanced-Algorithms/tree/develop/Advanced.Algorithms.Tests/DistributedSystems/LRUCache_Tests.cs))
 
 ## Numerical Methods