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); } } } }