private void CreateFileStreams() { if (_file != null || _fileStream != null) throw new InvalidOperationException(); _file = MemoryMappedFile.CreateFromFile(FileName); _fileStream = _file.CreateViewStream(); }
private void InitializeMemoryMap() { var mmf = MemoryMappedFile.CreateOrOpen(DATA_FILE, 1024 * 10); var view = mmf.CreateViewStream(); MappedFile = mmf; ViewStream = view; LinkDataSize = Marshal.SizeOf(typeof(LinkData)); }
public MappedFileBuffer(byte[] data) { _file = MemoryMappedFile.CreateNew(Guid.NewGuid().ToString(), data.Length); _stream = _file.CreateViewStream(); _stream.Write(data, 0, data.Length); //File.WriteAllBytes(_file.Name, data); _size = (uint)data.Length; }
public SharedRingBuffer(string name, int size) { _size = size; _memory = MemoryMappedFile.CreateOrOpen(name, size + 1); _memoryStream = _memory.CreateViewStream(); _writer = new BinaryWriter(_memoryStream); _reader = new BinaryReader(_memoryStream); _writer.Write(char.MinValue); }
public HeurFacade(string mutName, string mmfName, int RegIterations) { // Time of listening before register this.Luogo1 = new Dictionary<string, Network>(); this.threshold = RegIterations; this.mut = Mutex.OpenExisting(mutName); ; this.mmf = MemoryMappedFile.OpenExisting(mmfName, MemoryMappedFileRights.FullControl, HandleInheritability.None); this.stream = mmf.CreateViewStream(0, MappedFileDimension, MemoryMappedFileAccess.Read); }
public MemoryMappedReadWriteContext(MemoryMappedViewAccessor viewAccessor, MemoryMappedViewStream viewStream, Mutex accessMutex, bool lockOnCreate) { ViewAccessor = viewAccessor; ViewStream = viewStream; _accessMutex = accessMutex; if (lockOnCreate) Lock(); }
public byte Read(long T,MemoryMappedViewStream stream){ byte[] buffer = new byte[1]; BinaryReader reader = new BinaryReader(stream); try{reader.Read(buffer,(int)Math.Floor(T/8.0),1);} catch{return default(byte);} return buffer[0]; }
public TextureDesc(System.IO.MemoryMappedFiles.MemoryMappedViewStream mmvs) { var br = new BinaryReader(mmvs); SharedHandle = br.ReadUInt32(); Width = br.ReadUInt32(); Height = br.ReadUInt32(); Format = br.ReadUInt32(); Usage = br.ReadUInt32(); Description = br.ReadBytes(256); }
public MemoryMappedFileMessageSender(string name) { _file = MemoryMappedFile.CreateOrOpen(name, SizeOfFile); _bytesWrittenAccessor = _file.CreateViewAccessor(0, SizeOfInt32); _messageCompletedAccessor = _file.CreateViewAccessor(SizeOfInt32, SizeOfBool); _stream = _file.CreateViewStream(SizeOfInt32 + SizeOfBool + SizeOfBool, SizeOfStream); _messageSendingEvent = new EventWaitHandle(false, EventResetMode.AutoReset, name + "_MessageSending"); _messageReadEvent = new EventWaitHandle(false, EventResetMode.AutoReset, name + "_MessageRead"); _messageCancelledEvent = new EventWaitHandle(false, EventResetMode.ManualReset, name + "_MessageCancelled"); _bytesWrittenEvent = new EventWaitHandle(false, EventResetMode.AutoReset, name + "_BytesWritten"); _bytesReadEvent = new EventWaitHandle(false, EventResetMode.AutoReset, name + "_BytesRead"); }
/// @brief コンストラクタ public Interprocess() { directory_ = null; view_of_directory_ = null; mutex_directory_ = null; message_ = null; view_of_message_ = null; mutex_message_ = null; size_of_directory_ = Marshal.SizeOf(typeof(Directory)); size_of_message_ = Marshal.SizeOf(typeof(Message)); Trace.WriteLine("****Interprocess: NEW"); }
//--------------------------------------------------------------------------------------- // Construction //--------------------------------------------------------------------------------------- public SharedMemory(bool create, int cbBuffer, string uniquifier) { this.theLock = new object(); this.initialized = false; this.create = create; this.disposed = false; this.cbBuffer = cbBuffer; this.uniquifier = uniquifier; this.Mutex = null; this.BufferChangedEvent = null; this.MemoryMappedFile = null; this.MemoryViewStream = null; this.Reader = null; this.Writer = null; }
protected void Dispose(bool disposing) { if (this.disposed) { return; } if (disposing) { this.stream.Dispose(); } this.stream = null; this.disposed = true; }
public ConnectImpl() { _onDataUpdatedEvent = new EventWaitHandle(true, EventResetMode.ManualReset, OnDataUpdatedEventName); _onWriteLockMutex = new Mutex(false, OnWriteLockMutexName); using (GetLock()) { try { _memoryMappedFile = MemoryMappedFile.OpenExisting(MemoryMappedFileName); } catch (FileNotFoundException) { _memoryMappedFile = MemoryMappedFile.CreateNew(MemoryMappedFileName, MemoryMappedFileSize); } _memoryMappedViewAccessor = _memoryMappedFile.CreateViewAccessor(); _memoryMappedViewStream = _memoryMappedFile.CreateViewStream(); _memoryMappedViewHandle = _memoryMappedViewStream.SafeMemoryMappedViewHandle.DangerousGetHandle(); } }
public ParityChange(Parity parity, Config config, UInt32 startBlock, UInt32 lengthInBlocks) { this.parity = parity; this.startBlock = startBlock; tempDir = config.TempDir; writingToMMF = true; UInt32 maxMMFBlocks = Parity.LengthInBlocks((long)config.MaxTempRAM * 1024 * 1024); UInt32 mmfBlocks = (lengthInBlocks < maxMMFBlocks) ? lengthInBlocks : maxMMFBlocks; try { mmf = MemoryMappedFile.CreateNew("disparity.tmp", (long)mmfBlocks * Parity.BLOCK_SIZE); mmfStream = mmf.CreateViewStream(); } catch (Exception e) { LogFile.Log("Could not create memory mapped file: " + e.Message); // We'll use a temp file only mmf = null; mmfStream = null; writingToMMF = false; } tempFileStream = null; parityBlock = new ParityBlock(parity); block = startBlock; }
private void Read(MemoryMappedViewStream stream) { try { var serializer = new BinaryFormatter(); stream.Position = 0; var timestamp = DateTime.Now; AudioDataDTO result = null; try { result = serializer.Deserialize(stream) as AudioDataDTO; } catch (SerializationException) { if (lastGuid != Guid.Empty) { Console.WriteLine("Error deserializing; resetting listener..."); lastGuid = Guid.Empty; } } if (result == null || result.Guid == lastGuid) { Thread.Sleep(1); // Drops typical CPU usage while 'idle' from 18-23% to <1% return; } lastGuid = result.Guid; var diff = timestamp - result.Timestamp; Console.WriteLine("Message in; delay: " + diff.TotalMilliseconds); Console.WriteLine(result.ToString()); } catch (Exception ex) { Console.WriteLine("Error: " + ex.Message); } }
private byte[] GetBufferFromMapped(long offset, int length) { var baseIdx = CalcIndexBase(offset); if (baseIdx != _stream.PointerOffset) _stream = _mapped.CreateViewStream(baseIdx, MemBlockSize); var start = offset - baseIdx; var len = (int)(_stream.Length - start); len = len < length ? len : length; var buff = new byte[len]; _stream.Position = start; var count = _stream.Read(buff, 0, len); if (len == count) return buff; var temp = new byte[count]; Array.Copy(buff, 0, temp, 0, count); return temp; }
public void WriteMappedToStream(Stream stream, long offset, long length, bool writeToMapped) { while (length > 0) { var source = writeToMapped ? _stream : _editBuffer; if (writeToMapped) { var idxBase = CalcIndexBase(offset); if (idxBase != _stream.PointerOffset) { _stream = _mapped.CreateViewStream(idxBase, MemBlockSize); source = _stream; } _stream.Position = offset - _stream.PointerOffset; } else _editBuffer.Position = offset; var len = length > BufferSize ? BufferSize : length; var buffer = new byte[len]; var count = source.Read(buffer, 0, (int)len); if (count <= 0) break; stream.Write(buffer, 0, count); length -= count; offset += count; } }
public FluteWriter(Flute flute, long offset = 0, long size = 0) { _flute = flute; _output = _flute._mmf.CreateViewStream(offset, size, MemoryMappedFileAccess.Write); Interlocked.Increment(ref _flute._writers); }
/// @brief Message解放 void ReleaseMessage() { if (mutex_message_ != null) { mutex_message_.Dispose(); mutex_message_ = null; } if (view_of_message_ != null) { view_of_message_.Dispose(); view_of_message_ = null; } if (message_ != null) { message_.Dispose(); message_ = null; } }
//------------------------------------------------------------------- // Private //------------------------------------------------------------------- /// @brief Directory解放 void ReleaseDirectory() { if (mutex_directory_ != null) { mutex_directory_.Dispose(); mutex_directory_ = null; } if (view_of_directory_ != null) { view_of_directory_.Dispose(); view_of_directory_ = null; } if (directory_ != null) { directory_.Dispose(); directory_ = null; } }
//------------------------------------------------------------------- // Directory //------------------------------------------------------------------- /// @brief Directory初期化 /// @todo(me) 全体的に例外処理を考慮していないコード。要注意。 public bool InitDirectory() { // 念のため解放 ReleaseDirectory(); // 仮想メモリ(Directory)の作成 /// @todo(me) あまりにも邪悪な例外処理の使い方。なんとかしたい。 MemoryMappedFile tmp_directory; bool already_exists = true; try { tmp_directory = MemoryMappedFile.OpenExisting(kDirectoryName); } catch (FileNotFoundException) { tmp_directory = MemoryMappedFile.CreateNew(kDirectoryName, size_of_directory_); already_exists = false; } // ビューの作成 MemoryMappedViewStream tmp_view_of_directory = tmp_directory.CreateViewStream(); // 最初に共有メモリを作成した場合は0クリアしておく if (!already_exists) { for (int i = 0; i < size_of_directory_; i++) { tmp_view_of_directory.Seek(i, SeekOrigin.Begin); tmp_view_of_directory.WriteByte(0); } } // Mutexの作成 Mutex tmp_mutex_directory = new Mutex(false, kDirectoryMutexName); // メンバ変数に設定 directory_ = tmp_directory; view_of_directory_ = tmp_view_of_directory; mutex_directory_ = tmp_mutex_directory; Trace.WriteLine("****Interprocess: InitDirectory Done"); return true; }
public void RunProcess(Action<Action<StringDictionary>> process, bool isService) { var key = Guid.NewGuid().GetHashCode().ToString("X"); var processMgmt = new AutoResetEvent(false); var queueMgmt = new AutoResetEvent(false); var environmentKeyRead = new AutoResetEvent(false); var handles = new List<WaitHandle> { processMgmt }; string @namespace = isService ? "Global" : "Local"; _memoryManager.Initialise(@namespace, key); _profilerRequestsInformation = new EventWaitHandle(false, EventResetMode.ManualReset, @namespace + @"\OpenCover_Profiler_Communication_SendData_Event_" + key); _informationReadyForProfiler = new EventWaitHandle(false, EventResetMode.ManualReset, @namespace + @"\OpenCover_Profiler_Communication_ReceiveData_Event_" + key); _informationReadByProfiler = new EventWaitHandle(false, EventResetMode.ManualReset, @namespace + @"\OpenCover_Profiler_Communication_ChunkData_Event_" + key); handles.Add(_profilerRequestsInformation); _messageQueue = new ConcurrentQueue<byte[]>(); using (var mmfComms = MemoryMappedFile.CreateNew(@namespace + @"\OpenCover_Profiler_Communication_MemoryMapFile_" + key, maxMsgSize)) using (_streamAccessorComms = mmfComms.CreateViewStream(0, maxMsgSize, MemoryMappedFileAccess.ReadWrite)) { ThreadPool.QueueUserWorkItem((state) => { try { process(dictionary => { if (dictionary == null) return; dictionary[@"OpenCover_Profiler_Key"] = key; dictionary[@"OpenCover_Profiler_Namespace"] = @namespace; dictionary["Cor_Profiler"] = "{1542C21D-80C3-45E6-A56C-A9C1E4BEB7B8}"; dictionary["Cor_Enable_Profiling"] = "1"; dictionary["CoreClr_Profiler"] = "{1542C21D-80C3-45E6-A56C-A9C1E4BEB7B8}"; dictionary["CoreClr_Enable_Profiling"] = "1"; environmentKeyRead.Set(); }); } finally { processMgmt.Set(); } }); ThreadPool.QueueUserWorkItem((state) => { while (true) { byte[] data; while (!_messageQueue.TryDequeue(out data)) Thread.Yield(); if (data.Length == 0) { _messageHandler.Complete(); queueMgmt.Set(); return; } _persistance.SaveVisitData(data); } }); // wait for the environment key to be read if (WaitHandle.WaitAny(new[] { environmentKeyRead }, new TimeSpan(0, 0, 0, 10)) == -1) return; _dataCommunication = new byte[maxMsgSize]; var pinnedComms = GCHandle.Alloc(_dataCommunication, GCHandleType.Pinned); try { ProcessMessages(handles, pinnedComms); } finally { pinnedComms.Free(); } queueMgmt.WaitOne(); } }
/// Message解放 private void ReleaseMessage() { if (this.mutexMessage != null) { this.mutexMessage.Dispose(); this.mutexMessage = null; } if (this.viewOfMessage != null) { this.viewOfMessage.Dispose(); this.viewOfMessage = null; } if (this.message != null) { this.message.Dispose(); this.message = null; } }
//------------------------------------------------------------------- // Message //------------------------------------------------------------------- /// @brief Message初期化 public bool InitMessage(UInt32 process_id) { // 念のため解放 ReleaseMessage(); // 仮想メモリの名前 string message_name = kMessageNamePrefix + process_id; // 仮想メモリ(Message<process_id>)の作成 MemoryMappedFile tmp_message; bool already_exists = true; try { tmp_message = MemoryMappedFile.OpenExisting(message_name); } catch (FileNotFoundException) { tmp_message = MemoryMappedFile.CreateNew(message_name, size_of_message_); already_exists = false; } // ビューの作成 MemoryMappedViewStream tmp_view_of_message = tmp_message.CreateViewStream(); // 最初に共有メモリを作成した場合は0クリアしておく if (!already_exists) { for (int i = 0; i < size_of_message_; i++) { tmp_view_of_message.Seek(i, SeekOrigin.Begin); tmp_view_of_message.WriteByte(0); } } // Mutexの名前 string message_mutex_name = kMessageMutexNamePrefix + process_id; // Mutexの作成 Mutex tmp_mutex_message = new Mutex(false, message_mutex_name); // メンバ変数に設定 message_ = tmp_message; view_of_message_ = tmp_view_of_message; mutex_message_ = tmp_mutex_message; Trace.WriteLine("****Interprocess: InitMessage Done"); return true; }
//=================================================================== // Message //=================================================================== /// Message初期化 public bool InitMessage(UInt32 processID) { // 念のため解放 this.ReleaseMessage(); // 仮想メモリの名前 string messageName = MessageNamePrefix + processID; // 仮想メモリ(Message<ProcessID>)の作成 MemoryMappedFile tmpMessage; bool alreadyExists = true; try { tmpMessage = MemoryMappedFile.OpenExisting(messageName); } catch (FileNotFoundException) { tmpMessage = MemoryMappedFile.CreateNew(messageName, this.sizeOfMessage); alreadyExists = false; } // ビューの作成 MemoryMappedViewStream tmpViewOfMessage = tmpMessage.CreateViewStream(); // 最初に共有メモリを作成した場合は0クリアしておく if (!alreadyExists) { for (int i = 0; i < this.sizeOfMessage; i++) { tmpViewOfMessage.Seek(i, SeekOrigin.Begin); tmpViewOfMessage.WriteByte(0); } } // Mutexの名前 string messageMutexName = MessageMutexNamePrefix + processID; // Mutexの作成 Mutex tmpMutexMessage = new Mutex(false, messageMutexName); // フィールドに設定 this.message = tmpMessage; this.viewOfMessage = tmpViewOfMessage; this.mutexMessage = tmpMutexMessage; Trace.WriteLine("****Interprocess: InitMessage Done"); return true; }
/// Directory解放 private void ReleaseDirectory() { if (this.mutexDirectory != null) { this.mutexDirectory.Dispose(); this.mutexDirectory = null; } if (this.viewOfDirectory != null) { this.viewOfDirectory.Dispose(); this.viewOfDirectory = null; } if (this.directory != null) { this.directory.Dispose(); this.directory = null; } }
//=================================================================== // Directory //=================================================================== /// Directory初期化 /// @todo(me) 全体的に例外処理を考慮していないコード。要注意。 /// @return 初期化が成功したか public bool InitDirectory() { // プログラム全体で一回だけCreate/CloseすればよいのでCloseはしない if (IsDirectoryInitialized()) return true; // 仮想メモリ(Directory)の作成 /// @todo(me) あまりにも邪悪な例外処理の使い方。なんとかしたい。 MemoryMappedFile tmpDirectory; bool alreadyExists = true; try { tmpDirectory = MemoryMappedFile.OpenExisting(DirectoryName); } catch (FileNotFoundException) { tmpDirectory = MemoryMappedFile.CreateNew(DirectoryName, this.sizeOfDirectory); alreadyExists = false; } // ビューの作成 MemoryMappedViewStream tmpViewOfDirectory = tmpDirectory.CreateViewStream(); // 最初に共有メモリを作成した場合は0クリアしておく if (!alreadyExists) { for (int i = 0; i < this.sizeOfDirectory; i++) { tmpViewOfDirectory.Seek(i, SeekOrigin.Begin); tmpViewOfDirectory.WriteByte(0); } } // Mutexの作成 Mutex tmpMutexDirectory = new Mutex(false, DirectoryMutexName); // フィールドに設定 this.directory = tmpDirectory; this.viewOfDirectory = tmpViewOfDirectory; this.mutexDirectory = tmpMutexDirectory; Trace.WriteLine("****Interprocess: InitDirectory Done"); return true; }
//=================================================================== // コンストラクタ/デストラクタ //=================================================================== /// コンストラクタ public Interprocess() { this.directory = null; this.viewOfDirectory = null; this.mutexDirectory = null; this.message = null; this.viewOfMessage = null; this.mutexMessage = null; this.shutdownEvent = null; this.directoryType = typeof(Directory); this.messageType = typeof(Message); this.sizeOfDirectory = Marshal.SizeOf(this.directoryType); this.sizeOfMessage = Marshal.SizeOf(this.messageType); Trace.WriteLine("****Interprocess: NEW"); }
/// <summary> /// </summary> /// <returns></returns> public bool CreateServer() { try { _memoryMappedFile = MemoryMappedFile.CreateOrOpen(_smKeyStoreName, _smKeyStoreSize); _reader = _memoryMappedFile.CreateViewAccessor(0, _smKeyStoreSize, MemoryMappedFileAccess.ReadWrite); _writer = _memoryMappedFile.CreateViewStream(0, _smKeyStoreSize, MemoryMappedFileAccess.ReadWrite); _keystoreLock = new Mutex(true, LageantLock, out _isLocked); } catch { return false; } return true; }
public DumpFileMemoryReader(string dumpFilePath) { bool dispose = true; FileStream fileStream = null; MemoryMappedFile memoryMappedFile = null; MemoryMappedViewStream stream = null; try { fileStream = new FileStream(dumpFilePath, FileMode.Open, FileAccess.Read); memoryMappedFile = MemoryMappedFile.CreateFromFile(fileStream, Guid.NewGuid().ToString(), fileStream.Length, MemoryMappedFileAccess.Read, new MemoryMappedFileSecurity(), HandleInheritability.Inheritable, false); stream = memoryMappedFile.CreateViewStream(0, fileStream.Length, MemoryMappedFileAccess.Read); stream.SafeMemoryMappedViewHandle.AcquirePointer(ref basePointer); IntPtr streamPointer = IntPtr.Zero; uint streamSize = 0; MINIDUMP_DIRECTORY directory = new MINIDUMP_DIRECTORY(); if (!MiniDumpReadDumpStream((IntPtr)basePointer, MINIDUMP_STREAM_TYPE.Memory64ListStream, ref directory, ref streamPointer, ref streamSize)) throw new Exception("Unable to read mini dump stream"); var data = (MINIDUMP_MEMORY64_LIST)Marshal.PtrToStructure(streamPointer, typeof(MINIDUMP_MEMORY64_LIST)); ulong lastEnd = data.BaseRva; ranges = new MemoryLocation[data.NumberOfMemoryRanges]; for (int i = 0; i < ranges.Length; i++) { var descriptor = (MINIDUMP_MEMORY_DESCRIPTOR64)Marshal.PtrToStructure(streamPointer + sizeof(MINIDUMP_MEMORY64_LIST) + i * sizeof(MINIDUMP_MEMORY_DESCRIPTOR64), typeof(MINIDUMP_MEMORY_DESCRIPTOR64)); ranges[i] = new MemoryLocation() { MemoryStart = descriptor.StartOfMemoryRange, MemoryEnd = descriptor.StartOfMemoryRange + descriptor.DataSize, FilePosition = lastEnd, }; lastEnd += descriptor.DataSize; } int newEnd = 0; for (int i = 1; i < ranges.Length; i++) if (ranges[i].MemoryStart == ranges[newEnd].MemoryEnd) ranges[newEnd].MemoryEnd = ranges[i].MemoryEnd; else ranges[++newEnd] = ranges[i]; newEnd++; Array.Resize(ref ranges, newEnd); finder = new MemoryRegionFinder(ranges.Select(r => new MemoryRegion { BaseAddress = r.MemoryStart, MemoryEnd = r.MemoryEnd }).ToArray()); dispose = false; } finally { if (dispose) { stream.SafeMemoryMappedViewHandle.ReleasePointer(); if (stream != null) { stream.Dispose(); } if (memoryMappedFile != null) { memoryMappedFile.Dispose(); } if (fileStream != null) { fileStream.Dispose(); } } else { this.fileStream = fileStream; this.stream = stream; this.memoryMappedFile = memoryMappedFile; } } }
public SharedMemory(string name, IntPtr size) { mmf = MemoryMappedFile.OpenExisting(name + "_CONNECT_DATA"); mmva = mmf.CreateViewAccessor(); if (mmf.SafeMemoryMappedFileHandle.IsInvalid) throw new MySqlException("Cannot open file mapping " + name); mmvs = mmf.CreateViewStream(0L, size.ToInt64()); mmva = mmf.CreateViewAccessor(0L, size.ToInt64()); }