public void Dispose()
{
if (memoryMappedInfo != null)
{
// Destructors of SafeHandle and FileStream in MemoryMappedFile
// will eventually release resources if this Dispose is not called
// explicitly
memoryMappedInfo.Dispose();
memoryMappedInfo = null;
}
}
public void Dispose()
{
if (_memoryMappedInfo != null)
{
// Destructors of SafeHandle and FileStream in MemoryMappedFile
// will eventually release resources if this Dispose is not called
// explicitly
_memoryMappedInfo.Dispose();
_memoryMappedInfo = null;
}
if (_encoding != null)
{
_encoding = null;
}
}
private async Task WriteStreamMaybeAsync(Stream stream, bool useAsync, CancellationToken cancellationToken)
{
if (_memoryMappedInfo != null)
{
throw new InvalidOperationException(WorkspacesResources.Temporary_storage_cannot_be_written_more_than_once);
}
if (stream.Length == 0)
{
throw new ArgumentOutOfRangeException();
}
using (Logger.LogBlock(FunctionId.TemporaryStorageServiceFactory_WriteStream, cancellationToken))
{
var size = stream.Length;
_memoryMappedInfo = _service.CreateTemporaryStorage(size);
using var viewStream = _memoryMappedInfo.CreateWritableStream();
var buffer = SharedPools.ByteArray.Allocate();
try
{
while (true)
{
int count;
if (useAsync)
{
count = await stream.ReadAsync(buffer, 0, buffer.Length, cancellationToken).ConfigureAwait(false);
}
else
{
count = stream.Read(buffer, 0, buffer.Length);
}
if (count == 0)
{
break;
}
viewStream.Write(buffer, 0, count);
}
}
finally
{
SharedPools.ByteArray.Free(buffer);
}
}
}
public void WriteText(SourceText text, CancellationToken cancellationToken)
{
if (_memoryMappedInfo != null)
{
throw new InvalidOperationException();
}
using (Logger.LogBlock(FunctionId.TemporaryStorageServiceFactory_WriteText, cancellationToken))
{
_encoding = text.Encoding;
// the method we use to get text out of SourceText uses Unicode (2bytes per char).
var size = Encoding.Unicode.GetMaxByteCount(text.Length);
_memoryMappedInfo = _service.CreateTemporaryStorage(size);
// Write the source text out as Unicode. We expect that to be cheap.
using var stream = _memoryMappedInfo.CreateWritableStream();
using var writer = new StreamWriter(stream, Encoding.Unicode);
text.Write(writer, cancellationToken);
}
}
public void WriteText(SourceText text, CancellationToken cancellationToken)
{
if (memoryMappedInfo != null)
{
throw new InvalidOperationException();
}
using (Logger.LogBlock(FunctionId.TemporaryStorageServiceFactory_WriteText, cancellationToken))
{
var size = Encoding.Unicode.GetMaxByteCount(text.Length);
memoryMappedInfo = service.memoryMappedFileManager.CreateViewInfo(size);
using (var stream = memoryMappedInfo.CreateWritableStream())
{
// PERF: Don't call text.Write(writer) directly since it can cause multiple large string
// allocations from String.Substring. Instead use one of our pooled char[] buffers.
using (var writer = new StreamWriter(stream, Encoding.Unicode))
{
text.Write(writer, cancellationToken);
}
}
}
}
public SharedReadableStream(MemoryMappedInfo owner, MemoryMappedViewAccessor accessor, long length)
{
Contract.Assert(accessor.CanRead);
_owner = owner;
_accessor = accessor;
_current = _start = AcquirePointer(accessor);
_end = checked(_start + length);
}
public TemporaryStreamStorage(TemporaryStorageService service, string storageName, long offset, long size)
{
_service = service;
_memoryMappedInfo = new MemoryMappedInfo(storageName, offset, size);
}
public TemporaryTextStorage(TemporaryStorageService service, string storageName, long offset, long size, Encoding encoding)
{
_service = service;
_encoding = encoding;
_memoryMappedInfo = new MemoryMappedInfo(storageName, offset, size);
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
if (this.lazyPointer != IntPtr.Zero)
{
this.accessor.SafeMemoryMappedViewHandle.ReleasePointer();
this.lazyPointer = IntPtr.Zero;
}
if (this.owner != null)
{
this.owner.StreamDisposed();
this.owner = null;
}
}
public SharedReadableStream(MemoryMappedInfo owner, MemoryMappedViewAccessor accessor, long length)
{
this.owner = owner;
this.accessor = accessor;
this.length = length;
this.lazyPointer = IntPtr.Zero;
this.position = 0;
}
public SharedReadableStream(MemoryMappedInfo owner, ReferenceCountedDisposable <MemoryMappedViewAccessor> accessor, long length)
{
_accessor = accessor;
_current = _start = (byte *)_accessor.Target.SafeMemoryMappedViewHandle.DangerousGetHandle() + _accessor.Target.PointerOffset;
_end = checked (_start + length);
}
private async Task WriteStreamMaybeAsync(Stream stream, bool useAsync, CancellationToken cancellationToken)
{
if (_memoryMappedInfo != null)
{
throw new InvalidOperationException(WorkspacesResources.Temporary_storage_cannot_be_written_more_than_once);
}
if (stream.Length == 0)
{
throw new ArgumentOutOfRangeException();
}
using (Logger.LogBlock(FunctionId.TemporaryStorageServiceFactory_WriteStream, cancellationToken))
{
var size = stream.Length;
_memoryMappedInfo = _service._memoryMappedFileManager.CreateViewInfo(size);
using (var viewStream = _memoryMappedInfo.CreateWritableStream())
{
var buffer = SharedPools.ByteArray.Allocate();
try
{
while (true)
{
int count;
if (useAsync)
{
count = await stream.ReadAsync(buffer, 0, buffer.Length, cancellationToken).ConfigureAwait(false);
}
else
{
count = stream.Read(buffer, 0, buffer.Length);
}
if (count == 0)
{
break;
}
viewStream.Write(buffer, 0, count);
}
}
finally
{
SharedPools.ByteArray.Free(buffer);
}
}
}
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
if (_start != null)
{
_accessor.SafeMemoryMappedViewHandle.ReleasePointer();
_start = null;
}
if (_owner != null)
{
_owner.StreamDisposed();
_owner = null;
}
}
public TemporaryTextStorage(TemporaryStorageService service, string storageName, long size, Encoding encoding)
{
_service = service;
_encoding = encoding;
_memoryMappedInfo = new MemoryMappedInfo(storageName, size);
}
public TemporaryStreamStorage(TemporaryStorageService service, string storageName, long size)
{
_service = service;
_memoryMappedInfo = new MemoryMappedInfo(storageName, size);
}
public void WriteText(SourceText text, CancellationToken cancellationToken)
{
if (memoryMappedInfo != null)
{
throw new InvalidOperationException();
}
using (Logger.LogBlock(FeatureId.TemporaryStorage, FunctionId.Host_TemporaryStorageServiceFactory_WriteText, cancellationToken))
{
var size = Encoding.Unicode.GetMaxByteCount(text.Length);
memoryMappedInfo = service.memoryMappedFileManager.CreateViewInfo(size);
var buffer = SharedPools.CharArray.Allocate();
using (var stream = memoryMappedInfo.CreateWritableStream())
{
// PERF: Don't call text.Write(writer) directly since it can cause multiple large string
// allocations from String.Substring. Instead use one of our pooled char[] buffers.
using (var writer = new StreamWriter(stream, Encoding.Unicode))
{
for (int index = 0; index < text.Length; index += buffer.Length)
{
cancellationToken.ThrowIfCancellationRequested();
var count = Math.Min(buffer.Length, text.Length - index);
text.CopyTo(index, buffer, 0, count);
writer.Write(buffer, 0, count);
}
}
}
SharedPools.CharArray.Free(buffer);
}
}
public SharedReadableStream(MemoryMappedInfo owner, CopiedMemoryMappedViewHandle handle, long offset, long length)
{
_handle = handle;
_current = _start = handle.Pointer + offset;
_end = checked (_start + length);
}
public void WriteText(SourceText text, CancellationToken cancellationToken)
{
if (memoryMappedInfo != null)
{
throw new InvalidOperationException();
}
using (Logger.LogBlock(FeatureId.TemporaryStorage, FunctionId.Host_TemporaryStorageServiceFactory_WriteText, cancellationToken))
{
var size = Encoding.Unicode.GetMaxByteCount(text.Length);
memoryMappedInfo = service.memoryMappedFileManager.CreateViewInfo(size);
using (var stream = memoryMappedInfo.CreateWritableStream())
{
// PERF: Don't call text.Write(writer) directly since it can cause multiple large string
// allocations from String.Substring. Instead use one of our pooled char[] buffers.
using (var writer = new StreamWriter(stream, Encoding.Unicode))
{
text.Write(writer, cancellationToken);
}
}
}
}
internal MemoryMappedInfo CreateMemoryMappedViewInfo(long size)
{
lock (_gate)
{
var result = new MemoryMappedInfo(_memoryMappedFile, _freeSegmentOffsets.Pop(), size, this);
if (_freeSegmentOffsets.IsEmpty())
{
// containingList should already be locked by our caller.
_containingList.Remove(this);
}
return result;
}
}
public void WriteText(SourceText text, CancellationToken cancellationToken)
{
if (_memoryMappedInfo != null)
{
throw new InvalidOperationException();
}
using (Logger.LogBlock(FunctionId.TemporaryStorageServiceFactory_WriteText, cancellationToken))
{
_encoding = text.Encoding;
// the method we use to get text out of SourceText uses Unicode (2bytes per char).
var size = Encoding.Unicode.GetMaxByteCount(text.Length);
_memoryMappedInfo = _service._memoryMappedFileManager.CreateViewInfo(size);
// Write the source text out as Unicode. We expect that to be cheap.
using (var stream = _memoryMappedInfo.CreateWritableStream())
{
using (var writer = new StreamWriter(stream, Encoding.Unicode))
{
text.Write(writer, cancellationToken);
}
}
}
}
