FilterManager.cs

Go to the documentation of this file.

/* 
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

using System;
using System.Collections.Generic;
using System.Linq;
using Lucene.Net.Support;

namespace Lucene.Net.Search
{
    
    public class FilterManager
    {
        
        protected internal static FilterManager manager;
        
        protected internal const int DEFAULT_CACHE_CLEAN_SIZE = 100;
        protected internal const long DEFAULT_CACHE_SLEEP_TIME = 1000 * 60 * 10;
        
        protected internal IDictionary<int, FilterItem> cache;
        protected internal int cacheCleanSize;
        protected internal long cleanSleepTime;
        protected internal FilterCleaner internalFilterCleaner;

        private static readonly object _staticSyncObj = new object();
        public static FilterManager Instance
        {
            get
            {
                lock (_staticSyncObj)
                {
                    return manager ?? (manager = new FilterManager());
                }
            }
        }

        protected internal FilterManager()
        {
            cache = new HashMap<int, FilterItem>();
            cacheCleanSize = DEFAULT_CACHE_CLEAN_SIZE; // Let the cache get to 100 items
            cleanSleepTime = DEFAULT_CACHE_SLEEP_TIME; // 10 minutes between cleanings
            
            internalFilterCleaner = new FilterCleaner(this);
            ThreadClass fcThread = new ThreadClass(new System.Threading.ThreadStart(internalFilterCleaner.Run));
            // setto be a Daemon so it doesn't have to be stopped
            fcThread.IsBackground = true;
            fcThread.Start();
        }

        public virtual void SetCacheSize(int value)
        {
            this.cacheCleanSize = value;
        }

        public virtual void SetCleanThreadSleepTime(long value)
        {
            this.cleanSleepTime = value;
        }

        public virtual Filter GetFilter(Filter filter)
        {
            lock (cache)
            {
                FilterItem fi = null;
                fi = cache[filter.GetHashCode()];
                if (fi != null)
                {
                    fi.timestamp = System.DateTime.UtcNow.Ticks;
                    return fi.filter;
                }
                cache[filter.GetHashCode()] = new FilterItem(filter);
                return filter;
            }
        }
        
        protected internal class FilterItem
        {
            public Filter filter;
            public long timestamp;
            
            public FilterItem(Filter filter)
            {
                this.filter = filter;
                this.timestamp = System.DateTime.UtcNow.Ticks;
            }
        }
        
        
        protected internal class FilterCleaner : IThreadRunnable
        {
            private class FilterItemComparer : IComparer<KeyValuePair<int, FilterItem>>
            {
                #region IComparer<FilterItem> Members

                public int Compare(KeyValuePair<int, FilterItem> x, KeyValuePair<int, FilterItem> y)
                {
                    return x.Value.timestamp.CompareTo(y.Value.timestamp);
                }

                #endregion
            }
            
            private bool running = true;
            private FilterManager manager;
            private ISet<KeyValuePair<int, FilterItem>> sortedFilterItems;
            
            public FilterCleaner(FilterManager enclosingInstance)
            {
                this.manager = enclosingInstance;
                sortedFilterItems = new SortedSet<KeyValuePair<int, FilterItem>>(new FilterItemComparer());
            }
            
            public virtual void  Run()
            {
                while (running)
                {
                    // sort items from oldest to newest 
                    // we delete the oldest filters 
                    if (this.manager.cache.Count > this.manager.cacheCleanSize)
                    {
                        // empty the temporary set
                        sortedFilterItems.Clear();
                        lock (this.manager.cache)
                        {
                            sortedFilterItems.UnionWith(this.manager.cache);
                            int numToDelete = (int)((this.manager.cache.Count - this.manager.cacheCleanSize) * 1.5);

                            //delete all of the cache entries not used in a while
                            sortedFilterItems.ExceptWith(sortedFilterItems.Take(numToDelete).ToArray());
                        }
                        // empty the set so we don't tie up the memory
                        sortedFilterItems.Clear();
                    }
                    // take a nap
                    System.Threading.Thread.Sleep(new System.TimeSpan((System.Int64)10000 * this.manager.cleanSleepTime));
                    
                }
            }
        }
    }
}