private void GetTemporaryStorage( ObjectReader reader, SerializationKinds kind, out ITemporaryStreamStorage storage, out long length, CancellationToken cancellationToken) { if (kind == SerializationKinds.Bits) { storage = _storageService.CreateTemporaryStreamStorage(cancellationToken); using (var stream = SerializableBytes.CreateWritableStream()) { CopyByteArrayToStream(reader, stream, cancellationToken); length = stream.Length; stream.Position = 0; storage.WriteStream(stream, cancellationToken); } return; } if (kind == SerializationKinds.MemoryMapFile) { var service2 = _storageService as ITemporaryStorageService2; Contract.ThrowIfNull(service2); var name = reader.ReadString(); var size = reader.ReadInt64(); storage = service2.AttachTemporaryStreamStorage(name, size, cancellationToken); length = size; return; } throw ExceptionUtilities.UnexpectedValue(kind); }
private RecoverableSyntaxRoot( RecoverableSyntaxRoot <TRoot> originalRoot, IRecoverableSyntaxTree <TRoot> containingTree) : base(originalRoot) { _service = originalRoot._service; _storage = originalRoot._storage; _containingTree = containingTree; }
public void TestTemporaryStorageMemoryMappedFileManagement() { using var workspace = new AdhocWorkspace(); var textFactory = Assert.IsType <TextFactoryService>( workspace.Services.GetService <ITextFactoryService>() ); var service = new TemporaryStorageServiceFactory.TemporaryStorageService(textFactory); var buffer = new MemoryStream(257 * 1024 + 1); for (var i = 0; i < buffer.Length; i++) { buffer.WriteByte((byte)i); } // Do a relatively cheap concurrent stress test of the backing MemoryMappedFile management var tasks = Enumerable .Range(1, 257) .Select( async i => { for (var j = 1; j < 5; j++) { using ITemporaryStreamStorage storage1 = service.CreateTemporaryStreamStorage( CancellationToken.None ), storage2 = service.CreateTemporaryStreamStorage( CancellationToken.None ); var storage3 = service.CreateTemporaryStreamStorage( CancellationToken.None ); // let the finalizer run for this instance storage1.WriteStream( new MemoryStream(buffer.GetBuffer(), 0, 1024 * i - 1) ); storage2.WriteStream(new MemoryStream(buffer.GetBuffer(), 0, 1024 * i)); storage3.WriteStream( new MemoryStream(buffer.GetBuffer(), 0, 1024 * i + 1) ); await Task.Yield(); using Stream s1 = storage1.ReadStream(), s2 = storage2.ReadStream(), s3 = storage3.ReadStream(); Assert.Equal(1024 * i - 1, s1.Length); Assert.Equal(1024 * i, s2.Length); Assert.Equal(1024 * i + 1, s3.Length); } } ); Task.WaitAll(tasks.ToArray()); GC.Collect(2); GC.WaitForPendingFinalizers(); GC.Collect(2); }
public static void WriteString(this ITemporaryStreamStorage storage, string value) { using var stream = SerializableBytes.CreateWritableStream(); using var writer = new StreamWriter(stream); writer.Write(value); writer.Flush(); stream.Position = 0; storage.WriteStream(stream); }
protected override async Task SaveAsync(TRoot root, CancellationToken cancellationToken) { Contract.ThrowIfFalse(_storage == null); // Cannot save more than once // tree will be always held alive in memory, but nodes come and go. serialize nodes to storage using var stream = SerializableBytes.CreateWritableStream(); root.SerializeTo(stream, cancellationToken); stream.Position = 0; _storage = _service.LanguageServices.WorkspaceServices.GetService <ITemporaryStorageService>().CreateTemporaryStreamStorage(cancellationToken); await _storage.WriteStreamAsync(stream, cancellationToken).ConfigureAwait(false); }
private static IEnumerable <string> EnumerateLines(ITemporaryStreamStorage storage) { using var stream = storage.ReadStream(); using var reader = new StreamReader(stream); string line; while ((line = reader.ReadLine()) != null) { yield return(line); } }
protected override async Task SaveAsync(TRoot root, CancellationToken cancellationToken) { // tree will be always held alive in memory, but nodes come and go. serialize nodes to storage using (var stream = SerializableBytes.CreateWritableStream()) { root.SerializeTo(stream, cancellationToken); stream.Position = 0; storage = this.service.LanguageServices.WorkspaceServices.GetService <ITemporaryStorageService>().CreateTemporaryStreamStorage(cancellationToken); await storage.WriteStreamAsync(stream, cancellationToken).ConfigureAwait(false); } }
private ModuleMetadata GetModuleMetadata(ITemporaryStreamStorage storage) { var stream = storage.ReadStream(CancellationToken.None); // under VS host, direct access should be supported var directAccess = (ISupportDirectMemoryAccess)stream; var pImage = directAccess.GetPointer(); var metadata = ModuleMetadata.CreateFromMetadata(pImage, (int)stream.Length); // memory management. _lifetimeMap.Add(metadata, stream); return(metadata); }
public static void WriteAllLines(this ITemporaryStreamStorage storage, ImmutableArray <string> values) { using var stream = SerializableBytes.CreateWritableStream(); using var writer = new StreamWriter(stream); foreach (var value in values) { writer.WriteLine(value); } writer.Flush(); stream.Position = 0; storage.WriteStream(stream); }
private void GetStorageInfoFromTemporaryStorage(FileKey moduleFileKey, out ITemporaryStreamStorage storage, out Stream stream, out IntPtr pImage) { int size; using (var copyStream = SerializableBytes.CreateWritableStream()) { // open a file and let it go as soon as possible using (var fileStream = FileUtilities.OpenRead(moduleFileKey.FullPath)) { var headers = new PEHeaders(fileStream); var offset = headers.MetadataStartOffset; size = headers.MetadataSize; // given metadata contains no metadata info. // throw bad image format exception so that we can show right diagnostic to user. if (size <= 0) { throw new BadImageFormatException(); } StreamCopy(fileStream, copyStream, offset, size); } // copy over the data to temp storage and let pooled stream go storage = _temporaryStorageService.CreateTemporaryStreamStorage(CancellationToken.None); copyStream.Position = 0; storage.WriteStream(copyStream); } // get stream that owns direct access memory stream = storage.ReadStream(CancellationToken.None); // stream size must be same as what metadata reader said the size should be. Contract.ThrowIfFalse(stream.Length == size); // under VS host, direct access should be supported var directAccess = (ISupportDirectMemoryAccess)stream; pImage = directAccess.GetPointer(); }
private MetadataOnlyImage(ITemporaryStreamStorage storage, string assemblyName) { _storage = storage; _assemblyName = assemblyName; }
public static ImmutableArray <string> ReadLines(this ITemporaryStreamStorage storage) { return(EnumerateLines(storage).ToImmutableArray()); }
public static string ReadString(this ITemporaryStreamStorage storage) { using var stream = storage.ReadStream(); using var reader = new StreamReader(stream); return(reader.ReadToEnd()); }