You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucenenet.apache.org by sl...@apache.org on 2011/03/12 08:20:45 UTC
[Lucene.Net] svn commit: r1080881 - in /incubator/lucene.net/trunk/C#/src/Lucene.Net:
Index/DocumentsWriter.cs Index/StoredFieldsWriter.cs
Index/TermVectorsTermsWriter.cs Index/TermVectorsTermsWriterPerField.cs
Store/RAMFile.cs Store/RAMOutputStream.cs
Author: slombard
Date: Sat Mar 12 07:20:44 2011
New Revision: 1080881
URL: http://svn.apache.org/viewvc?rev=1080881&view=rev
Log:
[LUCENENET-399] (trunk) 2.9.3 - change LUCENE 2283: use shared byte[] pool to buffer pending stored fields & term vectors during indexing; fixes excessive memory usage for mixed tiny & big docs with many threads
Modified:
incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/DocumentsWriter.cs
incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/StoredFieldsWriter.cs
incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/TermVectorsTermsWriter.cs
incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/TermVectorsTermsWriterPerField.cs
incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/RAMFile.cs
incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/RAMOutputStream.cs
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/DocumentsWriter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Index/DocumentsWriter.cs?rev=1080881&r1=1080880&r2=1080881&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/DocumentsWriter.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/DocumentsWriter.cs Sat Mar 12 07:20:44 2011
@@ -19,15 +19,16 @@ using System;
using Analyzer = Lucene.Net.Analysis.Analyzer;
using Document = Lucene.Net.Documents.Document;
-using AlreadyClosedException = Lucene.Net.Store.AlreadyClosedException;
-using Directory = Lucene.Net.Store.Directory;
-using ArrayUtil = Lucene.Net.Util.ArrayUtil;
-using Constants = Lucene.Net.Util.Constants;
using IndexSearcher = Lucene.Net.Search.IndexSearcher;
using Query = Lucene.Net.Search.Query;
using Scorer = Lucene.Net.Search.Scorer;
using Similarity = Lucene.Net.Search.Similarity;
using Weight = Lucene.Net.Search.Weight;
+using AlreadyClosedException = Lucene.Net.Store.AlreadyClosedException;
+using Directory = Lucene.Net.Store.Directory;
+using RAMFile = Lucene.Net.Store.RAMFile;
+using ArrayUtil = Lucene.Net.Util.ArrayUtil;
+using Constants = Lucene.Net.Util.Constants;
namespace Lucene.Net.Index
{
@@ -104,7 +105,7 @@ namespace Lucene.Net.Index
{
internal override DocConsumer GetChain(DocumentsWriter documentsWriter)
- {
+ {
/*
This is the current indexing chain:
@@ -145,7 +146,8 @@ namespace Lucene.Net.Index
freeLevel = (long) (IndexWriter.DEFAULT_RAM_BUFFER_SIZE_MB * 1024 * 1024 * 0.95);
maxBufferedDocs = IndexWriter.DEFAULT_MAX_BUFFERED_DOCS;
skipDocWriter = new SkipDocWriter();
- byteBlockAllocator = new ByteBlockAllocator(this);
+ byteBlockAllocator = new ByteBlockAllocator(this, BYTE_BLOCK_SIZE);
+ perDocAllocator = new ByteBlockAllocator(this, PER_DOC_BLOCK_SIZE);
waitQueue = new WaitQueue(this);
}
@@ -220,6 +222,59 @@ namespace Lucene.Net.Index
}
}
+ //Create and return a new DocWriterBuffer.
+ internal PerDocBuffer newPerDocBuffer()
+ {
+ return new PerDocBuffer(perDocAllocator);
+ }
+
+ /// <summary>RAMFile buffer for DocWriters.</summary>
+ internal class PerDocBuffer:RAMFile
+ {
+ public PerDocBuffer(ByteBlockAllocator perDocAllocator)
+ {
+ InitBlock(perDocAllocator);
+ }
+ private void InitBlock(ByteBlockAllocator perDocAllocator)
+ {
+ this.perDocAllocator = perDocAllocator;
+ }
+ private ByteBlockAllocator perDocAllocator;
+
+ /// <summary>
+ /// Allocate bytes used from shared pool.
+ /// </summary>
+ /// <param name="size">Size of new buffer. Fixed at <see cref="PER_DOC_BLOCK_SIZE"/>.</param>
+ /// <returns></returns>
+ protected internal byte[] newBuffer(int size)
+ {
+ System.Diagnostics.Debug.Assert(size == PER_DOC_BLOCK_SIZE);
+ return perDocAllocator.GetByteBlock(false);
+ }
+
+ //Recycle the bytes used.
+ internal void recycle()
+ {
+ lock(this)
+ {
+ if (buffers.Count > 0)
+ {
+ SetLength(0);
+
+ // Recycle the blocks
+ int blockCount = buffers.Count;
+ byte[][] blocks = new byte[blockCount][];
+ buffers.CopyTo(blocks);
+ perDocAllocator.RecycleByteBlocks(blocks, 0, blockCount);
+ buffers.Clear();
+ sizeInBytes = 0;
+
+ System.Diagnostics.Debug.Assert(NumBuffers() == 0);
+ }
+ }
+ }
+ }
+
/// <summary> The IndexingChain must define the {@link #GetChain(DocumentsWriter)} method
/// which returns the DocConsumer that the DocumentsWriter calls to process the
/// documents.
@@ -486,7 +541,7 @@ namespace Lucene.Net.Index
internal void Message(System.String message)
{
if (infoStream != null)
- writer.Message("DW: " + message);
+ writer.Message("DW: " + message);
}
internal System.Collections.Generic.IList<string> openFiles = new System.Collections.Generic.List<string>();
@@ -1530,13 +1585,14 @@ namespace Lucene.Net.Index
internal class ByteBlockAllocator:ByteBlockPool.Allocator
{
- public ByteBlockAllocator(DocumentsWriter enclosingInstance)
+ public ByteBlockAllocator(DocumentsWriter enclosingInstance, int blockSize)
{
- InitBlock(enclosingInstance);
+ InitBlock(enclosingInstance, blockSize);
}
- private void InitBlock(DocumentsWriter enclosingInstance)
+ private void InitBlock(DocumentsWriter enclosingInstance, int blockSize)
{
this.enclosingInstance = enclosingInstance;
+ this.blockSize = blockSize;
}
private DocumentsWriter enclosingInstance;
public DocumentsWriter Enclosing_Instance
@@ -1545,11 +1601,12 @@ namespace Lucene.Net.Index
{
return enclosingInstance;
}
-
}
-
+
+ int blockSize;
+
internal System.Collections.ArrayList freeByteBlocks = new System.Collections.ArrayList();
-
+
/* Allocate another byte[] from the shared pool */
public /*internal*/ override byte[] GetByteBlock(bool trackAllocations)
{
@@ -1565,8 +1622,8 @@ namespace Lucene.Net.Index
// things that don't track allocations (term
// vectors) and things that do (freq/prox
// postings).
- Enclosing_Instance.numBytesAlloc += Lucene.Net.Index.DocumentsWriter.BYTE_BLOCK_SIZE;
- b = new byte[Lucene.Net.Index.DocumentsWriter.BYTE_BLOCK_SIZE];
+ Enclosing_Instance.numBytesAlloc += blockSize;
+ b = new byte[blockSize];
}
else
{
@@ -1576,7 +1633,7 @@ namespace Lucene.Net.Index
b = (byte[]) tempObject;
}
if (trackAllocations)
- Enclosing_Instance.numBytesUsed += Lucene.Net.Index.DocumentsWriter.BYTE_BLOCK_SIZE;
+ Enclosing_Instance.numBytesUsed += blockSize;
System.Diagnostics.Debug.Assert(Enclosing_Instance.numBytesUsed <= Enclosing_Instance.numBytesAlloc);
return b;
}
@@ -1656,13 +1713,20 @@ namespace Lucene.Net.Index
{
lock (this)
{
- for (int i = start; i < end; i++)
- freeIntBlocks.Add(blocks[i]);
+ for (int i = start; i < end; i++)
+ {
+ freeIntBlocks.Add(blocks[i]);
+ }
}
}
internal ByteBlockAllocator byteBlockAllocator;
-
+
+ internal const int PER_DOC_BLOCK_SIZE = 1024;
+
+ internal ByteBlockAllocator perDocAllocator;
+
+
/* Initial chunk size of the shared char[] blocks used to
store term text */
internal const int CHAR_BLOCK_SHIFT = 14;
@@ -1708,7 +1772,9 @@ namespace Lucene.Net.Index
lock (this)
{
for (int i = 0; i < numBlocks; i++)
+ {
freeCharBlocks.Add(blocks[i]);
+ }
}
}
@@ -1716,18 +1782,20 @@ namespace Lucene.Net.Index
{
return System.String.Format(nf, "{0:f}", new System.Object[] { (v / 1024F / 1024F) });
}
-
- /* We have three pools of RAM: Postings, byte blocks
- * (holds freq/prox posting data) and char blocks (holds
- * characters in the term). Different docs require
- * varying amount of storage from these three classes.
- * For example, docs with many unique single-occurrence
- * short terms will use up the Postings RAM and hardly any
- * of the other two. Whereas docs with very large terms
- * will use alot of char blocks RAM and relatively less of
- * the other two. This method just frees allocations from
- * the pools once we are over-budget, which balances the
- * pools to match the current docs. */
+
+ /* We have four pools of RAM: Postings, byte blocks
+ * (holds freq/prox posting data), char blocks (holds
+ * characters in the term) and per-doc buffers (stored fields/term vectors).
+ * Different docs require varying amount of storage from
+ * these four classes.
+ *
+ * For example, docs with many unique single-occurrence
+ * short terms will use up the Postings RAM and hardly any
+ * of the other two. Whereas docs with very large terms
+ * will use alot of char blocks RAM and relatively less of
+ * the other two. This method just frees allocations from
+ * the pools once we are over-budget, which balances the
+ * pools to match the current docs. */
internal void BalanceRAM()
{
@@ -1740,7 +1808,14 @@ namespace Lucene.Net.Index
{
if (infoStream != null)
- Message(" RAM: now balance allocations: usedMB=" + ToMB(numBytesUsed) + " vs trigger=" + ToMB(flushTrigger) + " allocMB=" + ToMB(numBytesAlloc) + " deletesMB=" + ToMB(deletesRAMUsed) + " vs trigger=" + ToMB(freeTrigger) + " byteBlockFree=" + ToMB(byteBlockAllocator.freeByteBlocks.Count * BYTE_BLOCK_SIZE) + " charBlockFree=" + ToMB(freeCharBlocks.Count * CHAR_BLOCK_SIZE * CHAR_NUM_BYTE));
+ Message(" RAM: now balance allocations: usedMB=" + ToMB(numBytesUsed) +
+ " vs trigger=" + ToMB(flushTrigger) +
+ " allocMB=" + ToMB(numBytesAlloc) +
+ " deletesMB=" + ToMB(deletesRAMUsed) +
+ " vs trigger=" + ToMB(freeTrigger) +
+ " byteBlockFree=" + ToMB(byteBlockAllocator.freeByteBlocks.Count * BYTE_BLOCK_SIZE) +
+ " perDocFree=" + ToMB(perDocAllocator.freeByteBlocks.Count * PER_DOC_BLOCK_SIZE) +
+ " charBlockFree=" + ToMB(freeCharBlocks.Count * CHAR_BLOCK_SIZE * CHAR_NUM_BYTE));
long startBytesAlloc = numBytesAlloc + deletesRAMUsed;
@@ -1757,7 +1832,11 @@ namespace Lucene.Net.Index
lock (this)
{
- if (0 == byteBlockAllocator.freeByteBlocks.Count && 0 == freeCharBlocks.Count && 0 == freeIntBlocks.Count && !any)
+ if (0 == perDocAllocator.freeByteBlocks.Count
+ && 0 == byteBlockAllocator.freeByteBlocks.Count
+ && 0 == freeCharBlocks.Count
+ && 0 == freeIntBlocks.Count
+ && !any)
{
// Nothing else to free -- must flush now.
bufferIsFull = numBytesUsed + deletesRAMUsed > flushTrigger;
@@ -1772,26 +1851,41 @@ namespace Lucene.Net.Index
break;
}
- if ((0 == iter % 4) && byteBlockAllocator.freeByteBlocks.Count > 0)
+ if ((0 == iter % 5) && byteBlockAllocator.freeByteBlocks.Count > 0)
{
byteBlockAllocator.freeByteBlocks.RemoveAt(byteBlockAllocator.freeByteBlocks.Count - 1);
numBytesAlloc -= BYTE_BLOCK_SIZE;
}
- if ((1 == iter % 4) && freeCharBlocks.Count > 0)
+ if ((1 == iter % 5) && freeCharBlocks.Count > 0)
{
freeCharBlocks.RemoveAt(freeCharBlocks.Count - 1);
numBytesAlloc -= CHAR_BLOCK_SIZE * CHAR_NUM_BYTE;
}
- if ((2 == iter % 4) && freeIntBlocks.Count > 0)
+ if ((2 == iter % 5) && freeIntBlocks.Count > 0)
{
freeIntBlocks.RemoveAt(freeIntBlocks.Count - 1);
numBytesAlloc -= INT_BLOCK_SIZE * INT_NUM_BYTE;
}
+
+ if ((3 == iter % 5) && perDocAllocator.freeByteBlocks.Count > 0)
+ {
+ // Remove upwards of 32 blocks (each block is 1K)
+ for (int i = 0; i < 32; ++i)
+ {
+ perDocAllocator.freeByteBlocks.RemoveAt (perDocAllocator.freeByteBlocks.Count - 1);
+ numBytesAlloc -= PER_DOC_BLOCK_SIZE;
+ if (perDocAllocator.freeByteBlocks.Count == 0)
+ {
+ break;
+ }
+ }
+ }
+
}
- if ((3 == iter % 4) && any)
+ if ((4 == iter % 5) && any)
// Ask consumer to free any recycled state
any = consumer.FreeRAM();
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/StoredFieldsWriter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Index/StoredFieldsWriter.cs?rev=1080881&r1=1080880&r2=1080881&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/StoredFieldsWriter.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/StoredFieldsWriter.cs Sat Mar 12 07:20:44 2011
@@ -222,6 +222,8 @@ namespace Lucene.Net.Index
private void InitBlock(StoredFieldsWriter enclosingInstance)
{
this.enclosingInstance = enclosingInstance;
+ buffer = enclosingInstance.docWriter.newPerDocBuffer();
+ fdt = new RAMOutputStream(buffer);
}
private StoredFieldsWriter enclosingInstance;
public StoredFieldsWriter Enclosing_Instance
@@ -233,14 +235,14 @@ namespace Lucene.Net.Index
}
- // TODO: use something more memory efficient; for small
- // docs the 1024 buffer size of RAMOutputStream wastes alot
- internal RAMOutputStream fdt = new RAMOutputStream();
+ internal DocumentsWriter.PerDocBuffer buffer;
+ internal RAMOutputStream fdt;
internal int numStoredFields;
internal void Reset()
{
fdt.Reset();
+ buffer.recycle();
numStoredFields = 0;
}
@@ -252,7 +254,7 @@ namespace Lucene.Net.Index
public override long SizeInBytes()
{
- return fdt.SizeInBytes();
+ return buffer.GetSizeInBytes();
}
public override void Finish()
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/TermVectorsTermsWriter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Index/TermVectorsTermsWriter.cs?rev=1080881&r1=1080880&r2=1080881&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/TermVectorsTermsWriter.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/TermVectorsTermsWriter.cs Sat Mar 12 07:20:44 2011
@@ -231,8 +231,8 @@ namespace Lucene.Net.Index
tvd.WriteVLong(pos - lastPos);
lastPos = pos;
}
- perDoc.tvf.WriteTo(tvf);
- perDoc.tvf.Reset();
+ perDoc.perDocTvf.WriteTo(tvf);
+ perDoc.perDocTvf.Reset();
perDoc.numVectorFields = 0;
}
@@ -308,6 +308,8 @@ namespace Lucene.Net.Index
private void InitBlock(TermVectorsTermsWriter enclosingInstance)
{
this.enclosingInstance = enclosingInstance;
+ this.buffer = enclosingInstance.docWriter.newPerDocBuffer();
+ this.perDocTvf = new RAMOutputStream(this.buffer);
}
private TermVectorsTermsWriter enclosingInstance;
public TermVectorsTermsWriter Enclosing_Instance
@@ -319,9 +321,9 @@ namespace Lucene.Net.Index
}
- // TODO: use something more memory efficient; for small
- // docs the 1024 buffer size of RAMOutputStream wastes alot
- internal RAMOutputStream tvf = new RAMOutputStream();
+ internal DocumentsWriter.PerDocBuffer buffer;
+ internal RAMOutputStream perDocTvf;
+
internal int numVectorFields;
internal int[] fieldNumbers = new int[1];
@@ -329,7 +331,8 @@ namespace Lucene.Net.Index
internal void Reset()
{
- tvf.Reset();
+ perDocTvf.Reset();
+ buffer.recycle();
numVectorFields = 0;
}
@@ -347,13 +350,13 @@ namespace Lucene.Net.Index
fieldPointers = ArrayUtil.Grow(fieldPointers);
}
fieldNumbers[numVectorFields] = fieldNumber;
- fieldPointers[numVectorFields] = tvf.GetFilePointer();
+ fieldPointers[numVectorFields] = perDocTvf.GetFilePointer();
numVectorFields++;
}
public override long SizeInBytes()
{
- return tvf.SizeInBytes();
+ return buffer.GetSizeInBytes();
}
public override void Finish()
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/TermVectorsTermsWriterPerField.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Index/TermVectorsTermsWriterPerField.cs?rev=1080881&r1=1080880&r2=1080881&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/TermVectorsTermsWriterPerField.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/TermVectorsTermsWriterPerField.cs Sat Mar 12 07:20:44 2011
@@ -81,8 +81,8 @@ namespace Lucene.Net.Index
perThread.doc = termsWriter.GetPerDoc();
perThread.doc.docID = docState.docID;
System.Diagnostics.Debug.Assert(perThread.doc.numVectorFields == 0);
- System.Diagnostics.Debug.Assert(0 == perThread.doc.tvf.Length());
- System.Diagnostics.Debug.Assert(0 == perThread.doc.tvf.GetFilePointer());
+ System.Diagnostics.Debug.Assert(0 == perThread.doc.perDocTvf.Length());
+ System.Diagnostics.Debug.Assert(0 == perThread.doc.perDocTvf.GetFilePointer());
}
else
{
@@ -125,8 +125,8 @@ namespace Lucene.Net.Index
if (numPostings > maxNumPostings)
maxNumPostings = numPostings;
-
- IndexOutput tvf = perThread.doc.tvf;
+
+ IndexOutput tvf = perThread.doc.perDocTvf;
// This is called once, after inverting all occurences
// of a given field in the doc. At this point we flush
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/RAMFile.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Store/RAMFile.cs?rev=1080881&r1=1080880&r2=1080881&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/RAMFile.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/RAMFile.cs Sat Mar 12 07:20:44 2011
@@ -19,23 +19,24 @@ using System;
namespace Lucene.Net.Store
{
-
+
+ /** For Lucene internal use */
[Serializable]
public class RAMFile
{
private const long serialVersionUID = 1L;
- private System.Collections.ArrayList buffers = new System.Collections.ArrayList();
+ protected System.Collections.ArrayList buffers = new System.Collections.ArrayList();
internal long length;
internal RAMDirectory directory;
- internal long sizeInBytes;
+ protected internal long sizeInBytes;
// This is publicly modifiable via Directory.touchFile(), so direct access not supported
private long lastModified = (DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond);
// File used as buffer, in no RAMDirectory
- public /*internal*/ RAMFile()
+ protected internal RAMFile()
{
}
@@ -45,15 +46,15 @@ namespace Lucene.Net.Store
}
// For non-stream access from thread that might be concurrent with writing
- public /*internal*/ virtual long GetLength()
+ public virtual long GetLength()
{
lock (this)
{
return length;
}
}
-
- public /*internal*/ virtual void SetLength(long length)
+
+ public /*internal*/ virtual void SetLength(long length)
{
lock (this)
{
@@ -62,7 +63,7 @@ namespace Lucene.Net.Store
}
// For non-stream access from thread that might be concurrent with writing
- internal virtual long GetLastModified()
+ public virtual long GetLastModified()
{
lock (this)
{
@@ -70,7 +71,7 @@ namespace Lucene.Net.Store
}
}
- internal virtual void SetLastModified(long lastModified)
+ protected internal virtual void SetLastModified(long lastModified)
{
lock (this)
{
@@ -78,7 +79,7 @@ namespace Lucene.Net.Store
}
}
- internal byte[] AddBuffer(int size)
+ protected internal byte[] AddBuffer(int size)
{
byte[] buffer = NewBuffer(size);
lock (this)
@@ -97,16 +98,16 @@ namespace Lucene.Net.Store
return buffer;
}
-
- public /*internal*/ byte[] GetBuffer(int index)
+
+ public /*internal*/ byte[] GetBuffer(int index)
{
lock (this)
{
return (byte[]) buffers[index];
}
}
-
- public /*internal*/ int NumBuffers()
+
+ public /*internal*/ int NumBuffers()
{
lock (this)
{
@@ -127,14 +128,11 @@ namespace Lucene.Net.Store
}
- public /*internal*/ virtual long GetSizeInBytes()
+ public virtual long GetSizeInBytes()
{
lock (this)
{
- lock (directory)
- {
- return sizeInBytes;
- }
+ return sizeInBytes;
}
}
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/RAMOutputStream.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Store/RAMOutputStream.cs?rev=1080881&r1=1080880&r2=1080881&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/RAMOutputStream.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/RAMOutputStream.cs Sat Mar 12 07:20:44 2011
@@ -23,7 +23,7 @@ namespace Lucene.Net.Store
/// <summary> A memory-resident {@link IndexOutput} implementation.
///
/// </summary>
- /// <version> $Id: RAMOutputStream.java 691694 2008-09-03 17:34:29Z mikemccand $
+ /// <version> $Id: RAMOutputStream.java 941125 2010-05-05 00:44:15Z mikemccand $
/// </version>
public class RAMOutputStream:IndexOutput
@@ -44,7 +44,7 @@ namespace Lucene.Net.Store
{
}
- public /*internal*/ RAMOutputStream(RAMFile f)
+ public RAMOutputStream(RAMFile f)
{
file = f;
@@ -75,19 +75,14 @@ namespace Lucene.Net.Store
}
}
- /// <summary>Resets this to an empty buffer. </summary>
+ /// <summary>Resets this to an empty file. </summary>
public virtual void Reset()
- {
- try
- {
- Seek(0);
- }
- catch (System.IO.IOException e)
- {
- // should never happen
- throw new System.SystemException(e.ToString());
- }
-
+ {
+ currentBuffer = null;
+ currentBufferIndex = -1;
+ bufferPosition = 0;
+ bufferStart = 0;
+ bufferLength = 0;
file.SetLength(0);
}