beagled/Lucene.Net/Store/MMapDirectory.cs

   1 /*
   2  * Copyright 2005 The Apache Software Foundation
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 using System;
  17 //using ByteBuffer = java.nio.ByteBuffer;                   // {{Aroush-1.9}}
  18 //using FileChannel = java.nio.channels.FileChannel;        // {{Aroush-1.9}}
  19 //using MapMode = java.nio.channels.FileChannel.MapMode;    // {{Aroush-1.9}}
  20 namespace Lucene.Net.Store
  21 {
  22
  23     /// <summary>File-based {@link Directory} implementation that uses mmap for input.
  24     ///
  25     /// <p>To use this, invoke Java with the System property
  26     /// Lucene.Net.FSDirectory.class set to
  27     /// Lucene.Net.store.MMapDirectory.  This will cause {@link
  28     /// FSDirectory#GetDirectory(File,boolean)} to return instances of this class.
  29     /// </summary>
  30     public class MMapDirectory : FSDirectory
  31     {
  32
  33         private class MMapIndexInput : IndexInput, System.ICloneable
  34         {
  35
  36             System.IO.FileStream buffer;    //{{}} private ByteBuffer buffer;   // {{Aroush-1.9}}
  37             private long length;
  38
  39             internal MMapIndexInput(System.IO.FileStream raf)
  40             {
  41                 this.length = raf.Length;
  42                 // this.buffer = raf.GetChannel().map(MapMode.READ_ONLY, 0, length);   // {{Aroush-1.9}}
  43             }
  44
  45             public override byte ReadByte()
  46             {
  47                 return 0;    // return buffer.get_Renamed();    // {{Aroush-1.9}}
  48             }
  49
  50             public override void  ReadBytes(byte[] b, int offset, int len)
  51             {
  52                 // buffer.get_Renamed(b, offset, len);   // {{Aroush-1.9}}
  53             }
  54
  55             public override long GetFilePointer()
  56             {
  57                 return buffer.Position;
  58             }
  59
  60             public override void  Seek(long pos)
  61             {
  62                 buffer.Seek(pos, System.IO.SeekOrigin.Begin);
  63             }
  64
  65             public override long Length()
  66             {
  67                 return length;
  68             }
  69
  70             public override System.Object Clone()
  71             {
  72                 MMapIndexInput clone = (MMapIndexInput) base.Clone();
  73                 // clone.buffer = buffer.duplicate();   // {{Aroush-1.9}}
  74                 return clone;
  75             }
  76
  77             public override void  Close()
  78             {
  79             }
  80         }
  81
  82         /* Added class MultiMMapIndexInput, Paul Elschot.
  83         * Slightly adapted constructor of MMapIndexInput.
  84         * Licensed under the Apache License, Version 2.0.
  85         */
  86         private class MultiMMapIndexInput:IndexInput, System.ICloneable
  87         {
  88
  89             private System.IO.FileStream[] buffers;     // private ByteBuffer[] buffers;    // {{Aroush-1.9}}
  90             private int[] bufSizes; // keep here, ByteBuffer.size() method is optional
  91
  92             private long length;
  93
  94             private int curBufIndex;
  95             private int maxBufSize;
  96
  97             private System.IO.FileStream curBuf;    // private ByteBuffer curBuf; // {{Aroush-1.9}} // redundant for speed: buffers[curBufIndex]
  98             private int curAvail; // redundant for speed: (bufSizes[curBufIndex] - curBuf.position())
  99
 100
 101             public MultiMMapIndexInput(System.IO.FileStream raf, int maxBufSize)
 102             {
 103                 this.length = raf.Length;
 104                 this.maxBufSize = maxBufSize;
 105
 106                 if (maxBufSize <= 0)
 107                     throw new System.ArgumentException("Non positive maxBufSize: " + maxBufSize);
 108
 109                 if ((length / maxBufSize) > System.Int32.MaxValue)
 110                 {
 111                     throw new System.ArgumentException("RandomAccessFile too big for maximum buffer size: " + raf.ToString());
 112                 }
 113
 114                 int nrBuffers = (int) (length / maxBufSize);
 115                 if ((nrBuffers * maxBufSize) < length)
 116                     nrBuffers++;
 117
 118                 this.buffers = new System.IO.FileStream[nrBuffers]; // this.buffers = new ByteBuffer[nrBuffers];    // {{Aroush-1.9}}
 119                 this.bufSizes = new int[nrBuffers];
 120
 121                 long bufferStart = 0;
 122                 System.IO.FileStream rafc = null; // FileChannel rafc = raf.getChannel(); // {{Aroush-1.9}}
 123                 for (int bufNr = 0; bufNr < nrBuffers; bufNr++)
 124                 {
 125                     int bufSize = (length > (bufferStart + maxBufSize))?maxBufSize:(int) (length - bufferStart);
 126                     // this.buffers[bufNr] = rafc.map(MapMode.READ_ONLY, bufferStart, bufSize); // {{Aroush-1.9}}
 127                     this.bufSizes[bufNr] = bufSize;
 128                     bufferStart += bufSize;
 129                 }
 130                 Seek(0L);
 131             }
 132
 133             public override byte ReadByte()
 134             {
 135                 // Performance might be improved by reading ahead into an array of
 136                 // eg. 128 bytes and readByte() from there.
 137                 if (curAvail == 0)
 138                 {
 139                     curBufIndex++;
 140                     curBuf = buffers[curBufIndex]; // index out of bounds when too many bytes requested
 141                     curBuf.Seek(0, System.IO.SeekOrigin.Begin);
 142                     curAvail = bufSizes[curBufIndex];
 143                 }
 144                 curAvail--;
 145                 return 0;   // return curBuf.get_Renamed(); // {{Aroush-1.9}}
 146             }
 147
 148             public override void  ReadBytes(byte[] b, int offset, int len)
 149             {
 150                 while (len > curAvail)
 151                 {
 152                     // curBuf.get_Renamed(b, offset, curAvail); // {{Aroush-1.9}}
 153                     len -= curAvail;
 154                     offset += curAvail;
 155                     curBufIndex++;
 156                     curBuf = buffers[curBufIndex]; // index out of bounds when too many bytes requested
 157                     curBuf.Seek(0, System.IO.SeekOrigin.Begin);
 158                     curAvail = bufSizes[curBufIndex];
 159                 }
 160                 // curBuf.get_Renamed(b, offset, len);  // {{Aroush-1.9}}
 161                 curAvail -= len;
 162             }
 163
 164             public override long GetFilePointer()
 165             {
 166                 return (curBufIndex * (long) maxBufSize) + curBuf.Position;
 167             }
 168
 169             public override void  Seek(long pos)
 170             {
 171                 curBufIndex = (int) (pos / maxBufSize);
 172                 curBuf = buffers[curBufIndex];
 173                 int bufOffset = (int) (pos - (curBufIndex * maxBufSize));
 174                 curBuf.Seek(bufOffset, System.IO.SeekOrigin.Begin);
 175                 curAvail = bufSizes[curBufIndex] - bufOffset;
 176             }
 177
 178             public override long Length()
 179             {
 180                 return length;
 181             }
 182
 183             public override System.Object Clone()
 184             {
 185                 MultiMMapIndexInput clone = (MultiMMapIndexInput) base.Clone();
 186                 // clone.buffers = new ByteBuffer[buffers.Length];  // {{Aroush-1.9}}
 187                 // No need to clone bufSizes.
 188                 // Since most clones will use only one buffer, duplicate() could also be
 189                 // done lazy in clones, eg. when adapting curBuf.
 190                 for (int bufNr = 0; bufNr < buffers.Length; bufNr++)
 191                 {
 192                     // clone.buffers[bufNr] = buffers[bufNr].duplicate();   // {{Aroush-1.9}}
 193                 }
 194                 try
 195                 {
 196                     clone.Seek(GetFilePointer());
 197                 }
 198                 catch (System.IO.IOException ioe)
 199                 {
 200                     throw new System.Exception(ioe.ToString()); // {{Aroush-1.9}} should be re-thrown as RuntimeException
 201                 }
 202                 return clone;
 203             }
 204
 205             public override void  Close()
 206             {
 207             }
 208         }
 209
 210         private int MAX_BBUF = System.Int32.MaxValue;
 211
 212         public override IndexInput OpenInput(System.String name)
 213         {
 214             System.IO.FileInfo f = new System.IO.FileInfo(System.IO.Path.Combine(GetFile().FullName, name));
 215             System.IO.FileStream raf = new System.IO.FileStream(f.FullName, System.IO.FileMode.Open, System.IO.FileAccess.Read);
 216             try
 217             {
 218                 return (raf.Length <= MAX_BBUF) ? (IndexInput) new MMapIndexInput(raf) : (IndexInput) new MultiMMapIndexInput(raf, MAX_BBUF);
 219             }
 220             finally
 221             {
 222                 raf.Close();
 223             }
 224         }
 225     }
 226 }