TimeLimitingCollector.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 Lucene.Net.Support;
using IndexReader = Lucene.Net.Index.IndexReader;

namespace Lucene.Net.Search
{
    
    public class TimeLimitingCollector:Collector
    {
        private void  InitBlock()
        {
            greedy = DEFAULT_GREEDY;
        }
        
        public const int DEFAULT_RESOLUTION = 20;
        
        public bool DEFAULT_GREEDY = false;
        
        private static uint resolution = DEFAULT_RESOLUTION;
        
        private bool greedy;
        
        private sealed class TimerThread:ThreadClass
        {
            
            // NOTE: we can avoid explicit synchronization here for several reasons:
            // * updates to volatile long variables are atomic
            // * only single thread modifies this value
            // * use of volatile keyword ensures that it does not reside in
            //   a register, but in main memory (so that changes are visible to
            //   other threads).
            // * visibility of changes does not need to be instantanous, we can
            //   afford losing a tick or two.
            //
            // See section 17 of the Java Language Specification for details.
            private volatile uint time = 0;
            
            internal TimerThread():base("TimeLimitedCollector timer thread")
            {
                this.IsBackground = true;
            }
            
            override public void  Run()
            {
                while (true)
                {
                    // TODO: Use System.nanoTime() when Lucene moves to Java SE 5.
                    time += Lucene.Net.Search.TimeLimitingCollector.resolution;
                    System.Threading.Thread.Sleep(new System.TimeSpan((System.Int64) 10000 * Lucene.Net.Search.TimeLimitingCollector.resolution));
                    
                }
            }

            public long Milliseconds
            {
                get { return time; }
            }
        }
        
        [Serializable]
        public class TimeExceededException:System.SystemException
        {
            private long timeAllowed;
            private long timeElapsed;
            private int lastDocCollected;
            internal TimeExceededException(long timeAllowed, long timeElapsed, int lastDocCollected):base("Elapsed time: " + timeElapsed + "Exceeded allowed search time: " + timeAllowed + " ms.")
            {
                this.timeAllowed = timeAllowed;
                this.timeElapsed = timeElapsed;
                this.lastDocCollected = lastDocCollected;
            }

            public virtual long TimeAllowed
            {
                get { return timeAllowed; }
            }

            public virtual long TimeElapsed
            {
                get { return timeElapsed; }
            }

            public virtual int LastDocCollected
            {
                get { return lastDocCollected; }
            }
        }
        
        // Declare and initialize a single static timer thread to be used by
        // all TimeLimitedCollector instances.  The JVM assures that
        // this only happens once.
        private static readonly TimerThread TIMER_THREAD = new TimerThread();
        
        private long t0;
        private long timeout;
        private Collector collector;

        private int docBase;
        
        public TimeLimitingCollector(Collector collector, long timeAllowed)
        {
            InitBlock();
            this.collector = collector;
            t0 = TIMER_THREAD.Milliseconds;
            this.timeout = t0 + timeAllowed;
        }

        public static long Resolution
        {
            get { return resolution; }
            set
            {
                // 5 milliseconds is about the minimum reasonable time for a Object.wait(long) call.
                resolution = (uint)System.Math.Max(value, 5);
            }
        }

        public virtual bool IsGreedy
        {
            get { return greedy; }
            set { this.greedy = value; }
        }

        public override void  Collect(int doc)
        {
            long time = TIMER_THREAD.Milliseconds;
            if (timeout < time)
            {
                if (greedy)
                {
                    //System.out.println(this+"  greedy: before failing, collecting doc: "+doc+"  "+(time-t0));
                    collector.Collect(doc);
                }
                //System.out.println(this+"  failing on:  "+doc+"  "+(time-t0));
                throw new TimeExceededException(timeout - t0, time - t0, docBase + doc);
            }
            //System.out.println(this+"  collecting: "+doc+"  "+(time-t0));
            collector.Collect(doc);
        }
        
        public override void  SetNextReader(IndexReader reader, int base_Renamed)
        {
            collector.SetNextReader(reader, base_Renamed);
            this.docBase = base_Renamed;
        }
        
        public override void  SetScorer(Scorer scorer)
        {
            collector.SetScorer(scorer);
        }

        public override bool AcceptsDocsOutOfOrder
        {
            get { return collector.AcceptsDocsOutOfOrder; }
        }

        static TimeLimitingCollector()
        {
            {
                TIMER_THREAD.Start();
            }
        }
    }
}