public void ChangeCollection() { _handle = new EventWaitHandle(false, EventResetMode.ManualReset); var test = new ObservableDictionary<int, string>(); test.Changed += Dictionary_Changed; test.Add(0, "myValue"); Assert.IsTrue(_handle.WaitOne(10), "Add() is not recognized as a change"); _handle.Reset(); test[0] = "newValue"; Assert.IsTrue(_handle.WaitOne(10), "this[] is not recognized as a change"); _handle.Reset(); test.Remove(0); Assert.IsTrue(_handle.WaitOne(10), "Remove() is not recognized as a change"); }
public override bool Execute() { try { syncEventName = new TaskItem(Guid.NewGuid().ToString()); handle = new EventWaitHandle(false, EventResetMode.ManualReset, syncEventName.ItemSpec); handle.Reset(); threadLock = GetLock(lockName); new Thread(new ThreadStart(AsyncExecute)).Start(); while (m_AsyncThreadState == ThreadState.NOT_STARTED) { Thread.Sleep(500); } return true; } catch (Exception e) { try { Log.LogErrorFromException(e); } catch { } return false; } }
protected override IMove GetNextMove_Impl(IGameBoard board) { m_GameBoard = board as GameBoard; InkCollectorStrokeEventHandler handler = new InkCollectorStrokeEventHandler(m_InkPicture_Stroke); IMove move = null; m_Waiter = new EventWaitHandle(false, EventResetMode.ManualReset); m_InkPicture.Stroke += handler; try { while (move == null) { m_Waiter.Reset(); if (m_Waiter.WaitOne()) { move = m_Move; } } } finally { m_InkPicture.Stroke -= handler; } return move; }
public void CrashTestOnMerge() { string path = Path.GetFullPath ("TestData\\CrashTestOnMerge"); using (var db = new KeyValueStore(path)) db.Truncate (); var doneSetting = new EventWaitHandle (false, EventResetMode.ManualReset, "CrashTestOnMerge"); doneSetting.Reset (); string testPath = Path.Combine (Path.GetDirectoryName (Assembly.GetExecutingAssembly ().GetName ().CodeBase), "RazorTest.exe"); var process = Process.Start (testPath, "CrashTestOnMerge"); doneSetting.WaitOne (30000); process.Kill (); process.WaitForExit (); // Open the database created by the other program using (var db = new KeyValueStore(path)) { db.Manifest.Logger = (msg) => Console.WriteLine (msg); Console.WriteLine ("Begin enumeration."); ByteArray lastKey = new ByteArray (); int ct = 0; foreach (var pair in db.Enumerate()) { ByteArray k = new ByteArray (pair.Key); Assert.True (lastKey.CompareTo (k) < 0); lastKey = k; ct++; } Assert.AreEqual (50000, ct); Console.WriteLine ("Found {0} items in the crashed database.", ct); } }
public static void Main() { // 1. 로그헬퍼 환경설정 읽기 - 클라이언트에서 xml파일로 환경설정 읽기 LogHelper.XMLConfiguratorLoader.Loader("LogHelperXMLConfigure.txt"); // 2. 프로그램 버전 설정 LogHelper.XMLConfiguratorLoader.ProgramVersion = "1.0.0.0"; // 3. 기본LogHelper를 등록 한다. LogHelper.LogHelper.AddLogHelper(LogHelperType.Default, "사용자 아이디"); _ewh = new EventWaitHandle(false, EventResetMode.AutoReset); Console.WriteLine("동기화 처리된 스레드 시작"); Thread T1 = new Thread( new ThreadStart(ThreadProc1) ); T1.Start(); _ewh.WaitOne(); Thread T2 = new Thread( new ThreadStart(ThreadProc2) ); T2.Start(); _ewh.WaitOne(); _ewh.Reset(); }
public Controller(BlockingMediator mediator) { _signal = new AutoResetEvent(false); mediator.AddSignal(_signal); dynamic config = ConfigurationManager.GetSection("delays"); var delays = new Dictionary<MessageType, int>(); foreach (string name in config) { delays[Hearts.Utility.Enum.Parse<MessageType>(name)] = int.Parse(config[name]); } foreach (var type in Hearts.Utility.Enum.GetValues<MessageType>()) { var key = type; mediator.Subscribe(type, ignore => { if (delays.ContainsKey(key)) { Thread.Sleep(delays[key]); } _signal.Reset(); if (!IsBlocking) { ThreadPool.QueueUserWorkItem(_ => _signal.Set()); } }); } }
public void LoadUserData(IList <Uri> addresses, bool IsTruncateTempDB = true) { WebHttpCrawlerClient client = new WebHttpCrawlerClient(); client.SetRequestDetail = (x) => { x._HttpWebRequest.AutomaticDecompression = DecompressionMethods.GZip; x._HttpWebRequest.Referer = "https://api.stackexchange.com/docs/users"; }; WebThreadDesigation t = new WebThreadDesigation(client); t.EventWaitHandleName = "WebThreadDesigation"; StackoverflowPageAnalysis ana = new StackoverflowPageAnalysis(); AnalysisThreadDesigation <UserInfo> a = new AnalysisThreadDesigation <UserInfo>(ana); a.EventWaitHandleName = "StackoverflowPageAnalysis"; DBThreadDesigation d = new DBThreadDesigation(); d.EventWaitHandleName = "DBThreadDesigation"; CrawlerSyncObject syscobject = new CrawlerSyncObject(); AnalysisSyncObject anasissyncObject = new AnalysisSyncObject(); SendImformation infos = new SendImformation(); infos.ConnectString = "data source=CIA-SH-svr-sis;initial catalog=stackoverflowNew;integrated security=True;"; //infos.EventhandlerName = "dbo.SuggestionStagging"; //infos.DestinationtableName = "dbo.SuggestionStagging"; infos.EventhandlerName = "UserTemp1_Tinct"; infos.DestinationtableName = "UserTemp1_Tinct"; infos.IsWantToMerged = false; infos.MergeSQlSPName = ""; EventWaitHandle eventWaitHandle1 = new System.Threading.EventWaitHandle(false, System.Threading.EventResetMode.ManualReset, t.EventWaitHandleName); eventWaitHandle1.Reset(); EventWaitHandle eventWaitHandle2 = new System.Threading.EventWaitHandle(false, System.Threading.EventResetMode.ManualReset, a.EventWaitHandleName); eventWaitHandle2.Reset(); EventWaitHandle eventWaitHandle3 = new System.Threading.EventWaitHandle(false, System.Threading.EventResetMode.ManualReset, d.EventWaitHandleName); eventWaitHandle3.Reset(); EventWaitHandle eventWaitHandle4 = new System.Threading.EventWaitHandle(false, System.Threading.EventResetMode.ManualReset, infos.EventhandlerName); eventWaitHandle4.Reset(); Task.Run(() => { t.CrawlerUris(addresses, 10, syscobject); }); Task.Run(() => { a.AnalysisResults(t.resultlists, 5, syscobject, anasissyncObject); }); Task.Run(() => { d.SendDispatchDatas <UserInfo>(ref a.datas, 500, ref anasissyncObject, infos, null); }); eventWaitHandle1.WaitOne(); eventWaitHandle2.WaitOne(); eventWaitHandle3.WaitOne(); eventWaitHandle4.WaitOne(); }
public void AsyncLookupCustomerSetsCustomerName() { string ruleSet = "Lookup"; var actual = RuleBaseClassesRoot.NewEditableRoot(ruleSet); var waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset); actual.ValidationComplete += (o, e) => waitHandle.Set(); waitHandle.Reset(); actual.CustomerId = 1; waitHandle.WaitOne(); // wait for async lookup to complete Assert.AreEqual("Rocky Lhotka", actual.Name); waitHandle.Reset(); actual.CustomerId = 2; waitHandle.WaitOne(); Assert.AreEqual("Customer_2", actual.Name); }
/// <summary> /// 开始测试初始化 /// </summary> /// <param name="type">测试类型</param> /// <param name="count">测试数量</param> internal static void Start(TestType type, int count) { LoopCount = count; ErrorCount = 0; TestType = type; WaitHandle.Reset(); Time.Restart(); }
/// <summary> /// 开始测试初始化 /// </summary> /// <param name="type">测试类型</param> /// <param name="count">测试数量</param> internal static void Start(TestType type, int count) { if (type != TestType.ClientSynchronous) { mapPointer.Clear(); } waitCount = LoopCount = count; ErrorCount = 0; TestType = type; WaitHandle.Reset(); Time.Restart(); }
/// <summary> /// 开始测试初始化 /// </summary> /// <param name="type">测试类型</param> /// <param name="count">测试数量</param> internal static void Start(TestType type, int count) { if (type != TestType.ClientSynchronous) { AutoCSer.Memory.Clear(mapPointer.ULong, mapPointer.GetSize() >> 3); } waitCount = LoopCount = count; ErrorCount = 0; TestType = type; WaitHandle.Reset(); Time.Restart(); }
/// <summary> /// Waits on 'waitEvent' with a timeout /// Before the wait 'numWaiters' is incremented and is restored before leaving this routine. /// </summary> private bool WaitOnEvent(EventWaitHandle waitEvent, ref uint numWaiters, TimeoutTracker timeout) { #if DEBUG Debug.Assert(MyLockHeld); #endif waitEvent.Reset(); numWaiters++; _fNoWaiters = false; //Setting these bits will prevent new readers from getting in. if (_numWriteWaiters == 1) { SetWritersWaiting(); } if (_numWriteUpgradeWaiters == 1) { SetUpgraderWaiting(); } bool waitSuccessful = false; ExitMyLock(); // Do the wait outside of any lock try { waitSuccessful = waitEvent.WaitOne(timeout.RemainingMilliseconds); } finally { EnterMyLock(); --numWaiters; if (_numWriteWaiters == 0 && _numWriteUpgradeWaiters == 0 && _numUpgradeWaiters == 0 && _numReadWaiters == 0) { _fNoWaiters = true; } if (_numWriteWaiters == 0) { ClearWritersWaiting(); } if (_numWriteUpgradeWaiters == 0) { ClearUpgraderWaiting(); } if (!waitSuccessful) // We may also be aboutto throw for some reason. Exit myLock. { ExitMyLock(); } } return(waitSuccessful); }
public void LoadQuestionsData(IList<Uri> addresses, bool IsTruncateTempDB = true) { WebHttpCrawlerClient client = new WebHttpCrawlerClient(); client.SetRequestDetail = (x) => { x._HttpWebRequest.AutomaticDecompression = DecompressionMethods.GZip; x._HttpWebRequest.Referer = "https://api.stackexchange.com/docs/questions"; }; WebThreadDesigation t = new WebThreadDesigation(client); t.EventWaitHandleName = "WebThreadDesigation"; StackoverflowPageAnalysis ana = new StackoverflowPageAnalysis(); AnalysisThreadDesigation<QuestionInfo> a = new AnalysisThreadDesigation<QuestionInfo>(ana); a.EventWaitHandleName = "StackoverflowPageAnalysis"; DBThreadDesigation d = new DBThreadDesigation(); d.EventWaitHandleName = "DBThreadDesigation"; CrawlerSyncObject syscobject = new CrawlerSyncObject(); AnalysisSyncObject anasissyncObject = new AnalysisSyncObject(); SendImformation infos = new SendImformation(); infos.ConnectString = "data source=CIA-SH-svr-sis;initial catalog=stackoverflowNew;integrated security=True;"; infos.EventhandlerName = "QuestionTemp1_Tinct"; infos.DestinationtableName = "QuestionTemp1_Tinct"; infos.IsWantToMerged = false; infos.MergeSQlSPName = ""; EventWaitHandle eventWaitHandle1 = new System.Threading.EventWaitHandle(false, System.Threading.EventResetMode.ManualReset, t.EventWaitHandleName); eventWaitHandle1.Reset(); EventWaitHandle eventWaitHandle2 = new System.Threading.EventWaitHandle(false, System.Threading.EventResetMode.ManualReset, a.EventWaitHandleName); eventWaitHandle2.Reset(); EventWaitHandle eventWaitHandle3 = new System.Threading.EventWaitHandle(false, System.Threading.EventResetMode.ManualReset, d.EventWaitHandleName); eventWaitHandle3.Reset(); EventWaitHandle eventWaitHandle4 = new System.Threading.EventWaitHandle(false, System.Threading.EventResetMode.ManualReset, infos.EventhandlerName); eventWaitHandle4.Reset(); Task.Run(() => { t.CrawlerUris(addresses, 10, syscobject); }); Task.Run(() => { a.AnalysisResults(t.resultlists, 5, syscobject, anasissyncObject); }); Task.Run(() => { d.SendDispatchDatas<QuestionInfo>(ref a.datas, 500, ref anasissyncObject, infos, null); }); eventWaitHandle1.WaitOne(); eventWaitHandle2.WaitOne(); eventWaitHandle3.WaitOne(); eventWaitHandle4.WaitOne(); }
static void TryDo(Action action, int timeout) { var waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset); { AsyncCallback callback = ar => waitHandle.Set(); action.BeginInvoke(callback, null); if (!waitHandle.WaitOne(timeout)) { waitHandle.Reset(); throw new TimeoutException("Failed to complete in the timeout specified."); } } }
public void Reset() { _ready.Reset(); _start.Reset(); _start.Reset(); for( int i=0; i < 100; i++ ) { using (EventWaitHandle handle = new EventWaitHandle(false, EventResetMode.ManualReset, _signal + ".ready" + i)) { if (handle.WaitOne(0, false)) handle.Reset(); else break; } } }
public void Learn() { ewh=new EventWaitHandle(false,EventResetMode.AutoReset); for (int i = 0; i <=4; i++) { Thread t=new Thread(new ParameterizedThreadStart(ThreadProc)); t.Start(i); } while (Interlocked.Read(ref threadCount)<5) { Thread.Sleep(500); } while (Interlocked.Read(ref threadCount)>0) { Console.WriteLine("Press Enter to release a waiting thread."); Console.ReadLine(); clearCount.Set(); WaitHandle.SignalAndWait(ewh, clearCount); Console.WriteLine("loop again."); } Console.WriteLine(); ewh=new EventWaitHandle(false,EventResetMode.ManualReset); for (int i = 0; i <=4; i++) { Thread t=new Thread(new ParameterizedThreadStart(ThreadProc)); t.Start(i); } while (Interlocked.Read(ref threadCount)<5) { Thread.Sleep(500); } Console.WriteLine("Press ENTER to release the waiting threads"); Console.ReadLine(); ewh.Set(); ewh.Reset(); Console.WriteLine("Press ENTER to release the waiting threads"); Console.ReadLine(); ewh.Set(); }
private bool WaitOnEvent(EventWaitHandle waitEvent, ref uint numWaiters, int millisecondsTimeout) { waitEvent.Reset(); numWaiters++; this.fNoWaiters = false; if (this.numWriteWaiters == 1) { this.SetWritersWaiting(); } if (this.numWriteUpgradeWaiters == 1) { this.SetUpgraderWaiting(); } bool flag = false; this.ExitMyLock(); try { flag = waitEvent.WaitOne(millisecondsTimeout);//, false); } finally { this.EnterMyLock(); numWaiters--; if (((this.numWriteWaiters == 0) && (this.numWriteUpgradeWaiters == 0)) && ((this.numUpgradeWaiters == 0) && (this.numReadWaiters == 0))) { this.fNoWaiters = true; } if (this.numWriteWaiters == 0) { this.ClearWritersWaiting(); } if (this.numWriteUpgradeWaiters == 0) { this.ClearUpgraderWaiting(); } if (!flag) { this.ExitMyLock(); } } return(flag); }
static void Main(string[] args) { Server _server = null; Application _application = null; Query _results; //InputAdapter Config InputConfig _inputConfig = new InputConfig(); string _stopSignalName = "TimeToStop"; EventWaitHandle _adapterStopSignal = new EventWaitHandle(false, EventResetMode.ManualReset, _stopSignalName); try { // Creating the server and application _server = Server.Create("localhost"); _application = _server.CreateApplication("TwitterStream"); var input = CepStream<TweetsType>.Create("TwitterInputStream", typeof(InputFactory), _inputConfig, EventShape.Point); var query1 = from s in input group s by s.HashTag into grp from win in grp.TumblingWindow(TimeSpan.FromSeconds(10), HoppingWindowOutputPolicy.ClipToWindowEnd) select new { HashTag = grp.Key, cnt = win.Count() }; _results = query1.ToQuery(_application, "TweetsCount", "Data Query2", typeof(TotalCountOutputFactory), _stopSignalName, EventShape.Point, StreamEventOrder.FullyOrdered); _adapterStopSignal.Reset(); //Start the Query _results.Start(); //_results2.Start(); } catch (Exception e) { Console.WriteLine(e.Message); Console.ReadLine(); } }
private bool WaitOnEvent(EventWaitHandle waitEvent, ref uint numWaiters, int millisecondsTimeout) { waitEvent.Reset(); numWaiters += 1u; bool flag = false; this.ExitMyLock(); try { flag = waitEvent.WaitOne(millisecondsTimeout, false); } finally { this.EnterMyLock(); numWaiters -= 1u; if (!flag) { this.ExitMyLock(); } } return(flag); }
/// <summary> /// Waits on 'waitEvent' with a timeout of 'millisceondsTimeout. /// Before the wait 'numWaiters' is incremented and is restored before leaving this routine. /// </summary> bool WaitOnEvent(EventWaitHandle waitEvent, ref uint numWaiters, int millisecondsTimeout) { Debug.Assert(MyLockHeld); waitEvent.Reset(); numWaiters++; bool waitSuccessful = false; // Do the wait outside of any lock ExitMyLock(); try { waitSuccessful = waitEvent.WaitOne(millisecondsTimeout, false); } finally { EnterMyLock(); --numWaiters; if (!waitSuccessful) { ExitMyLock(); } } return(waitSuccessful); }
public void PingPong(EventResetMode mode) { // Create names for the two events string outboundName = Guid.NewGuid().ToString("N"); string inboundName = Guid.NewGuid().ToString("N"); // Create the two events and the other process with which to synchronize using (var inbound = new EventWaitHandle(true, mode, inboundName)) using (var outbound = new EventWaitHandle(false, mode, outboundName)) using (var remote = RemoteInvoke(PingPong_OtherProcess, mode.ToString(), outboundName, inboundName)) { // Repeatedly wait for one event and then set the other for (int i = 0; i < 10; i++) { Assert.True(inbound.WaitOne(FailWaitTimeoutMilliseconds)); if (mode == EventResetMode.ManualReset) { inbound.Reset(); } outbound.Set(); } } }
/// <summary> /// Waits on 'waitEvent' with a timeout of 'millisecondsTimeout. /// Before the wait 'numWaiters' is incremented and is restored before leaving this routine. /// </summary> /// <param name="waitEvent"> /// The wait Event. /// </param> /// <param name="numWaiters"> /// The num Waiters. /// </param> /// <param name="millisecondsTimeout"> /// The milliseconds Timeout. /// </param> private void WaitOnEvent(EventWaitHandle waitEvent, ref uint numWaiters, int millisecondsTimeout) { Debug.Assert(this.MyLockHeld); waitEvent.Reset(); numWaiters++; bool waitSuccessful = false; this.ExitMyLock(); // Do the wait outside of any lock try { #if !NETCF if (!waitEvent.WaitOne(millisecondsTimeout)) { throw new InvalidOperationException("ReaderWriterLock timeout expired"); } #else if (!waitEvent.WaitOne(millisecondsTimeout, false)) { throw new InvalidOperationException("ReaderWriterLock timeout expired"); } #endif waitSuccessful = true; } finally { this.EnterMyLock(); --numWaiters; if (!waitSuccessful) { // We are going to throw for some reason. Exit myLock. this.ExitMyLock(); } } }
static void Main(string[] args) { Server _server = null; Application _application = null; Query _results, _results2; //InputAdapter Config InputConfig _inputConfig = new InputConfig(); string _stopSignalName = "TimeToStop"; EventWaitHandle _adapterStopSignal = new EventWaitHandle(false, EventResetMode.ManualReset, _stopSignalName); try { // Creating the server and application _server = Server.Create("localhost"); _application = _server.CreateApplication("TwitterStream"); var input = CepStream<TweetsType>.Create("TwitterInputStream", typeof(InputFactory), _inputConfig, EventShape.Point); var query1 = from e in input select new { text = e.Text, createdAt = e.CreatedAt, location=e.Location, lang=e.Lang, tweetid=e.TweetID, followercnt=e.FollowersCount, friendscnt=e.FriendsCount, hash = e.HashTag, userName = e.UserName, timeZone=e.TimeZone, lat = e.Latitude, lon = e.Longitude }; _results = query1.ToQuery(_application, "TweetsData", "Data Query", typeof(OutputFactory), _stopSignalName, EventShape.Point, StreamEventOrder.FullyOrdered); _adapterStopSignal.Reset(); //Start the Query _results.Start(); } catch (Exception e) { Console.WriteLine(e.Message); Console.ReadLine(); } }
private void WaitOnEvent(EventWaitHandle waitEvent, ref uint numWaiters, int millisecondsTimeout) { waitEvent.Reset(); numWaiters++; bool waitSuccessful = false; ExitMyLock(); try { if (!waitEvent.WaitOne(millisecondsTimeout)) { throw new InvalidOperationException("ReaderWriterLock timeout expired"); } waitSuccessful = true; } finally { EnterMyLock(); --numWaiters; if (!waitSuccessful) { ExitMyLock(); } } }
/// <summary> /// Waits on 'waitEvent' with a timeout of 'millisceondsTimeout. /// Before the wait 'numWaiters' is incremented and is restored before leaving this routine. /// </summary> private void WaitOnEvent(EventWaitHandle waitEvent, ref uint numWaiters, int millisecondsTimeout) { Debug.Assert(IsLockHeld); waitEvent.Reset(); numWaiters++; bool waitSuccessful = false; ExitLock(); // Do the wait outside of any lock try { #if SILVERLIGHT if (!waitEvent.WaitOne(millisecondsTimeout)) throw new Exception("ReaderWriterLock timeout expired"); #else if (!waitEvent.WaitOne(millisecondsTimeout, false)) throw new Exception("ReaderWriterLock timeout expired"); #endif waitSuccessful = true; } finally { EnterLock(); --numWaiters; if (!waitSuccessful) // We are going to throw for some reason. Exit myLock. ExitLock(); } }
private static void AddRemoveItems(ConcurrentQueue<Tuple<bool, IRoundRobinWorker>> addRemoveQueue, EventWaitHandle waitHandle, List<IRoundRobinWorker> workers) { waitHandle.Reset(); Tuple<bool, IRoundRobinWorker> worker; while (addRemoveQueue.TryDequeue(out worker)) { if (worker.Item1) { // Add workers.Add(worker.Item2); } else { // Remove int index = 0; while (index < workers.Count) { if (workers[index].Token == worker.Item2.Token) { workers.RemoveAt(index); // there should never be more than one, but just loop through them all to be sure } else { index++; } } } } }
/// <summary> /// Waits on 'waitEvent' with a timeout /// Before the wait 'numWaiters' is incremented and is restored before leaving this routine. /// </summary> private bool WaitOnEvent( EventWaitHandle waitEvent, ref uint numWaiters, TimeoutTracker timeout, bool isWriteWaiter) { #if DEBUG Debug.Assert(MyLockHeld); #endif waitEvent.Reset(); numWaiters++; _fNoWaiters = false; //Setting these bits will prevent new readers from getting in. if (_numWriteWaiters == 1) SetWritersWaiting(); if (_numWriteUpgradeWaiters == 1) SetUpgraderWaiting(); bool waitSuccessful = false; ExitMyLock(); // Do the wait outside of any lock try { waitSuccessful = waitEvent.WaitOne(timeout.RemainingMilliseconds); } finally { EnterMyLock(); --numWaiters; if (_numWriteWaiters == 0 && _numWriteUpgradeWaiters == 0 && _numUpgradeWaiters == 0 && _numReadWaiters == 0) _fNoWaiters = true; if (_numWriteWaiters == 0) ClearWritersWaiting(); if (_numWriteUpgradeWaiters == 0) ClearUpgraderWaiting(); if (!waitSuccessful) // We may also be about to throw for some reason. Exit myLock. { if (isWriteWaiter && _numWriteWaiters == 0 && _numWriteUpgradeWaiters == 0 && !_fNoWaiters) { // Write waiters block read waiters from acquiring the lock. Since this was the last write waiter and // there is a read waiter, wake up the appropriate read waiters. ExitAndWakeUpAppropriateReadWaiters(); } else ExitMyLock(); } } return waitSuccessful; }
//-------------------------------------------------------------------------- // Data Reception //-------------------------------------------------------------------------- // http://www.beefycode.com/post/Using-Overlapped-IO-from-Managed-Code.aspx #pragma warning disable 0618 // warning CS0618: 'System.Threading.WaitHandle.Handle' is obsolete: 'Use the SafeWaitHandle property instead.' unsafe void ReadThread(ThreadContext ctx) { System.Threading.Thread.CurrentThread.Name = "USBConnection.ReadThread"; EventWaitHandle asyncReadCompleteEvent = new EventWaitHandle(false, System.Threading.EventResetMode.ManualReset); NativeOverlapped* pNativeOverlapped = null; byte[] rgbBuffer = new byte[64]; try { WaitHandle[] waitHandles = new WaitHandle[2]; waitHandles[0] = asyncReadCompleteEvent; waitHandles[1] = ctx.StopEvent; // // If we get unexpected errors, we stop reading; likely these are caused by a device // in the process of disconnecting. // bool fStop = false; // while (!fStop && !ctx.StopRequest) { // Issue an async read // asyncReadCompleteEvent.Reset(); Overlapped overlapped = new Overlapped(0, 0, asyncReadCompleteEvent.Handle, null); pNativeOverlapped = overlapped.Pack(null, rgbBuffer); int cbRead = 0; // Program.Trace("issuing async read: 0x{0:08X} 0x{1:08X}", new IntPtr(pNativeOverlappedWrite), this.hWinUSB); bool fSuccess = WinUsb_ReadPipe( this.hWinUSB, bulkInPipe, rgbBuffer, rgbBuffer.Length, out cbRead, new IntPtr(pNativeOverlapped)); this.readThreadRunning.Set(); if (!fSuccess) { int err = Marshal.GetLastWin32Error(); if (err != ERROR_IO_PENDING) { Program.Trace("USB Read: WinUsb_ReadPipe=={0}", err); fStop = true; continue; } } // Wait until either the async read completes or we're asked to stop int iWait = WaitHandle.WaitAny(waitHandles); // Process according to which event fired switch (iWait) { case 0: // Async read completed { // Program.Trace("async read complete: 0x{0:08X} 0x{1:08X}", new IntPtr(pNativeOverlappedWrite), this.hWinUSB); if (WinUsb_GetOverlappedResult(this.hWinUSB, new IntPtr(pNativeOverlapped), ref cbRead, System.Convert.ToByte(true))) { ProcessIncomingPacket(rgbBuffer, cbRead); } else { int err = Marshal.GetLastWin32Error(); Program.Trace("USB Read: WinUsb_GetOverlappedResult=={0}", err); fStop = true; } // System.Threading.Overlapped.Free(pNativeOverlapped); pNativeOverlapped = null; } break; case 1: // StopEvent // Program.Trace("async read stop requested"); break; // end switch } } } finally { // Program.Trace("async cleanup: 0x{0:08X} 0x{1:08X}", new IntPtr(pNativeOverlappedWrite), this.hWinUSB); WinUsb_AbortPipe(this.hWinUSB, bulkInPipe); asyncReadCompleteEvent.Close(); if (pNativeOverlapped != null) { System.Threading.Overlapped.Free(pNativeOverlapped); pNativeOverlapped = null; } } }
//-------------------------------------------------------------------------- // Data reception //-------------------------------------------------------------------------- unsafe void ReadThread(ThreadContext ctx) { System.Threading.Thread.CurrentThread.Name = "BluetoothConnection.ReadThread"; EventWaitHandle asyncReadCompleteEvent = new EventWaitHandle(false, System.Threading.EventResetMode.ManualReset); NativeOverlapped* pNativeOverlapped = null; byte[] rgbBuffer = new byte[64]; try { WaitHandle[] waitHandles = new WaitHandle[2]; waitHandles[0] = asyncReadCompleteEvent; waitHandles[1] = ctx.StopEvent; // while (!ctx.StopRequest) { // Issue an async read // asyncReadCompleteEvent.Reset(); Overlapped overlapped = new Overlapped(0, 0, asyncReadCompleteEvent.SafeWaitHandle.DangerousGetHandle(), null); pNativeOverlapped = overlapped.Pack(null, rgbBuffer); int cbRead = 0; bool fSuccess = ReadFile(this.hSerialPort, rgbBuffer, rgbBuffer.Length, out cbRead, new IntPtr(pNativeOverlapped)); readThreadRunning.Set(); if (!fSuccess) { int err = Marshal.GetLastWin32Error(); if (err != ERROR_IO_PENDING) ThrowWin32Error(err); } // Wait until either the async read completes or we're asked to stop int iWait = WaitHandle.WaitAny(waitHandles); // Process according to which event fired switch (iWait) { case 0: // Async read completed { ThrowIfFail(GetOverlappedResult(this.hSerialPort, new IntPtr(pNativeOverlapped), ref cbRead, System.Convert.ToByte(true))); // Program.Trace("async read complete: 0x{0:08X} 0x{1:08X} cb={2}", new IntPtr(pNativeOverlapped), this.hSerialPort, cbRead); // Record the new data and process any packets that are now complete this.RecordIncomingData(rgbBuffer, cbRead); ProcessPacketIfPossible(); System.Threading.Overlapped.Free(pNativeOverlapped); pNativeOverlapped = null; } break; case 1: // StopEvent break; // end switch } } } finally { CancelIo(this.hSerialPort); asyncReadCompleteEvent.Close(); if (pNativeOverlapped != null) { System.Threading.Overlapped.Free(pNativeOverlapped); pNativeOverlapped = null; } } }
/// <summary> /// Waits on 'waitEvent' with a timeout /// Before the wait 'numWaiters' is incremented and is restored before leaving this routine. /// </summary> private bool WaitOnEvent(EventWaitHandle waitEvent, ref uint numWaiters, TimeoutTracker timeout) { #if DEBUG Debug.Assert(MyLockHeld); #endif waitEvent.Reset(); numWaiters++; fNoWaiters = false; //Setting these bits will prevent new readers from getting in. if (numWriteWaiters == 1) SetWritersWaiting(); if (numWriteUpgradeWaiters == 1) SetUpgraderWaiting(); bool waitSuccessful = false; ExitMyLock(); // Do the wait outside of any lock try { waitSuccessful = waitEvent.WaitOne(timeout.RemainingMilliseconds); } finally { EnterMyLock(); --numWaiters; if (numWriteWaiters == 0 && numWriteUpgradeWaiters == 0 && numUpgradeWaiters == 0 && numReadWaiters == 0) fNoWaiters = true; if (numWriteWaiters == 0) ClearWritersWaiting(); if (numWriteUpgradeWaiters == 0) ClearUpgraderWaiting(); if (!waitSuccessful) // We may also be aboutto throw for some reason. Exit myLock. ExitMyLock(); } return waitSuccessful; }
public GpgInterfaceResult Execute() { GpgInterfaceResult result = null; try { lock (_alreadyUsedLock) { if (_alreadyUsed) throw new GpgInterfaceAlreadyUsed(); _alreadyUsed = true; } if (!File.Exists(GpgInterface.ExePath)) throw new FileNotFoundException(null, GpgInterface.ExePath); _outputEventWait = new ManualResetEvent(false); _abortedEventWait = new ManualResetEvent(false); _exitedEventWait = new ManualResetEvent(false); Log("Execute " + this); result = GpgInterfaceResult.Started; EmitEvent(result); result = BeforeStartProcess(); if (result.Status != GpgInterfaceStatus.Success) { EmitEvent(result); return result; } _process = GetProcess(Arguments()); _process.Exited += delegate(Object sender, EventArgs args) { _processExited = true; _exitedEventWait.Set(); }; _process.EnableRaisingEvents = true; _process.Start(); _process.BeginErrorReadLine(); _outputThread = new Thread(OutputReader) { Name = ToString() + " - OutputReader" }; _outputThread.Start(); while (WaitHandle.WaitAny(new WaitHandle[] { _outputEventWait, _abortedEventWait, _exitedEventWait }) != -1) { if (_aborted) break; if (_processExited) { if (_outputThread != null) _outputThread.Join(); _outputThread = null; } _outputEventWait.Reset(); GpgOutput output; while (!_aborted && _output.TryDequeue(out output)) { Log(output.Str); result = ProcessLine(output.Str); if (result.Status == GpgInterfaceStatus.Success) continue; EmitEvent(result); if (result.Status == GpgInterfaceStatus.Error) { _aborted = true; break; } } if (_processExited && _outputThread == null) break; } if (!_aborted) { result = GpgInterfaceResult.Success; EmitEvent(result); } else if (_aborted && result.Status != GpgInterfaceStatus.Error) { result = GpgInterfaceResult.UserAbort; EmitEvent(result); } Log("Exit"); } catch (Exception e) { result = new GpgInterfaceResult(GpgInterfaceStatus.Error, GpgInterfaceMessage.None, e); EmitEvent(result); } finally { CleanUp(); } return result; }
protected virtual void Start() { if (ProcessHelper.IsLocalMachine(this.MachineName)) { if (process == null) { waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset, waitHandleName); waitHandle.Reset(); ProcessStartInfo processStartInfo = new ProcessStartInfo(); processStartInfo.FileName = ExecutablePath; if (AstoriaTestProperties.RuntimeEnvironment == TestRuntimeEnvironment.CheckinSuites) { processStartInfo.CreateNoWindow = true; processStartInfo.UseShellExecute = false; } if (AstoriaTestProperties.Host == Host.IDSH) processStartInfo.Arguments = ServiceRootUri + " false" + " " + waitHandleName; else if (AstoriaTestProperties.Host == Host.IDSH2) processStartInfo.Arguments = ServiceRootUri + " true" + " " + waitHandleName; else processStartInfo.Arguments = ServiceRootUri + " " + waitHandleName; process = Process.Start(processStartInfo); } } }
/// <summary> /// Waits on 'waitEvent' with a timeout of 'millisceondsTimeout. /// Before the wait 'numWaiters' is incremented and is restored before leaving this routine. /// </summary> bool WaitOnEvent(EventWaitHandle waitEvent, ref uint numWaiters, int millisecondsTimeout) { Debug.Assert (MyLockHeld); waitEvent.Reset (); numWaiters++; bool waitSuccessful = false; // Do the wait outside of any lock ExitMyLock(); try { waitSuccessful = waitEvent.WaitOne (millisecondsTimeout, false); } finally { EnterMyLock (); --numWaiters; if (!waitSuccessful) ExitMyLock (); } return waitSuccessful; }
public static void Start() { if (_listenTask == null) { lock (typeof (Monitor)) { _cancellationTokenSource = new CancellationTokenSource(); bool wasCreated; var ewhSec = new EventWaitHandleSecurity(); ewhSec.AddAccessRule( new EventWaitHandleAccessRule( new SecurityIdentifier(WellKnownSidType.WorldSid, null), EventWaitHandleRights.FullControl, AccessControlType.Allow)); var sessionAckEvent = new EventWaitHandle(false, EventResetMode.AutoReset, "DBWIN_BUFFER_READY", out wasCreated, ewhSec); var sessionReadyEvent = new EventWaitHandle(false, EventResetMode.AutoReset, "DBWIN_DATA_READY", out wasCreated, ewhSec); var globalAckEvent = new EventWaitHandle(false, EventResetMode.AutoReset, "Global\\DBWIN_BUFFER_READY", out wasCreated, ewhSec); var globalReadyEvent = new EventWaitHandle(false, EventResetMode.AutoReset, "Global\\DBWIN_DATA_READY", out wasCreated, ewhSec); var sd = new SECURITY_DESCRIPTOR(); var sa = new SECURITY_ATTRIBUTES(); // Initialize the security descriptor. if (!Advapi32.InitializeSecurityDescriptor(ref sd, 1)) { throw new ApplicationException( string.Format("{0}. Last Win32 Error was {1}", "Failed to initializes the security descriptor.", Marshal.GetLastWin32Error())); } // Set information in a discretionary access control list if (!Advapi32.SetSecurityDescriptorDacl(ref sd, true, IntPtr.Zero, false)) { throw new ApplicationException( string.Format("{0}. Last Win32 Error was {1}", "Failed to initializes the security descriptor", Marshal.GetLastWin32Error())); } // Create the event for slot 'DBWIN_BUFFER_READY' sa.nLength = Marshal.SizeOf(sa); sa.lpSecurityDescriptor = Marshal.AllocHGlobal(Marshal.SizeOf(sd)); Marshal.StructureToPtr(sd, sa.lpSecurityDescriptor, false); // Get a handle to the readable shared memory at slot 'DBWIN_BUFFER'. var sessionSharedFileHandle = Kernel32.CreateFileMapping(new IntPtr(-1), ref sa, PageProtection.ReadWrite, 0, 4096, "DBWIN_BUFFER"); if (sessionSharedFileHandle == IntPtr.Zero) { throw new ApplicationException( string.Format( "{0}. Last Win32 Error was {1}", "Failed to create a file mapping to slot 'DBWIN_BUFFER'", Marshal.GetLastWin32Error())); } // Create a view for this file mapping so we can access it var sessionSharedMemoryHandle = Kernel32.MapViewOfFile(sessionSharedFileHandle, /*SECTION_MAP_READ*/ 0x0004, 0, 0, 4096); if (sessionSharedMemoryHandle == IntPtr.Zero) { throw new ApplicationException( string.Format( "{0}. Last Win32 Error was {1}", "Failed to create a mapping view for slot 'DBWIN_BUFFER'", Marshal.GetLastWin32Error())); } // Get a handle to the readable shared memory at slot 'DBWIN_BUFFER'. var globalSharedFileHandle = Kernel32.CreateFileMapping(new IntPtr(-1), ref sa, PageProtection.ReadWrite, 0, 4096, "Global\\DBWIN_BUFFER"); if (globalSharedFileHandle == IntPtr.Zero) { throw new ApplicationException( string.Format( "{0}. Last Win32 Error was {1}", "Failed to create a file mapping to slot 'Global\\DBWIN_BUFFER'", Marshal.GetLastWin32Error())); } // Create a view for this file mapping so we can access it var globalSharedMemoryHandle = Kernel32.MapViewOfFile(globalSharedFileHandle, /*SECTION_MAP_READ*/ 0x0004, 0, 0, 4096); if (globalSharedMemoryHandle == IntPtr.Zero) { throw new ApplicationException( string.Format( "{0}. Last Win32 Error was {1}", "Failed to create a mapping view for slot 'Global\\DBWIN_BUFFER'", Marshal.GetLastWin32Error())); } var queue = new Queue<Tuple<int, DateTime, string>>(); var dataAvailable = new ManualResetEvent(true); _listenTask = Task.Factory.StartNew( () => { // Everything after the first DWORD is our debugging text IntPtr sessionStringPointer; IntPtr globalStringPointer; if (Environment.Is64BitProcess) { sessionStringPointer = new IntPtr(sessionSharedMemoryHandle.ToInt64() + Marshal.SizeOf(typeof (int))); globalStringPointer = new IntPtr(globalSharedMemoryHandle.ToInt64() + Marshal.SizeOf(typeof (int))); } else { sessionStringPointer = new IntPtr(sessionSharedMemoryHandle.ToInt32() + Marshal.SizeOf(typeof (int))); globalStringPointer = new IntPtr(globalSharedMemoryHandle.ToInt32() + Marshal.SizeOf(typeof (int))); } while (!_cancellationTokenSource.IsCancellationRequested) { sessionAckEvent.Set(); globalAckEvent.Set(); try { var i = WaitHandle.WaitAny(new[] { sessionReadyEvent, globalReadyEvent, _cancellationTokenSource.Token.WaitHandle }); var now = DateTime.Now; if (i == 0) { lock (queue) { queue.Enqueue(new Tuple<int, DateTime, string>(Marshal.ReadInt32(sessionSharedMemoryHandle), now, Marshal.PtrToStringAnsi(sessionStringPointer))); dataAvailable.Set(); } } if (i == 1) { lock (queue) { queue.Enqueue(new Tuple<int, DateTime, string>(Marshal.ReadInt32(globalSharedMemoryHandle), now, Marshal.PtrToStringAnsi(globalStringPointer))); dataAvailable.Set(); } } } catch { // it's over. _cancellationTokenSource.Cancel(); } } _listenTask = null; // cleanup after stopping. globalAckEvent.Reset(); globalAckEvent.Dispose(); globalAckEvent = null; sessionAckEvent.Reset(); sessionAckEvent.Dispose(); sessionAckEvent = null; globalReadyEvent.Reset(); globalReadyEvent.Dispose(); globalReadyEvent = null; sessionReadyEvent.Reset(); sessionReadyEvent.Dispose(); sessionReadyEvent = null; // Close SharedFile if (sessionSharedFileHandle != IntPtr.Zero) { if (!Kernel32.CloseHandle(sessionSharedFileHandle)) { throw new ApplicationException( string.Format("{0}. Last Win32 Error was {1}", "Failed to close handle for 'SharedFile'", Marshal.GetLastWin32Error())); } sessionSharedFileHandle = IntPtr.Zero; } // Unmap SharedMem if (sessionSharedMemoryHandle != IntPtr.Zero) { if (!Kernel32.UnmapViewOfFile(sessionSharedMemoryHandle)) { throw new ApplicationException( string.Format( "{0}. Last Win32 Error was {1}", "Failed to unmap view for slot 'DBWIN_BUFFER'", Marshal.GetLastWin32Error())); } sessionSharedMemoryHandle = IntPtr.Zero; } // Close SharedFile if (globalSharedFileHandle != IntPtr.Zero) { if (!Kernel32.CloseHandle(globalSharedFileHandle)) { throw new ApplicationException( string.Format("{0}. Last Win32 Error was {1}", "Failed to close handle for 'SharedFile'", Marshal.GetLastWin32Error())); } globalSharedFileHandle = IntPtr.Zero; } // Unmap SharedMem if (globalSharedMemoryHandle != IntPtr.Zero) { if (!Kernel32.UnmapViewOfFile(globalSharedMemoryHandle)) { throw new ApplicationException( string.Format( "{0}. Last Win32 Error was {1}", "Failed to unmap view for slot 'Global\\DBWIN_BUFFER'", Marshal.GetLastWin32Error())); } globalSharedMemoryHandle = IntPtr.Zero; } }, _cancellationTokenSource.Token); Task.Factory.StartNew(() => { // handle events on seperate task to minimize the work that is done blocking the handles Tuple<int, DateTime, string> item = null; while (WaitHandle.WaitAny(new[] { dataAvailable, _cancellationTokenSource.Token.WaitHandle }) == 0) { lock (queue) { if (queue.Count > 0) { item = queue.Dequeue(); } if (queue.Count == 0) { dataAvailable.Reset(); } } if (item == null || OnOutputDebugString == null) { continue; } try { OnOutputDebugString(new OutputDebugStringEventArgs(item.Item1, item.Item2, item.Item3)); } catch { // if it's taken, good, if not--well too bad! } } }, _cancellationTokenSource.Token); } } }
/// <summary> /// Waits on 'waitEvent' with a timeout of 'millisceondsTimeout. Before the wait 'numWaiters' is incremented and is /// restored before leaving this routine. /// </summary> private void WaitOnEvent(EventWaitHandle waitEvent, ref uint numWaiters, int millisecondsTimeout) { waitEvent.Reset(); numWaiters++; bool waitSuccessful = false; ExitMyLock(); // Do the wait outside of any lock try { if (!waitEvent.WaitOne(millisecondsTimeout)) { const string error = "ReaderWriterLock timeout expired"; Log.ErrorWithData(error); throw new InvalidOperationException(error); } waitSuccessful = true; } finally { EnterMyLock(); --numWaiters; if (!waitSuccessful) // We are going to throw for some reason. Exit myLock. { ExitMyLock(); } } }
public void DispatchAndWait(EventWaitHandle waitHandle, Action action, DispatcherPriority priority = DispatcherPriority.Normal) { Dispatcher dispatcher = ((FrameworkElement)ReplWindow.TextView).Dispatcher; waitHandle.Reset(); dispatcher.Invoke(new Action(() => { action(); waitHandle.Set(); }), priority); Assert.IsTrue(waitHandle.WaitOne(500)); }
static int Main(string[] args) // :обновление { AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException); Directory.SetCurrentDirectory(Path.GetDirectoryName(Application.ExecutablePath)); repairUpdateExe(); var repair = args.Length == 0 || (args.Length == 1 && args[0] == "-repair"); if (Repair(repair) && repair) { Console.WriteLine("repair started - succes"); return(40); } if (args.Length > 5 || args.Length < 4) { writeHelp(); return(1); } mainMutexForLog.WaitOne(); addBootRun(); Semaphore s = null; //new System.Threading.Semaphore(50, 50, "vs8.ru updator semaphore"); Mutex syncSemaphoreMutex = null; int sCount = 0, rCount = 0, mCount = 0; bool updatorUpdate = false; try { if (args[1] == "vs8.ru updator semaphore") { main.Set(); sCount = 50; updatorUpdate = true; } else { sCount = Int32.Parse(args[2]); } if (args[1].Length > 0) { s = new Semaphore(sCount, sCount, args[1]); syncSemaphoreMutex = new Mutex(false, args[1] + " umove sync mutex"); } if (syncSemaphoreMutex != null) { if (!syncSemaphoreMutex.WaitOne(0)) { return(32); } mCount = 1; } var RepairInfo = setRepairInfo(args); if (s != null) { rCount = blockSemaphore(s, sCount); } var returned = umoveProcess(args); if (returned == 0) { Console.WriteLine("success"); } else { Console.WriteLine("failure with code " + returned); } File.AppendAllText(errorLogFileName, String.Format(msgMessage, DateTime.Now, "Исполнено с кодом " + returned, getArgumentsFromArgArray(args))); if (updatorUpdate) { File.AppendAllText(errorLogFileName, String.Format(msgMessage, DateTime.Now, "Стартуем ./updatorvs8.exe -umove", getArgumentsFromArgArray(args))); Process.Start("updatorvs8.exe", "-umove"); } if (args[3].Length > 0) { if (args.Length == 4) { File.AppendAllText(errorLogFileName, String.Format(msgMessage, DateTime.Now, "Стартуем " + args[3], getArgumentsFromArgArray(args))); Process.Start(args[3]); } else { File.AppendAllText(errorLogFileName, String.Format(msgMessage, DateTime.Now, "Стартуем " + args[3] + " " + args[4], getArgumentsFromArgArray(args))); Process.Start(args[3], args[4]); } } ClearRepairInfo(args, RepairInfo); deleteBootRun(); File.AppendAllText(errorLogFileName, String.Format(msgMessage, DateTime.Now, "Исполнено и удалено из аварийного восстановления", getArgumentsFromArgArray(args))); truncateLog(new FileInfo(errorLogFileName)); return(returned); } finally { if (s != null) { releaseSemaphore(s, rCount); s.Close(); } if (syncSemaphoreMutex != null) { if (mCount > 0) { syncSemaphoreMutex.ReleaseMutex(); } syncSemaphoreMutex.Close(); } main.Reset(); main.Close(); mainMutexForLog.ReleaseMutex(); mainMutexForLog.Close(); } }
protected override void Handle(MercuryPacket packet) { using var stream = new MemoryStream(packet.Payload); int seqLength = getShort(packet.Payload, (int)stream.Position, true); stream.Seek(2, SeekOrigin.Current); long seq = 0; var buffer = packet.Payload; switch (seqLength) { case 2: seq = getShort(packet.Payload, (int)stream.Position, true); stream.Seek(2, SeekOrigin.Current); break; case 4: seq = getInt(packet.Payload, (int)stream.Position, true); stream.Seek(4, SeekOrigin.Current); break; case 8: seq = getLong(packet.Payload, (int)stream.Position, true); stream.Seek(8, SeekOrigin.Current); break; } byte flags = packet.Payload[(int)stream.Position]; stream.Seek(1, SeekOrigin.Current); short parts = getShort(packet.Payload, (int)stream.Position, true); stream.Seek(2, SeekOrigin.Current); _partials.TryGetValue(seq, out var partial); if (partial == null || flags == 0) { partial = new BytesArrayList(); _partials.TryAdd(seq, partial); } Debug.WriteLine($"Handling packet, cmd: {packet.Cmd}, seq: {seq}, flags: {flags}, parts: {parts}"); for (int j = 0; j < parts; j++) { short size = getShort(packet.Payload, (int)stream.Position, true); stream.Seek(2, SeekOrigin.Current); byte[] buffer2 = new byte[size]; int end = buffer2.Length; for (int z = 0; z < end; z++) { byte a = packet.Payload[(int)stream.Position]; stream.Seek(1, SeekOrigin.Current); buffer2[z] = a; } partial.Add(buffer2); } if (flags != 1) { return; } _partials.TryRemove(seq, out partial); Header header; try { header = Header.Parser.ParseFrom(partial.First()); } catch (Exception ex) { Debug.WriteLine($"Couldn't parse header! bytes: {Utils.bytesToHex(partial.First())}"); throw ex; } var resp = new MercuryResponse(header, partial); switch (packet.Cmd) { case MercuryPacket.Type.MercuryEvent: bool dispatched = false; lock (_subscriptions) { foreach (var sub in _subscriptions) { if (sub.Matches(header.Uri)) { sub.Dispatch(resp); dispatched = true; } } } if (!dispatched) { Debug.WriteLine( $"Couldn't dispatch Mercury event seq: {seq}, uri: {header.Uri}, code: {header.StatusCode}, payload: {resp.Payload.ToHex()}"); } break; case MercuryPacket.Type.MercuryReq: case MercuryPacket.Type.MercurySub: case MercuryPacket.Type.MercuryUnsub: _callbacks.TryRemove(seq, out var val); if (val != null) { val.Response(resp); } else { Debug.WriteLine( $"Skipped Mercury response, seq: {seq}, uri: {header.Uri}, code: {header.StatusCode}"); } lock (_removeCallbackLock) { _removeCallbackLock.Reset(); } break; default: Debugger.Break(); break; } }
public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken) { CheckState(); if (millisecondsTimeout < -1) { throw new ArgumentOutOfRangeException("millisecondsTimeout", "millisecondsTimeout is a negative number other than -1"); } Watch sw = Watch.StartNew(); Func <bool> stopCondition = () => millisecondsTimeout >= 0 && sw.ElapsedMilliseconds > millisecondsTimeout; do { bool shouldWait; int result; do { cancellationToken.ThrowIfCancellationRequested(); if (stopCondition()) { return(false); } shouldWait = true; result = currCount; if (result > 0) { shouldWait = false; } else { break; } } while (Interlocked.CompareExchange(ref currCount, result - 1, result) != result); if (!shouldWait) { if (result == 1) { handle.Reset(); } break; } SpinWait wait = new SpinWait(); while (Thread.VolatileRead(ref currCount) <= 0) { cancellationToken.ThrowIfCancellationRequested(); if (stopCondition()) { return(false); } if (wait.Count > spinCount) { handle.WaitOne(Math.Min(Math.Max(millisecondsTimeout - (int)sw.ElapsedMilliseconds, 1), deepSleepTime)); } else { wait.SpinOnce(); } } } while (true); return(true); }
public void NameRequiredIsNotBrokenAfterLookupCustomer() { // test that Name is revalidated as it is an affected property of LookupCustomer rule // that runs when CustomerId is set. string ruleSet = "LookupAndNameRequired"; string err1; var actual = RuleBaseClassesRoot.NewEditableRoot(ruleSet); err1 = ((IDataErrorInfo)actual)[RuleBaseClassesRoot.NameProperty.Name]; Assert.IsFalse(actual.IsSelfValid); // is broken before we set customerid var waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset); actual.ValidationComplete += (o, e) => waitHandle.Set(); waitHandle.Reset(); actual.CustomerId = 1; waitHandle.WaitOne(); // wait for async lookup to complete Assert.IsTrue(actual.IsSelfValid); // is valid after }
/// <summary> /// Waits on 'waitEvent' with a timeout /// Before the wait 'numWaiters' is incremented and is restored before leaving this routine. /// </summary> private bool WaitOnEvent( EventWaitHandle waitEvent, ref uint numWaiters, TimeoutTracker timeout, bool isWriteWaiter) { #if DEBUG Debug.Assert(MyLockHeld); #endif waitEvent.Reset(); numWaiters++; _fNoWaiters = false; //Setting these bits will prevent new readers from getting in. if (_numWriteWaiters == 1) { SetWritersWaiting(); } if (_numWriteUpgradeWaiters == 1) { SetUpgraderWaiting(); } bool waitSuccessful = false; ExitMyLock(); // Do the wait outside of any lock try { waitSuccessful = waitEvent.WaitOne(timeout.RemainingMilliseconds); } finally { EnterMyLock(); --numWaiters; if (_numWriteWaiters == 0 && _numWriteUpgradeWaiters == 0 && _numUpgradeWaiters == 0 && _numReadWaiters == 0) { _fNoWaiters = true; } if (_numWriteWaiters == 0) { ClearWritersWaiting(); } if (_numWriteUpgradeWaiters == 0) { ClearUpgraderWaiting(); } if (!waitSuccessful) // We may also be about to throw for some reason. Exit myLock. { if (isWriteWaiter && _numWriteWaiters == 0 && _numWriteUpgradeWaiters == 0 && !_fNoWaiters) { // Write waiters block read waiters from acquiring the lock. Since this was the last write waiter and // there is a read waiter, wake up the appropriate read waiters. ExitAndWakeUpAppropriateReadWaiters(); } else { ExitMyLock(); } } } return(waitSuccessful); }
void ReadThread(ThreadContext ctx) { System.Threading.Thread.CurrentThread.Name = "IPConnection.ReadThread"; EventWaitHandle asyncReadCompleteEvent = new EventWaitHandle(false, System.Threading.EventResetMode.ManualReset); SocketAsyncEventArgs socketAsyncEventArgs = new SignallingSocketEventArgs(asyncReadCompleteEvent); byte[] rgbBuffer = new byte[64]; socketAsyncEventArgs.SetBuffer(rgbBuffer, 0, rgbBuffer.Length); try { WaitHandle[] waitHandles = new WaitHandle[2]; waitHandles[0] = asyncReadCompleteEvent; waitHandles[1] = ctx.StopEvent; bool fStop = false; while (!fStop && !ctx.StopRequest) { // Issue an async read // asyncReadCompleteEvent.Reset(); bool fAsync = true; this.SocketMonitorLock(() => { fAsync = this.socket.ReceiveAsync(socketAsyncEventArgs); }); if (!fAsync) { // IO operation completed synchronously asyncReadCompleteEvent.Set(); } this.readThreadRunning.Set(); // Wait until either the async read completes or we're asked to stop int iWait = WaitHandle.WaitAny(waitHandles); // Process according to which event fired switch (iWait) { case 0: // Async read completed { if (socketAsyncEventArgs.BytesTransferred > 0) { if (socketAsyncEventArgs.SocketError == SocketError.Success) { // Program.Trace("IP Read: incoming packet"); ProcessIncomingPacket(rgbBuffer, socketAsyncEventArgs.BytesTransferred); } else { Program.Trace("IP Read: unexpected async result: cb={0} err={1}", socketAsyncEventArgs.BytesTransferred, socketAsyncEventArgs.SocketError); fStop = true; } } else { // Program.Trace("IP Read: read completed with zero bytes"); } } break; case 1: // StopEvent // Program.Trace("async read stop requested"); break; // end switch } } } finally { } }
/// <summary> /// Waits on 'waitEvent' with a timeout of 'millisecondsTimeout. /// Before the wait 'numWaiters' is incremented and is restored before leaving this routine. /// </summary> /// <param name="waitEvent"> /// The wait Event. /// </param> /// <param name="numWaiters"> /// The num Waiters. /// </param> /// <param name="millisecondsTimeout"> /// The milliseconds Timeout. /// </param> private void WaitOnEvent(EventWaitHandle waitEvent, ref uint numWaiters, int millisecondsTimeout) { Debug.Assert(this.MyLockHeld); waitEvent.Reset(); numWaiters++; bool waitSuccessful = false; this.ExitMyLock(); // Do the wait outside of any lock try { if (!waitEvent.WaitOne(millisecondsTimeout)) { throw new InvalidOperationException("ReaderWriterLock timeout expired"); } waitSuccessful = true; } finally { this.EnterMyLock(); --numWaiters; if (!waitSuccessful) { // We are going to throw for some reason. Exit myLock. this.ExitMyLock(); } } }
/// <summary> /// Run a process /// </summary> /// <param name="filter"></param> /// <param name="process"></param> /// <param name="onCallback"></param> /// <param name="onError"></param> /// <param name="onComplete"></param> public static void RunProcess(Filter filter, Action<Action<StringDictionary, ProfilerRuntime>> process, Action<int, byte[]> onCallback, Action<Exception> onError, Action onComplete) { filter = filter ?? new Filter(); var tag = (new Random((int)DateTime.UtcNow.Ticks)).Next().ToString(); var readBufferEvt = new EventWaitHandle(false, EventResetMode.ManualReset, "Local\\MM_ReadBuffer" + tag); var bufferReadEvt = new EventWaitHandle(false, EventResetMode.ManualReset, "Local\\MM_BufferRead" + tag); var workItemClosedEvt = new AutoResetEvent(false); var waitHandles = new WaitHandle[] { workItemClosedEvt, readBufferEvt }; var includes = string.IsNullOrWhiteSpace(filter.Includes) ? String.Empty.ToCharArray() : filter.Includes.ToCharArray(); var excludes = string.IsNullOrWhiteSpace(filter.Excludes) ? String.Empty.ToCharArray() : filter.Excludes.ToCharArray(); const int pfs = (32768 * 4) + 4 + 4; using (var mmf2 = MemoryMappedFile.CreateOrOpen("Local\\MMProfilerMapBuffer" + tag, 4 + filter.BufferSize + filter.ThresholdSize)) { using (var mmf = MemoryMappedFile.CreateOrOpen("Local\\MMProfilerMapControl" + tag, pfs)) { var filterAccessor = mmf.CreateViewAccessor(0, pfs, MemoryMappedFileAccess.ReadWrite); var lengthAccessor = mmf2.CreateViewAccessor(0, 4, MemoryMappedFileAccess.ReadWrite); var streamAccessor = mmf2.CreateViewStream(4, filter.BufferSize + filter.ThresholdSize, MemoryMappedFileAccess.ReadWrite); filterAccessor.Write(0, filter.BufferSize); filterAccessor.Write(4, filter.ThresholdSize); filterAccessor.WriteArray(4 + 4, includes, 0, includes.Count()); filterAccessor.WriteArray(32768 * 2 + 4 + 4, excludes, 0, excludes.Count()); ThreadPool.QueueUserWorkItem((state) => { try { process((dictionary, runtime) => { if (dictionary == null) return; if (dictionary.ContainsKey("Cor_Profiler") && dictionary.ContainsKey("Cor_Enable_Profiling") && dictionary["Cor_Enable_Profiling"] == "1") { Logger.WriteInfo("WARNING A PROFILER IS ALREADY REGISTERED!!!"); } else { dictionary["MMProfiler_Tag"] = tag; dictionary["Cor_Profiler"] = (runtime == ProfilerRuntime.Runtime32) ? "{36C8D782-F697-45C4-856A-92D05C061A39}" : "{5D789D88-EEE7-46C4-909F-E39D5606544D}"; dictionary["Cor_Enable_Profiling"] = "1"; } }); } finally { workItemClosedEvt.Set(); } }); var data = new byte[filter.BufferSize + filter.ThresholdSize]; var length = 0; var error = false; try { bool bTerminate = false; while (!bTerminate) { switch (WaitHandle.WaitAny(waitHandles)) { case 0: bTerminate = true; break; case 1: readBufferEvt.Reset(); length = lengthAccessor.ReadInt32(0); lengthAccessor.Write(0, (Int32)0); streamAccessor.Read(data, 0, length); streamAccessor.Seek(0, SeekOrigin.Begin); bufferReadEvt.Set(); bufferReadEvt.Reset(); onCallback(length, data); break; } } } catch (Exception ex) { onError(ex); error = true; } finally { if (!error) { length = lengthAccessor.ReadInt32(0); streamAccessor.Read(data, 0, length); onCallback(length, data); onComplete(); } } } } }