LIRS算法的近似实现

 从LIRS算法的描述来看，可以理解为两个LRU队列的组合，利用cold缓冲区来保护Hot缓冲区，提高了进入hot缓冲区的门槛，阻止hot缓冲区频繁地变化。为了验证LIRS算法的有效性，笔者自行开发了LRU算法及LIRS算法的c#实现。
 首先说明LRU算法的实现。
 采用带表头的单链表来存储数据节点，head指针指向表头，tail指针指向链表最后一个节点。数据节点则记录了每个缓存块的ID，加载状态，数据指针，next指针。另有unUsedSize变量存放未分配的缓存块数量。
 当用户访问命中时，将对应的数据节点移到队列尾部。当用户访问未命中时，若能分配新数据节点，则分配，否则从表头摘下一个数据节点，并卸载数据。更新得到的数据节点的信息，并加到队列尾部。
 最后，为了避免在查找数据节点时遍历整个链表，增加了Dictionary<ID,数据节点>的字典，利用其hash查找功能提高查找效率。
 再说明LIRS算法的实现。
 为了简化实现，将算法实现为多个逻辑LRU队列（可实现多级缓冲区），在物理实现上，仍采用带表头的单链表来存储数据节点。对于N级缓冲区的实现（原始的LIRS算法为2级），使用unUsedSize[N]数组存放每个缓冲区的未分配数量，使用head[N+1]存放缓冲区的头尾指针。这样head[0]、head[1]指示了第0块缓冲区的头尾，依次类推，head[N-1]、head[N]指示了第N-1块缓冲区的头尾。0号缓冲区是cold的缓冲区，N-1号则是最hot的。由于使用了多级缓冲区，数据节点也需要增加一个选择器selector，用于指示该节点属于哪个缓冲区。
 当用户访问未命中，分配新节点时，先检查N-1号缓冲区是否能分配新节点，若不能则依次向前检查。若分配了新节点，则直接加入相应缓冲区的尾部，否则就从0级缓冲区头部摘下一个节点来，更新节点信息后加入0级缓冲区尾部。
 当用户访问命中时，则将x级的节点提升到x+1级，并加到缓冲区尾部，x+1级的头部节点，则被移到x级缓冲区的尾部
 同样的，增加了Dictionary<ID,数据节点>字典，提高查找节点的效率。

 using System;
 using System.Linq;
 using System.Diagnostics;
 using System.Collections;
 using System.Collections.Generic;
 //using System.Collections.Concurrent;
 using WaveTang.Classes;
 public interface ICache<T,U>{
     //T=资源类型，U=资源ID类型
     T this[U id]{get;} //向cache申请使用资源，参数：id=资源ID，返回：资源
     Func<U,T> Loader{set;}//回调函数 要求访问者加载资源
     Action<U> UnLoader{set;}//回调函数 要求访问者卸载资源
 }
 [System.Security.Permissions.HostProtectionAttribute(Synchronization=true, ExternalThreading=true)]
 public class LRUCache<T,U>:ICache<T,U>,IDisposable  where U:IComparable<U>{
     Int32 _unUsedSize;//可用资源数量（缓冲区的块数）
     Node _head,_tail;//使用带表头的单向链表，_head指向表头，_tail指向表尾，新节点在表尾插入，老节点从表头处摘除，允许将某一个节点移动到表尾
     Dictionary<U,Node> _dict;//维护U与Node之间的对照，以提供更高速的Find功能.（ID与Node的前一个节点对应）

     ////////test使用
     public Int32 _accessed=0,_missed=0;

     ////////////////
     //构造函数
     //参数 size : cache拥有的资源数
     //     load : 根据资源id加载资源的delegate
     //     unLoad : 卸载资源的delegate
     public LRUCache(Int32 size,Func<U,T> loader,Action<U> unLoader){
         _unUsedSize=size;
         _tail=_head=new Node(default(U)); //建立表头节点,使用带表头的单向链表存放数据
         Loader=loader;
         UnLoader=unLoader;
         _dict=new Dictionary<U,Node>();
     }

     //根据id查找对应的节点，返回目标节点的前一个节点
     protected Node Find(U id){
         //Node p=_head;
         //for(;p.Next!=null&&(p.Next.ID.CompareTo(id)!=0);p=p.Next);

         //改用dictionary查找表，提高查询效率
         return (_dict.ContainsKey(id))?(_dict[id]):_tail;
     }
     //在队列尾部加入节点
     protected Node Append(Node n){
         _dict.Add(n.ID,_tail);
         return _tail=_tail.InsertAfter(n);
     }
     //移除一个节点 (n.Next)
     protected Node Remove(Node n){
         if(n.Next==_tail)
             _tail=n;
         if(n.Next.Next!=null)
             _dict[n.Next.Next.ID]=n;
         _dict.Remove(n.Next.ID);
         return n.RemoveAfter();
     }
     //将指定节点的Next移动到队列尾部
     protected Node SendBack(Node n){
         if(n.Next!=_tail){
             return Append(Remove(n));//摘除节点 加到队列尾部
         }else
             return _tail;
     }

     //获得一个新的资源。
     protected Node CreateResource(U id){
         if(_unUsedSize>0){
             //有未使用的缓冲区，直接创建管理节点即可
             --_unUsedSize;
             return new Node(id);
         }else{
             //从表头摘下一个节点来使用。
             Node p=Remove(_head).UnLoadResource(UnLoader);
             p.ID=id;
             return p;
         }
     }
     protected String Show(Node n){
         String s=String.Empty;
         for(;n!=null;n=n.Next){
             s+=','+n.ID.ToString();
         }
         return s;
     }
     ~LRUCache(){
         Dispose();
     }

     ////////////////////////////
     //实现ICache
     public T this[U id]{
         get{
             lock(_head){
                 ++_accessed;
                 //Console.WriteLine("+++"+Show(_head));
                 Node p=Find(id);//查找队列中是否有该资源
                 if(p.Next==null){
                     ++_missed;
                     p=Append(CreateResource(id));//无，则创建资源，并加入队列尾部
                 }else
                     p=SendBack(p);//有，将资源移到队列尾部
                 p.LoadResource(Loader);//加载资源（若已经加载，则不做任何动作）
                 //Console.WriteLine("---"+Show(_head));
                 return p.Value;
             }
         }
     }
     public Func<U,T> Loader{protected get;set;}//回调函数 要求访问者加载资源
     public Action<U> UnLoader{protected get;set;}//回调函数 要求访问者卸载资源
     //public event CacheEventHandler<T,U> Load;
     //public event CacheEventHandler<T,U> UnLoad;

     ////////////////////////////
     //实现IDisposable
     public void Dispose(){
         lock(_head){
             //卸载cache中的资源
             for(Node p=_head.Next;p!=null;p=p.Next)
                 if(p.Loaded)
                     p.UnLoadResource(UnLoader);
             _head.Next=null;
         }
     }

     ////////////////////////////
     //节点定义
     public class Node{
         public Node(U id){
             Value=default(T);
             ID=id;
             Next=null;
             Loaded=false;
         }
         public T Value{get;set;}
         public U ID{get;set;}
         public Node Next{get;set;}
         public Boolean Loaded{get;set;}
         public Node InsertAfter(Node n){
             n.Next=this.Next;
             this.Next=n;
             return n;
         }
         public Node RemoveAfter(){
             Node n=this.Next;
             if(n!=null){
                 this.Next=n.Next;
                 n.Next=null;
             }
             return n;
         }
         //加载资源
         public Node LoadResource(Func<U,T> load){
             if(!Loaded){
                 Value=load(ID);
                 Loaded=true;
             }
             return this;

         }
         //卸载资源
         public Node UnLoadResource(Action<U> unLoad){
             //Console.WriteLine("==="+Show(_head));
             if(Loaded){
                 unLoad(ID);
                 Value=default(T);
                 Loaded=false;
             }
             return this;
         }
     }
 }

 public class LIRSCache<T,U>:ICache<T,U>,IDisposable where U:IComparable<U>{
     Int32 _grade;//缓冲区级数
     Int32[] _unUsedSize;//可用资源数量（缓冲区的块数），_unUsedSize[0]存放cold数据，_unUsedSize[1]存放hot数据
     Node[] _head;//使用带表头的单向链表,_head[0]指向表头，_head[1]指向hot区的前一个节点（cold区的最后一个节点),_head[2]指向表尾
     Dictionary<U,Node> _dict;//维护U与Node之间的对照，以提供更高速的Find功能.（ID与Node的前一个节点对应）
     ////////test使用
     public Int32 _accessed=0,_missed=0;

     ////////////////
     //构造函数
     //参数 size : cache拥有的资源数
     //     load : 根据资源id加载资源的delegate
     //     unLoad : 卸载资源的delegate
     public LIRSCache(Int32 grade,Int32[] size,Func<U,T> loader,Action<U> unLoader){
         _grade=grade;
         //设置每级缓冲的大小
         _unUsedSize=new Int32[_grade];
         for(Int32 i=0;i<_grade;++i)
             _unUsedSize[i]=size[i];
         //初始化缓冲指针//建立表头节点,使用带表头的单向链表存放数据
         _head=new Node[_grade+1];
         _head[_grade]=new Node(default(U));
         for(Int32 i=0;i<_grade;++i)
             _head[i]=_head[_grade];
         Loader=loader;
         UnLoader=unLoader;
         _dict=new Dictionary<U,Node>();
     }

     protected Node Find(U id){
         /*foreach(var i in _dict)
             Console.WriteLine("{0}->{1}",i.Value.ID,i.Key);*/
         /*Node p=_head[0];
         for(;p.Next!=null&&(p.Next.ID.CompareTo(id)!=0);p=p.Next);

         Node q=(_dict.ContainsKey(id))?(_dict[id]):_head[_grade];
         if(p!=q)throw new Exception("Find Error");
         return q;*/
         //改用dictionary查找表，提高查询效率
         return (_dict.ContainsKey(id))?(_dict[id]):_head[_grade];
     }

     //在队列尾部加入节点
     protected Node Append(Int32 selector,Node n){
         _dict.Add(n.ID,_head[selector+1]);
         if(selector+1<_grade)
             _dict[_head[selector+1].Next.ID]=n;
         n.Selector=selector;
         return _head[selector+1]=_head[selector+1].InsertAfter(n);
     }
     //移除一个节点 (n.Next)
     protected Node Remove(Int32 selector,Node n){
         if(n.Next==_head[selector+1])
             _head[selector+1]=n;
         if(n.Next.Next!=null)
             _dict[n.Next.Next.ID]=n;
         _dict.Remove(n.Next.ID);
         return n.RemoveAfter();
     }
     //将指定节点的Next移动到队列尾部
     protected Node SendBack(Int32 selector,Node n){
         if(n.Next!=_head[selector+1])
             return Append(selector,Remove(selector,n));//摘除节点 加到队列尾部
         else
             return _head[selector+1];
     }
     //获得一个新的资源。
     protected Node CreateResource(U id){
         //有未使用的缓冲区，直接创建管理节点即可
         for(Int32 i=_grade-1;i>=0;--i){
             if(_unUsedSize[i]>0){
                 --_unUsedSize[i];
                 Node n=new Node(id);
                 n.Selector=i; //记录新节点的级数
                 return n;
             }
         }
         //从表头摘下一个节点来使用。
         Node p=Remove(0,_head[0]).UnLoadResource(UnLoader);
         p.ID=id;
         p.Selector=0;//指定为0级节点
         return p;
     }
     protected String Show(Node n){
         String s=String.Empty;
         for(;n!=null;n=n.Next){
             s+=','+n.ID.ToString();
         }
         return s;
     }
     ~LIRSCache(){
         Dispose();
     }

     ////////////////////////////
     //实现ICache
     public T this[U id]{
         get{
             //return default(T);
             lock(_head){
                 ++_accessed;
                 //Console.WriteLine(id);
                 Node p=Find(id);
                 Int32 selector;
                 if(p.Next==null){
                     //无，则创建资源，并加入队列尾部
                     ++_missed;
                     p=CreateResource(id);
                     //队列未满，将节点加入指定级缓冲的尾部
                     //替换下来的节点，加入0级队列的尾部
                     Append(p.Selector,p);
                 }else{
                     //有，若已经到最后一级，则移动到尾部，否则将资源升级到下一级的头部
                     selector=p.Next.Selector;
                     if(selector+1<_grade){
                         p=Remove(selector,p); // 移除节点
                         _head[selector+1]=_head[selector+1].Next;//移动selector+1级的头指针,使原先的头节点成为selector级的尾部
                         _head[selector+1].Selector=selector;//指定节点的新级别
                         Append(selector+1,p);//在selector+1级尾部添加节点
                     }else{
                         p=SendBack(selector,p);
                     }
                 }
                 p.LoadResource(Loader);//加载资源（若已经加载，则不做任何动作）
                 /*Console.WriteLine("0:"+Show(_head[0]));
                 Console.WriteLine("1:"+Show(_head[1]));
                 Console.WriteLine("2:"+Show(_head[2]));*/
                 return p.Value;
             }
         }
     }
     public Func<U,T> Loader{protected get;set;}//回调函数 要求访问者加载资源
     public Action<U> UnLoader{protected get;set;}//回调函数 要求访问者卸载资源
     //public event CacheEventHandler<T,U> Load;
     //public event CacheEventHandler<T,U> UnLoad;

     ////////////////////////////
     //实现IDisposable
     public void Dispose(){
     }

     public class Node{
         public Node(U id){
             Value=default(T);
             ID=id;
             Next=null;
             Loaded=false;
             Selector=0;
         }
         public T Value{get;set;}
         public U ID{get;set;}
         public Int32 Selector{get;set;}
         public Node Next{get;set;}
         public Boolean Loaded{get;set;}

         public Node InsertAfter(Node n){
             n.Next=this.Next;
             this.Next=n;
             return n;
         }
         public Node RemoveAfter(){
             Node n=this.Next;
             if(n!=null){
                 this.Next=n.Next;
                 n.Next=null;
             }
             return n;
         }
         //加载资源
         public Node LoadResource(Func<U,T> load){
             if(!Loaded){
                 Value=load(ID);
                 Loaded=true;
             }
             return this;

         }
         //卸载资源
         public Node UnLoadResource(Action<U> unLoad){
             //Console.WriteLine("==="+Show(_head));
             if(Loaded){
                 unLoad(ID);
                 Value=default(T);
                 Loaded=false;
             }
             return this;
         }
     }
 }
 public class Test{
     public static void Main(){
         List<Int32> list=GetRandomGaussian(1000000);
         Stopwatch  sw=new Stopwatch ();
         sw.Reset();
         sw.Start();
         TestLRUCache(list);
         sw.Stop();
         Console.WriteLine(sw.ElapsedTicks);
         sw.Reset();
         sw.Start();
         TestLIRSCache(list);
         sw.Stop();
         Console.WriteLine(sw.ElapsedTicks);
         sw.Reset();
         sw.Start();
         TestLIRSCache2(list);
         sw.Stop();
         Console.WriteLine(sw.ElapsedTicks);
         sw.Reset();
         sw.Start();
         TestLIRSCache3(list);
         sw.Stop();
         Console.WriteLine(sw.ElapsedTicks);
     }
     public static List<Int32> GetRandomList(Int32 len){
         List<Int32> list=new List<Int32>();
         for(Int32 i=0;i<len;i++)
             list.Add(i%1001);
         return list;
     }
     public static List<Int32> GetRandomAvg(Int32 len){
         Random r=new Random();
         List<Int32> list=new List<Int32>();
         for(Int32 i=0;i<len;i++)
             list.Add(r.Next(2000));
         return list;
     }
     public static List<Int32> GetRandomGaussian(Int32 len){
         GaussianRandom r=new GaussianRandom();
         List<Int32> list=new List<Int32>();
         for(Int32 i=0;i<len;i++)
             list.Add(r.Next(500,250));
         return list;
     }
     public static void TestLIRSCache(List<Int32> r){
         LIRSCache<String,Int32> cache =new LIRSCache<String,Int32>(2,new Int32[]{100,900},id=>{return "="+id.ToString()+'=';},id=>{});
         Dictionary<Int32,Int32> dict=new Dictionary<Int32,Int32>();
         Int32 k;
         foreach(Int32 j in r){
             if(dict.ContainsKey(j))dict[j]++;else dict.Add(j,1);
             //Console.WriteLine(cache[j]);
             k=cache[j].Length;
         }
         Console.WriteLine("LIRS1 : 1-{0}/{1}={2}",cache._missed,cache._accessed,1.0-1.0*cache._missed/cache._accessed);
         //dict.OrderBy(d=>d.Key).ForEach(k=>{Console.WriteLine("{0},{1}",k.Key,k.Value);});

     }
     public static void TestLIRSCache2(List<Int32> r){
         LIRSCache<String,Int32> cache =new LIRSCache<String,Int32>(3,new Int32[]{10,100,890},id=>{return "="+id.ToString()+'=';},id=>{});
         Dictionary<Int32,Int32> dict=new Dictionary<Int32,Int32>();
         Int32 k;
         foreach(Int32 j in r){
             if(dict.ContainsKey(j))dict[j]++;else dict.Add(j,1);
             //Console.WriteLine(cache[j]);
             k=cache[j].Length;
         }
         Console.WriteLine("LIRS2 : 1-{0}/{1}={2}",cache._missed,cache._accessed,1.0-1.0*cache._missed/cache._accessed);
         //dict.OrderBy(d=>d.Key).ForEach(k=>{Console.WriteLine("{0},{1}",k.Key,k.Value);});

     }
     public static void TestLIRSCache3(List<Int32> r){
         LIRSCache<String,Int32> cache =new LIRSCache<String,Int32>(2,new Int32[]{10,990},id=>{return "="+id.ToString()+'=';},id=>{});
         Dictionary<Int32,Int32> dict=new Dictionary<Int32,Int32>();
         Int32 k;
         foreach(Int32 j in r){
             if(dict.ContainsKey(j))dict[j]++;else dict.Add(j,1);
             //Console.WriteLine(cache[j]);
             k=cache[j].Length;
         }
         Console.WriteLine("LIRS3 : 1-{0}/{1}={2}",cache._missed,cache._accessed,1.0-1.0*cache._missed/cache._accessed);
         //dict.OrderBy(d=>d.Key).ForEach(k=>{Console.WriteLine("{0},{1}",k.Key,k.Value);});

     }
     public static void TestLRUCache(List<Int32> r){
         LRUCache<String,Int32> cache =new LRUCache<String,Int32>(200,id=>{return "="+id.ToString()+'=';},id=>{});
         Dictionary<Int32,Int32> dict=new Dictionary<Int32,Int32>();
         Int32 k;
         foreach(Int32 j in r){
             if(dict.ContainsKey(j))dict[j]++;else dict.Add(j,1);
             //Console.WriteLine(cache[j]);
             k=cache[j].Length;
         }
         Console.WriteLine("LRU   : 1-{0}/{1}={2}",cache._missed,cache._accessed,1.0-1.0*cache._missed/cache._accessed);
         //dict.OrderBy(d=>d.Key).ForEach(k=>{Console.WriteLine("{0},{1}",k.Key,k.Value);});

     }
 }