Initial commit

C#/CodeWalker.Core/Utils/Cache.cs

@@ -0,0 +1,153 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CodeWalker
+{
+    public class Cache<TKey, TVal> where TVal : Cacheable<TKey>
+    {
+        public long MaxMemoryUsage = 536870912; //512mb
+        public long CurrentMemoryUsage = 0;
+        public double CacheTime = 10.0; //seconds to keep something that's not used
+        public DateTime CurrentTime = DateTime.Now;
+
+        private LinkedList<TVal> loadedList = new LinkedList<TVal>();
+        private Dictionary<TKey, LinkedListNode<TVal>> loadedListDict = new Dictionary<TKey, LinkedListNode<TVal>>();
+
+        public int Count
+        {
+            get
+            {
+                return loadedList.Count;
+            }
+        }
+
+        public Cache()
+        {
+        }
+        public Cache(long maxMemoryUsage, double cacheTime)
+        {
+            MaxMemoryUsage = maxMemoryUsage;
+            CacheTime = cacheTime;
+        }
+
+        public void BeginFrame()
+        {
+            CurrentTime = DateTime.Now;
+            Compact();
+        }
+
+        public TVal TryGet(TKey key)
+        {
+            LinkedListNode<TVal> lln = null;
+            if (loadedListDict.TryGetValue(key, out lln))
+            {
+                loadedList.Remove(lln);
+                loadedList.AddLast(lln);
+                lln.Value.LastUseTime = CurrentTime;
+            }
+            return (lln != null) ? lln.Value : null;
+        }
+        public bool TryAdd(TKey key, TVal item)
+        {
+            if (item.MemoryUsage == 0)
+            {
+            }
+            item.Key = key;
+            if (CanAdd())
+            {
+                var lln = loadedList.AddLast(item);
+                loadedListDict.Add(key, lln);
+                Interlocked.Add(ref CurrentMemoryUsage, item.MemoryUsage);
+                return true;
+            }
+            else
+            {
+                //cache full, check the front of the list for oldest..
+                var oldlln = loadedList.First;
+                var cachetime = CacheTime;
+                int iter = 0, maxiter = 2;
+                while (!CanAdd() && (iter<maxiter))
+                {
+                    while ((!CanAdd()) && (oldlln != null) && ((CurrentTime - oldlln.Value.LastUseTime).TotalSeconds > cachetime))
+                    {
+                        Interlocked.Add(ref CurrentMemoryUsage, -oldlln.Value.MemoryUsage);
+                        loadedListDict.Remove(oldlln.Value.Key);
+                        loadedList.Remove(oldlln); //gc should free up memory later..
+                        oldlln.Value = null;
+                        oldlln = null;
+                        //GC.Collect();
+                        oldlln = loadedList.First;
+                    }
+                    cachetime *= 0.5;
+                    iter++;
+                }
+                if (CanAdd()) //see if there's enough memory now...
+                {
+                    var newlln = loadedList.AddLast(item);
+                    loadedListDict.Add(key, newlln);
+                    Interlocked.Add(ref CurrentMemoryUsage, item.MemoryUsage);
+                    return true;
+                }
+                else
+                {
+                    //really shouldn't get here, but it's possible under stress.
+                }
+            }
+            return false;
+        }
+
+        public bool CanAdd()
+        {
+            return Interlocked.Read(ref CurrentMemoryUsage) < MaxMemoryUsage;
+        }
+
+
+        public void Clear()
+        {
+            loadedList.Clear();
+            loadedListDict.Clear();
+            CurrentMemoryUsage = 0;
+        }
+
+        public void Remove(TKey key)
+        {
+            LinkedListNode<TVal> n;
+            if (loadedListDict.TryGetValue(key, out n))
+            {
+                loadedListDict.Remove(key);
+                loadedList.Remove(n);
+                Interlocked.Add(ref CurrentMemoryUsage, -n.Value.MemoryUsage);
+            }
+        }
+
+
+        public void Compact()
+        {
+            var oldlln = loadedList.First;
+            while (oldlln != null)
+            {
+                if ((CurrentTime - oldlln.Value.LastUseTime).TotalSeconds < CacheTime) break;
+                var nextln = oldlln.Next;
+                Interlocked.Add(ref CurrentMemoryUsage, -oldlln.Value.MemoryUsage);
+                loadedListDict.Remove(oldlln.Value.Key);
+                loadedList.Remove(oldlln); //gc should free up memory later..
+                oldlln.Value = null;
+                oldlln = nextln;
+            }
+        }
+
+
+    }
+
+    public abstract class Cacheable<TKey>
+    {
+        public TKey Key;
+        public DateTime LastUseTime;
+        public long MemoryUsage;
+    }
+
+}