private MemoryAccessor(MemoryMappedFile memoryMappedFile, bool usingDefaultData = false)
{
UsingDefaultData = usingDefaultData;
MemoryMappedFile = memoryMappedFile;
using (var viewAccessor = MemoryMappedFile?.CreateViewAccessor())
{
var bytesCheck = new byte[] { 0x50, 0x53, 0x2D, 0x58, 0x20, 0x45, 0x58, 0x45 };
byte[] bytes = new byte[8];
if (viewAccessor?.ReadArray(0, bytes, 0, 8) != 8)
{
MemoryMappedFile?.Dispose();
throw new Exception("This file has the wrong header size returning early.");
}
if (bytesCheck.Where((t, i) => bytes[i] != t).Any())
{
MemoryMappedFile?.Dispose();
throw new Exception("This file has the wrong header returning early.");
}
MemoryMappedFilesToBeDisposed.Add(MemoryMappedFile);
IsOpen = true;
GetData(viewAccessor);
}
}
public override void Close()
{
base.Close();
reader?.Dispose();
viewStream?.Dispose();
mappedFile?.Dispose();
fileStream?.Dispose();
}
/// <summary>
/// Dispose
/// </summary>
/// <param name="disposing"></param>
protected override void Dispose(bool disposing)
{
if (disposing)
{
m_MemoryFile?.Dispose();
m_MemoryFile = null;
}
base.Dispose(disposing);
}
public void Dispose()
{
lock (SyncLock)
{
if (IsDisposed)
{
return;
}
IsDisposed = true;
BackBufferView?.Dispose();
BackBufferFile?.Dispose();
}
}
// Инициализая файла
void InitFile()
{
if (header_mma != null)
{
header_mma.SafeMemoryMappedViewHandle.ReleasePointer();
header_mma.Dispose();
}
file?.Dispose();
file = fs.CreateMMF(Key);
header_mma = file.CreateViewAccessor(0, fs.Length, MemoryMappedFileAccess.ReadWrite);
ptr = header_mma.Pointer(0);
}
public void Dispose()
{
_reader?.Dispose();
_writer?.Dispose();
_memoryMappedFile?.Dispose();
_keystoreLock?.Close();
}
private void DisposeNativeResources()
{
if (_CharBufferBase != null)
{
_CharBufferGCHandle.Free();
_CharBufferBase = null;
}
if (_Accessor != null)
{
_Accessor.SafeMemoryMappedViewHandle.ReleasePointer();
_Accessor.Dispose();
_Accessor = null;
}
if (_MMF != null)
{
_MMF.Dispose();
_MMF = null;
}
if (_FS != null)
{
_FS.Dispose();
_FS = null;
}
}
public void Close()
{
for (int k = 0; k < oscTypes.NUM_SCENES; k++)
{
clientToOscBuff?[k].Close();
oscToClientBuff?[k].Close();
}
oscToClientBuff = clientToOscBuff = null;
if (mapAccess != null)
{
mapAccess.Write(SERVERUP_POS, 0);
MemoryMappedViewAccessor handle = mapAccess;
mapAccess = null;
handle?.Dispose();
}
// Close the file handle
if (m_hMapFile != null)
{
MemoryMappedFile handle = m_hMapFile;
m_hMapFile = null;
handle?.Dispose();
}
}
void ClosePfs()
{
accessor?.Dispose();
pfs?.Dispose();
pfs = null;
accessor = null;
}
protected override async Task <UploadResponse> InternalUploadAsync(CancellationToken cancellationToken)
{
MemoryMappedFile memoryMappedFile = null;
try
{
if (FileStream.Length > 0)
{
memoryMappedFile = CreateMemoryMappedFile();
AdjustNumberOfThreadsByFileSize();
var partSizeCalc = new PartSizeCalculator(Config.NumberOfThreads, Config.PartConfig);
await UploadChunks(
memoryMappedFile,
partSizeCalc,
Config.NumberOfThreads,
cancellationToken).ConfigureAwait(false);
if (cancellationToken.IsCancellationRequested)
{
throw CancellationException();
}
}
return(await FinishUpload(cancellationToken).ConfigureAwait(false));
}
finally
{
memoryMappedFile?.Dispose();
}
}
internal static OperationResult <InboundChannel> Open(string fullName, string name)
{
Semaphore readerSemaphore = null;
MemoryMappedFile file = null;
Semaphore exclusiveAccessSemaphore = null;
EventWaitHandle hasMessagesEvent = null;
EventWaitHandle noMessagesEvent = null;
EventWaitHandle clientConnectedEvent = null;
try
{
var readerSemaphoreOperationResult = LifecycleHelper.OpenAndSetReaderSemaphore(fullName);
if (readerSemaphoreOperationResult.Status != OperationStatus.Completed)
{
return(new OperationResult <InboundChannel>(readerSemaphoreOperationResult.Status, null));
}
readerSemaphore = readerSemaphoreOperationResult.Data;
var openCommonSharedObjectsStatus = LifecycleHelper.OpenCommonSharedObjects(fullName, out file, out exclusiveAccessSemaphore, out hasMessagesEvent, out noMessagesEvent, out clientConnectedEvent);
if (openCommonSharedObjectsStatus != OperationStatus.Completed)
{
try { readerSemaphore.Release(); } catch { }
LifecycleHelper.PlatformSpecificDispose(readerSemaphore);
}
var result = new InboundChannel(name, readerSemaphore, exclusiveAccessSemaphore, file, hasMessagesEvent, noMessagesEvent, clientConnectedEvent, null);
return(new OperationResult <InboundChannel>(OperationStatus.Completed, result));
}
catch
{
if (readerSemaphore != null)
{
try { readerSemaphore.Release(); } catch { }
LifecycleHelper.PlatformSpecificDispose(readerSemaphore);
}
LifecycleHelper.PlatformSpecificDispose(exclusiveAccessSemaphore);
file?.Dispose();
LifecycleHelper.PlatformSpecificDispose(hasMessagesEvent);
LifecycleHelper.PlatformSpecificDispose(noMessagesEvent);
LifecycleHelper.PlatformSpecificDispose(clientConnectedEvent);
throw;
}
}
/// <summary>
/// Sets the <see cref="ShuttingDown"/> flag, and disposes of the MemoryMappedFile and MemoryMappedViewAccessor.<br />
/// Attempting to read/write to the buffer after closing will result in a <see cref="System.NullReferenceException"/>.
/// </summary>
public virtual void Close()
{
if (IsOwnerOfSharedMemory && View != null)
{
// Indicates to any open instances that the owner is no longer open
#pragma warning disable 0420 // ignore ref to volatile warning - Interlocked API
Interlocked.Exchange(ref Header->Shutdown, 1);
#pragma warning restore 0420
}
// Allow additional close logic
DoClose();
// Close the MemoryMappedFile and MemoryMappedViewAccessor
if (View != null)
{
View.SafeMemoryMappedViewHandle.ReleasePointer();
View.Dispose();
}
if (Mmf != null)
{
Mmf.Dispose();
}
Header = null;
ViewPtr = null;
BufferStartPtr = null;
View = null;
Mmf = null;
}
private void CloseLogFile()
{
MemoryMappedFile mmf = Interlocked.CompareExchange(ref this.memoryMappedFile, null, this.memoryMappedFile);
if (mmf != null)
{
// Each thread has its own MemoryMappedViewStream created from the only one MemoryMappedFile.
// Once worker thread closes the MemoryMappedFile, all the ViewStream objects should be disposed
// properly.
foreach (MemoryMappedViewStream stream in this.viewStream.Values)
{
if (stream != null)
{
stream.Dispose();
}
}
mmf.Dispose();
}
FileStream fs = Interlocked.CompareExchange(
ref this.underlyingFileStreamForMemoryMappedFile,
null,
this.underlyingFileStreamForMemoryMappedFile);
fs?.Dispose();
}
private bool disposedValue = false; // To detect redundant calls
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
// release / clear up streams
if (disposing)
{
if (mappedAccess != null)
{
mappedAccess.Dispose();
}
if (mappedFile != null)
{
mappedFile.Dispose();
}
if (mapStream != null)
{
mapStream.Dispose();
}
mappedAccess = null;
mappedFile = null;
mapStream = null;
}
// no unmanaged resources e.g. AllocHGlobal etc...
disposedValue = true;
}
}
public void Dispose()
{
_allocated.Do(s => s.Dispose());
_mmap.Dispose();
_fileStream.Dispose();
_file.Dispose();
}
public void Dispose()
{
requestReadyEvent?.Dispose();
replyReadyEvent?.Dispose();
stream.Dispose();
file?.Dispose();
}
protected virtual void Dispose(bool disposing)
{
if (disposed)
{
return;
}
// Always set the dispose wait handle even when dispised by the finalizer
// otherwize the file watcher task will needleessly have to wait for its timeout.
disposeWaitHandle?.Set();
fileWatcherTask?.Wait(TinyReadWriteLock.DefaultWaitTimeout);
if (disposing)
{
memoryMappedFile.Dispose();
if (disposeLock && readWriteLock is IDisposable disposableLock)
{
disposableLock.Dispose();
}
fileWaitHandle.Dispose();
disposeWaitHandle?.Dispose();
}
disposed = true;
}
private void Dispose(bool disposing)
{
if (_disposed)
{
return;
}
ReleaseUnmanagedResources();
if (disposing)
{
// We own the _mmva, so always dispose it
_mmva?.Dispose();
var what = this;
while (what._parent != null)
{
what = what._parent;
}
if (0 == Interlocked.Decrement(ref what._references))
{
// Only dispose the _mmf if we are the last reference to it
_mmf?.Dispose();
}
}
_disposed = true;
}
public void CustomOnDestroy()
{
if (fileKeyFloat != null)
{
fileKeyFloat.Dispose();
fileKeyFloat.Close();
}
if (streamFloatValue != null)
{
streamFloatValue.Dispose();
streamFloatValue.Close();
}
if (fileHeader != null)
{
fileHeader.Dispose();
fileHeader.Close();
}
if (fileValueFloat != null)
{
fileValueFloat.Dispose();
fileValueFloat.Close();
}
}
private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
if (m_memMap != null)
{
m_memMap.Dispose();
}
}
private string ReadIPCClassNameMMF()
{
MemoryMappedFile mmf = null;
MemoryMappedViewAccessor mma = null;
try
{
byte[] buffer = new byte[128];
mmf = MemoryMappedFile.OpenExisting("DS4Windows_IPCClassName.dat");
mma = mmf.CreateViewAccessor(0, 128);
mma.ReadArray(0, buffer, 0, buffer.Length);
return(Encoding.ASCII.GetString(buffer));
}
catch (Exception)
{
// Eat all exceptions
}
finally
{
mma?.Dispose();
mmf?.Dispose();
}
return(null);
}
public void LeaveOpenRespected_OutstandingViews(bool leaveOpen)
{
const int Capacity = 4096;
using (TempFile file = new TempFile(GetTestFilePath()))
using (FileStream fs = File.Open(file.Path, FileMode.Open))
{
// Handle should still be open
SafeFileHandle handle = fs.SafeFileHandle;
Assert.False(handle.IsClosed);
// Create the map, create each of the views, then close the map
using (MemoryMappedFile mmf = MemoryMappedFile.CreateFromFile(fs, null, Capacity, MemoryMappedFileAccess.ReadWrite, HandleInheritability.None, leaveOpen))
using (MemoryMappedViewAccessor acc = mmf.CreateViewAccessor(0, Capacity))
using (MemoryMappedViewStream s = mmf.CreateViewStream(0, Capacity))
{
// Explicitly close the map. The handle should now be open iff leaveOpen.
mmf.Dispose();
Assert.NotEqual(leaveOpen, handle.IsClosed);
// But the views should still be usable.
ValidateMemoryMappedViewAccessor(acc, Capacity, MemoryMappedFileAccess.ReadWrite);
ValidateMemoryMappedViewStream(s, Capacity, MemoryMappedFileAccess.ReadWrite);
}
}
}
public void Grow(long minCapacity)
{
lock (SyncRoot) {
_fileStream?.Dispose();
_fileStream = new FileStream(_filename, FileMode.OpenOrCreate,
FileAccess.ReadWrite, FileShare.ReadWrite, 4096,
FileOptions.RandomAccess);
// NB another thread could have increase the map size and _capacity could be stale
var bytesCapacity = Math.Max(_fileStream.Length, minCapacity);
var sec = new MemoryMappedFileSecurity();
_mmf?.Dispose();
var unique = ((long)Process.GetCurrentProcess().Id << 32) | _counter++;
// NB: map name must be unique
var mmf = MemoryMappedFile.CreateFromFile(_fileStream,
$@"{Path.GetFileName(_filename)}.{unique}", bytesCapacity,
MemoryMappedFileAccess.ReadWrite, sec, HandleInheritability.Inheritable,
false);
_mmf = mmf;
unsafe
{
byte *ptr = (byte *)0;
_va = _mmf.CreateViewAccessor(0, bytesCapacity, MemoryMappedFileAccess.ReadWrite);
var sh = _va.SafeMemoryMappedViewHandle;
sh.AcquirePointer(ref ptr);
var ptrV = new IntPtr(ptr);
_buffer = new DirectBuffer(bytesCapacity, ptrV);
}
_capacity = bytesCapacity;
}
}
public static MemoryMapping Create(string path)
{
MemoryMappedFile file = null;
MemoryMappedViewAccessor accessor = null;
SafeMemoryMappedViewHandle handle = null;
MemoryMapping mapping = null;
FileStream stream = null;
byte * ptr = null;
try {
stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Delete | FileShare.ReadWrite);
file = MemoryMappedFile.CreateFromFile(stream, null, 0, MemoryMappedFileAccess.Read, null, HandleInheritability.None, true);
accessor = file.CreateViewAccessor(0, 0, MemoryMappedFileAccess.Read);
mapping = new MemoryMapping();
// we need to make sure that the handle and the acquired pointer get stored to MemoryMapping:
RuntimeHelpers.PrepareConstrainedRegions();
try { } finally {
handle = accessor.SafeMemoryMappedViewHandle;
handle.AcquirePointer(ref ptr);
if (ptr == null)
{
throw new IOException("Cannot create a file mapping");
}
mapping._handle = handle;
mapping._pointer = ptr;
mapping._capacity = accessor.Capacity;
}
} finally {
stream?.Dispose();
accessor?.Dispose();
file?.Dispose();
}
return(mapping);
}
private bool disposedValue = false; // To detect redundant calls
protected virtual void Dispose(bool disposing)
{
// Mem is a very shared construct looking to find where a consumer is causing dispose before were ready
if (!disposedValue)
{
// release / clear up streams
if (disposing)
{
if (mappedAccess != null)
{
mappedAccess.Dispose();
}
if (mappedFile != null)
{
mappedFile.Dispose();
}
if (mapStream != null)
{
mapStream.Dispose();
}
mappedAccess = null;
mappedFile = null;
mapStream = null;
}
// no unmanaged resources e.g. AllocHGlobal etc...
disposedValue = true;
}
}
public static unsafe PEReader OpenPEFile(string filePath, out MemoryMappedViewAccessor mappedViewAccessor)
{
// System.Reflection.Metadata has heuristic that tries to save virtual address space. This heuristic does not work
// well for us since it can make IL access very slow (call to OS for each method IL query). We will map the file
// ourselves to get the desired performance characteristics reliably.
FileStream fileStream = null;
MemoryMappedFile mappedFile = null;
MemoryMappedViewAccessor accessor = null;
try
{
// Create stream because CreateFromFile(string, ...) uses FileShare.None which is too strict
fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize: 1);
mappedFile = MemoryMappedFile.CreateFromFile(
fileStream, null, fileStream.Length, MemoryMappedFileAccess.Read, HandleInheritability.None, true);
accessor = mappedFile.CreateViewAccessor(0, 0, MemoryMappedFileAccess.Read);
var safeBuffer = accessor.SafeMemoryMappedViewHandle;
var peReader = new PEReader((byte *)safeBuffer.DangerousGetHandle(), (int)safeBuffer.ByteLength);
// MemoryMappedFile does not need to be kept around. MemoryMappedViewAccessor is enough.
mappedViewAccessor = accessor;
accessor = null;
return(peReader);
}
finally
{
accessor?.Dispose();
mappedFile?.Dispose();
fileStream?.Dispose();
}
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
mmva.Dispose();
mmf.Dispose();
}
}
/// <summary>
/// Close method implementation
/// </summary>
public void Close()
{
if (isopen)
{
memoryMappedFile.Dispose();
isopen = false;
}
}
public void Dispose()
{
writer.Close();
writer.Dispose();
stream.Close();
stream.Dispose();
memoryMappedFile.Dispose();
}
private void Dispose(bool disposing)
{
if (disposing)
{
_stream?.Dispose();
_memoryMappedFile?.Dispose();
}
}
public virtual DocumentText CreateDocumentText(string fileName, CompilerResults results, CompilerParameters options, ErrorNodeList errorNodes, bool canUseMemoryMap){
#if !ROTOR
if (canUseMemoryMap){
int applicableCodePage = System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ANSICodePage;
CompilerOptions coptions = options as CompilerOptions;
if (coptions != null && coptions.CodePage != null) applicableCodePage = (int)coptions.CodePage;
int asciiCodePage = System.Globalization.CultureInfo.InvariantCulture.TextInfo.ANSICodePage;
if (applicableCodePage == asciiCodePage){
//If there is no unicode signature at the start of the file, it seems reasonably safe to assume that 1 byte == 1 char
//In that case we can bypass the overhead of BCL file classes and use a memory mapped file instead.
unsafe{
try{
MemoryMappedFile mmFile = new MemoryMappedFile(fileName);
try{
byte b0 = *mmFile.Buffer;
if (b0 == 'M' && *(mmFile.Buffer+1) == 'Z'){
//This is a binary file. Give an appropriate error.
errorNodes.Add(this.CreateErrorNode(Error.IsBinaryFile, System.IO.Path.GetFullPath(fileName)));
this.ProcessErrors(options, results, errorNodes);
mmFile.Dispose();
return null;
}else if (b0 != 0xff && b0 != 0xfe && b0 != 0xef){
// No unicode signature, it seems. Go ahead and compile using the memory mapped file.
return new DocumentText(mmFile);
}
}catch(Exception e){
errorNodes.Add(this.CreateErrorNode(Error.InternalCompilerError, e.Message));
this.ProcessErrors(options, results, errorNodes);
return new DocumentText("");
}
}catch{}
}
}
}
#endif
return new DocumentText(this.ReadSourceText(fileName, options, errorNodes));
}