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;
}
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 MetadataOnlyImage(ITemporaryStreamStorage storage, string assemblyName)
{
_storage = storage;
_assemblyName = assemblyName;
}
public static ImmutableArray <string> ReadLines(this ITemporaryStreamStorage storage)
{
return(EnumerateLines(storage).ToImmutableArray());
}
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();
}
public static string ReadString(this ITemporaryStreamStorage storage)
{
using var stream = storage.ReadStream();
using var reader = new StreamReader(stream);
return(reader.ReadToEnd());
}
