private void btnPause_Click(object sender, EventArgs e)
 {
     this.Cursor = Cursors.WaitCursor;
     if (state == ThreadState.Running) // Press Pause Button's
     {
         if (Algorithm.Algorithm.GetInstance().Pause())
         {
             state = ThreadState.Suspended;
             btnStart.Enabled = true;
             btnPause.Enabled = false;
             btnPause.Text = "&Pause";
             btnStop.Enabled = true;
             btnStart.Text = "&Resume";
             if (ResultForm._setting.AutoSave_OnStopped)
             {
                 Save(Algorithm.Algorithm.GetInstance().GetBestChromosome());
             }
         }
     }
     else if (state == ThreadState.Stopped || state == ThreadState.Aborted) // Press Sava Button's
     {
         Save(Algorithm.Algorithm.GetInstance().GetBestChromosome());
         btnStart.Enabled = true;
         btnPause.Enabled = false;
         btnPause.Text = "&Pause";
         btnStop.Enabled = false;
     }
     this.Cursor = Cursors.Default;
 }
Exemple #2
0
 public Thread(Closure closure, int stackSize)
 {
     ThreadClosure = closure;
     State = new ThreadState(stackSize);
     State.CurrentInstruction = new InstructionPointer(closure.Func, closure.ClosedVars, 0);
     State.CurrentInstruction.InstructionIndex = -1;
 }
 /// <summary>
 /// Waits for all incoming threads to be in wait()
 ///  methods.
 /// </summary>
 public static void AwaitState(ThreadState state, params ThreadClass[] threads)
 {
     while (true)
     {
         bool done = true;
         foreach (ThreadClass thread in threads)
         {
             if (thread.State != state)
             {
                 done = false;
                 break;
             }
         }
         if (done)
         {
             return;
         }
         if (Random().NextBoolean())
         {
             Thread.@Yield();
         }
         else
         {
             Thread.Sleep(1);
         }
     }
 }
Exemple #4
0
        private readonly ThreadState _threadState; // State of the thread

        #endregion Fields

        #region Constructors

        /// <summary> Constructor. </summary>
        /// <param name="interval"> The execution interval. </param>
        /// <param name="action">   The action to execute. </param>
        public TimedAction(double interval, Action action)
        {
            _action = action;
            _threadState = new ThreadState {IsRunning = false};

            _actionTimer = new Timer(interval) {Enabled = false, SynchronizingObject = null};
            _actionTimer.Elapsed += OnActionTimer;
        }
Exemple #5
0
 public override bool CanComplete(ThreadState threadState)
 {
     // A DelayedUnlock can be completed even if the thread does not
     // own the lock, then the execution does not affect anything
     // except that the instruction acts as a barrier preventing
     // instruction before to be completed after the unlock
     return true;
 }
Exemple #6
0
        public static ThreadState _1_SimplifyThreadState(ThreadState ts)
		{
            // Technique to convert threadstate to one of the 4 most useful values:
            // Unstarted, Running, WaitSleepJoin, and Stopped
            return ts & (ThreadState.Unstarted | 
				         ThreadState.WaitSleepJoin | 
						 ThreadState.Stopped);
        }
Exemple #7
0
 public ThreadSurrogated(Thread thread)
 {
     Id = thread.ManagedThreadId;
     Name = thread.Name;
     Priority = thread.Priority;
     State = thread.ThreadState;
     IsBackground = thread.IsBackground;
     IsThreadPoolThread = thread.IsThreadPoolThread;
 }
Exemple #8
0
        public override bool CanComplete(ThreadState threadState)
        {
            // TODO: (much later) support exception here
            VMValue_objectinst vinst = (VMValue_objectinst)threadState.GetValue(obj);
            if(vinst.HoldingLockThreadID != threadState.ThreadID)
                throw new Exception("Calling pulse on a lock we don't possess");

            return true;
        }
        private readonly ThreadState _threadState; // State of the thread

        #endregion Fields

        #region Constructors

        /// <summary> Constructor. </summary>
        /// <param name="disposeStack">Dispose stack to add itself to</param>
        /// <param name="interval"> The execution interval. </param>
        /// <param name="action">   The action to execute. </param>
        public TimedAction(DisposeStack disposeStack, double interval, Action action)
        {
            disposeStack.Push(this);
            _action = action;
            _threadState = new ThreadState {IsRunning = false};

            _actionTimer = new Timer(interval) {Enabled = false, SynchronizingObject = null};
            _actionTimer.Elapsed += OnActionTimer;
        }
Exemple #10
0
 public ThreadTraceInfo(int id, string name, DateTime start, float cpuUsage, TimeSpan totalCpuUsageTime, ThreadState state)
 {
     _id = id;
     _name = name;
     _start = start;
     _cpuUsage = cpuUsage;
     _totalCpuUsageTime = totalCpuUsageTime;
     _state = state;
 }
Exemple #11
0
        public void Start(Action<Exception> threadFailedHandler)
        {
            if (threadFailedHandler != null)
                ThreadFailed += threadFailedHandler;

            StartCore();

            m_State = ThreadState.Starting;
            m_Thread.Start();
        }
Exemple #12
0
 // A lock action can be completed if the lock is free
 // or it is currently hold by the same thread
 public override bool CanComplete(ThreadState threadState)
 {
     // A DelayedLock can only be completed if the object instance is not locked
     // or it is already locked by this thread
     VMValue_objectinst vinst = (VMValue_objectinst)threadState.GetValue(obj);
     if((vinst.HoldingLockThreadID == threadState.ThreadID) ||
         (vinst.HoldingLockThreadID == -1))
         return true;
     else
         return false;
 }
Exemple #13
0
        /// <summary>
        /// 创建线程
        /// </summary>
        /// <param name="name"></param>
        /// <param name="task"></param>
        /// <param name="isBackground"></param>
        /// <param name="apartmentState"></param>
        public SmartThread(Action task, string name = null, bool isBackground = true, ApartmentState apartmentState = ApartmentState.MTA)
        {
            if (task == null)
                throw new ArgumentNullException("task");

            InnerThread = new System.Threading.Thread(()=>task()) { Name = name, IsBackground = isBackground };
            InnerThread.SetApartmentState(apartmentState);

            mutex = new ResetEvent(false);
            State = ThreadState.NotStarted;
        }
 /// <summary>
 /// Start executing the robotscript
 /// </summary>
 public void executeScript()
 {
     try
     {
         thread = new Thread(new ThreadStart(scriptexecutor));
         thState = thread.ThreadState;
         thread.Start();
     }
     catch (ThreadStateException)
     {
         return;
     }
 }
 /// <summary>
 /// Creates a new <seealso cref="DocumentsWriterPerThreadPool"/> with a given maximum of <seealso cref="ThreadState"/>s.
 /// </summary>
 public DocumentsWriterPerThreadPool(int maxNumThreadStates)
 {
     if (maxNumThreadStates < 1)
     {
         throw new System.ArgumentException("maxNumThreadStates must be >= 1 but was: " + maxNumThreadStates);
     }
     ThreadStates = new ThreadState[maxNumThreadStates];
     NumThreadStatesActive = 0;
     for (int i = 0; i < ThreadStates.Length; i++)
     {
         ThreadStates[i] = new ThreadState(null);
     }
 }
Exemple #16
0
 private Mission(eTaskType taskType, string missionName, string dllLocation, string className, string launchMethod,
     string shutDownMethod, int launchInterval, int _errorTryInterval, eMissionStatus missionStatus)
 {
     _TaskType = taskType;
     _MissionName = missionName;
     _DllLocation = string.Format(@"{0}{1}", System.AppDomain.CurrentDomain.BaseDirectory, dllLocation); ;
     _ClassName = className;
     _LaunchMethod = launchMethod;
     _ShutDownMethod = shutDownMethod;
     _LaunchInterval = launchInterval;
     _ErrorTryInterval = _errorTryInterval;
     _MissionStatus = missionStatus;
     _MissionOwnerStatus = ThreadState.Unstarted;
 }
        private static string ThreadStateAsString(ThreadState state)
        {
            var values = (ThreadState[])Enum.GetValues(typeof(ThreadState));
            var extractedValues = new List<string>();

            foreach (var value in values)
            {
                if ((state & value) == value)
                {
                    extractedValues.Add(DebuggerBase.Instance.MuiProcessor.GetString(_threadStateMuiIdentifiers[value]));
                }
            }

            return string.Join(", ", extractedValues);
        }
        public ContextSwitch(TraceEvent sw)
        {
            // Old thread id & process id
            this.OldThreadId = (int)sw.PayloadValue(0);
            this.OldProcessId = (int)sw.PayloadValue(1);
            this.NewThreadId = (int)sw.PayloadValue(3);
            this.NewProcessId = (int)sw.PayloadValue(4);
            this.State = (ThreadState)sw.PayloadValue(13);
            this.ProcessorNumber = sw.ProcessorNumber;
            this.TimeStamp = sw.TimeStamp;
            this.TimeStamp100ns = sw.TimeStamp100ns;

            // Multiply by 10 to adjust the time as 100ns
            this.NewThreadWaitTime = (int)sw.PayloadValue(15) * 10;
        }
Exemple #19
0
 // In completion stage, the lock action will actually
 // set the object's lock field to be locked by this thread
 public override void Complete(ThreadState threadState)
 {
     VMValue_objectinst vinst = (VMValue_objectinst)threadState.GetValue(obj);
     if(vinst.HoldingLockThreadID == -1)
     {
         vinst.HoldingLockThreadID = threadState.ThreadID;
         vinst.HoldingLockCount = nTimes;
     }
     else
         vinst.HoldingLockCount += nTimes;
     if(CheckerConfiguration.DoPrintExecution)
     {
         Console.WriteLine("Commiting Lock in thread " + threadState.CurrentMethod.Name + " on " + obj);
     }
 }
 /// <summary>
 /// ThreadStorageView constructor.
 /// </summary>
 /// <param name="applicationId"></param>
 /// <param name="threadId"></param>
 /// <param name="state"></param>
 public ThreadStorageView(
     string applicationId,
     int threadId,
     ThreadState state
     )
     : this(-1,
     applicationId,
     null,
     threadId,
     state,
     c_noTimeSet,
     c_noTimeSet,
     0,
     false)
 {
 }
Exemple #21
0
        public ServiceController()
        {
            _sensor = new WiFiSensor(stopThread: _sensorStop, pauseThread: _sensorPause,
                playThread: _sensorPlay, output: _sensorOutputLocalizerInput);
            _localizer = new LocationLocalizer(stopThread: _localizerStop, pauseThread: _localizerPause,
                playThread: _localizerPlay, input: _sensorOutputLocalizerInput, algorithm: _localizationAlgorithm);

            _sensorState = ThreadState.Playing;
            _localizerState = ThreadState.Playing;

            _sensorThread = new Thread(new ThreadStart(_sensor.WiFiSensorLoop));
            _localizerThread = new Thread(new ThreadStart(_localizer.LocationLocalizerLoop));

            _sensorThread.IsBackground = true;
            _localizerThread.IsBackground = true;

            _sensorThread.Name = "WiFiSensorThread";
            _localizerThread.Name = "LocationLocalizerThread";
        }
Exemple #22
0
 public override void Complete(ThreadState threadState)
 {
     VMValue dest = threadState.GetValue(destValue);
     VMValue src = threadState.GetValue(srcValue);
     dest.CopyFrom(src);
     dest.IsConcrete = true;
     if(CheckerConfiguration.DoPrintExecution)
     {
         if(dest is VMValue_int32)
             Console.Write("Committing load of value {0} ",((VMValue_int32)dest).Value);
         else if(dest is VMValue_double)
             Console.Write("Committing load of value {0} ",((VMValue_double)dest).Value);
         else if(dest is VMValue_object)
             Console.Write("Committing write of {0}", ((VMValue_object)dest).ClassType);
         else
             Console.Write("Committing write of non-displayable value");
         Console.WriteLine(" from {0} in {1}", sourceInstruction, threadState.CurrentMethod.Name);
     }
 }
Exemple #23
0
 public override void Complete(ThreadState threadState)
 {
     VMValue_objectinst vinst = (VMValue_objectinst)threadState.GetValue(obj);
     if(vinst.HoldingLockThreadID == threadState.ThreadID)
     {
         vinst.HoldingLockCount--;
         if(vinst.HoldingLockCount == 0)
             vinst.HoldingLockThreadID = -1;
     }
     else
     {
         // If we unlock a lock that
         // this thread does not possess, the instruction
         // executes normally but has no effect
     }
     if(CheckerConfiguration.DoPrintExecution)
     {
         Console.WriteLine("Commiting Unlock in thread " + threadState.CurrentMethod.Name + " on " + obj);
     }
 }
Exemple #24
0
 public void Close()
 {
     lock (LockObject)
     {
         if ((_refCount <= 0) || (--_refCount != 0)) {
             return;
         }
         if (Running == ThreadState.Running)
         {
             Running = ThreadState.StopRequested;
             while (Running != ThreadState.Stopped)
             {
                 Thread.Sleep(1); //todo replace with Task.Delay() when using 4.5
             }
         }
         _thread = null;
         if (_ftd2XxHandle != IntPtr.Zero)
         {
             FTD2XX.FT_Close(_ftd2XxHandle);
             _ftd2XxHandle = IntPtr.Zero;
         }
         _data = null;
     }
 }
        internal void MarkForFullFlush()
        {
            DocumentsWriterDeleteQueue flushingQueue;

            lock (this)
            {
                if (Debugging.AssertsEnabled)
                {
                    Debugging.Assert(!fullFlush, "called DWFC#markForFullFlush() while full flush is still running");
                    Debugging.Assert(fullFlushBuffer.Count == 0, "full flush buffer should be empty: {0}", fullFlushBuffer);
                }
                fullFlush     = true;
                flushingQueue = documentsWriter.deleteQueue;
                // Set a new delete queue - all subsequent DWPT will use this queue until
                // we do another full flush
                DocumentsWriterDeleteQueue newQueue = new DocumentsWriterDeleteQueue(flushingQueue.generation + 1);
                documentsWriter.deleteQueue = newQueue;
            }
            int limit = perThreadPool.NumThreadStatesActive;

            for (int i = 0; i < limit; i++)
            {
                ThreadState next = perThreadPool.GetThreadState(i);
                next.@Lock();
                try
                {
                    if (!next.IsInitialized)
                    {
                        if (closed && next.IsActive)
                        {
                            DocumentsWriterPerThreadPool.DeactivateThreadState(next); // LUCENENET specific - made method static per CA1822
                        }
                        continue;
                    }
                    if (Debugging.AssertsEnabled)
                    {
                        Debugging.Assert(next.dwpt.deleteQueue == flushingQueue ||
                                         next.dwpt.deleteQueue == documentsWriter.deleteQueue,
                                         " flushingQueue: {0} currentqueue: {1} perThread queue: {2} numDocsInRam: {3}",
                                         flushingQueue, documentsWriter.deleteQueue, next.dwpt.deleteQueue, next.dwpt.NumDocsInRAM);
                    }
                    if (next.dwpt.deleteQueue != flushingQueue)
                    {
                        // this one is already a new DWPT
                        continue;
                    }
                    AddFlushableState(next);
                }
                finally
                {
                    next.Unlock();
                }
            }
            lock (this)
            {
                /* make sure we move all DWPT that are where concurrently marked as
                 * pending and moved to blocked are moved over to the flushQueue. There is
                 * a chance that this happens since we marking DWPT for full flush without
                 * blocking indexing.*/
                PruneBlockedQueue(flushingQueue);
                if (Debugging.AssertsEnabled)
                {
                    Debugging.Assert(AssertBlockedFlushes(documentsWriter.deleteQueue));
                }
                //FlushQueue.AddAll(FullFlushBuffer);
                foreach (var dwpt in fullFlushBuffer)
                {
                    flushQueue.Enqueue(dwpt);
                }
                fullFlushBuffer.Clear();
                UpdateStallState();
            }
            if (Debugging.AssertsEnabled)
            {
                Debugging.Assert(AssertActiveDeleteQueue(documentsWriter.deleteQueue));
            }
        }
Exemple #26
0
 extern static void SetState(Thread thread, ThreadState set);
        public void updateSPCDisplay(object sender, EventArgs e)
        {
            ThreadState currentState = searchThread.ThreadState;

            /* the ugly truth is that the threadState can change during the following
             * conditions. To avoid problems we set up a local variable first. */
            iterationBox.Text = SearchIO.getIteration(searchThread.Name).ToString();
            miscBox.Text      = SearchIO.getMiscObject(searchThread.Name);
            verbosityComboBox.SelectedIndex = SearchIO.getVerbosity(searchThread.Name);
            processTimer.Interval           = getIntervalFromVerbosity();
            try { priorityComboBox.SelectedIndex = (int)searchThread.Priority; }
            catch { }
            if ((currentState == ThreadState.AbortRequested) ||
                (currentState == ThreadState.StopRequested) ||
                (currentState == ThreadState.SuspendRequested))
            {
                this.playButton.Enabled        = false;
                this.pauseButton.Enabled       = false;
                this.stopButton.Enabled        = false;
                this.abortButton.Enabled       = true;
                this.ControlBox                = false;
                this.priorityComboBox.Enabled  = true;
                this.verbosityComboBox.Enabled = true;
                updateTimeDisplay();
            }
            else if (currentState == ThreadState.Suspended)
            {
                this.playButton.Enabled        = true;
                this.pauseButton.Enabled       = false;
                this.stopButton.Enabled        = false;
                this.abortButton.Enabled       = true;
                this.ControlBox                = false;
                this.priorityComboBox.Enabled  = true;
                this.verbosityComboBox.Enabled = true;
            }
            else if ((currentState == ThreadState.Running) ||
                     (currentState == ThreadState.WaitSleepJoin))
            {
                this.playButton.Enabled        = false;
                this.pauseButton.Enabled       = true;
                this.stopButton.Enabled        = true;
                this.abortButton.Enabled       = true;
                this.ControlBox                = false;
                this.priorityComboBox.Enabled  = true;
                this.verbosityComboBox.Enabled = true;
                updateTimeDisplay();
            }
            else if ((currentState == ThreadState.Stopped) ||
                     (currentState == ThreadState.Aborted))
            {
                if (abortedTime != 0)
                {
                    long test = DateTime.Now.Ticks - abortedTime;
                    if (test > 50000000)
                    /* after 5 seconds(?) close the search process window */
                    {
                        this.processTimer.Stop();
                        this.Close();
                    }
                }
                else
                {
                    this.playButton.Enabled        = false;
                    this.pauseButton.Enabled       = false;
                    this.stopButton.Enabled        = false;
                    this.abortButton.Enabled       = false;
                    this.ControlBox                = true;
                    this.priorityComboBox.Enabled  = false;
                    this.verbosityComboBox.Enabled = false;
                    abortedTime = DateTime.Now.Ticks;
                }
            }
        }
Exemple #28
0
 private bool GetThreadStateBit(ThreadState bit)
 {
     Debug.Assert((bit & ThreadState.Stopped) == 0, "ThreadState.Stopped bit may be stale; use GetThreadState instead.");
     return((_threadState & (int)bit) != 0);
 }
Exemple #29
0
 /// <inheritdoc />
 public Possible <ObjectContext, Failure> GetCompletions(ThreadState threadState, int frameIndex, string expr)
 {
     return(new Failure <string>("hi"));
 }
Exemple #30
0
 public static void OnStop()
 {
     threadState = ThreadState.Stopping;
 }
Exemple #31
0
		extern private static void ClrState (InternalThread thread, ThreadState clr);
 public void StopMonitoring()
 {
     //_monitoring = false;
       if( _currentMonitor != null ) {
     _currentMonitor.Executing = false;
     _currentMonitor = null;
       }
 }
Exemple #33
0
        private void ChangeThreadState(ThreadState newState, bool scroll = true)
        {
            if (scroll && Version >= WorldModelVersion.v540 && (newState == ThreadState.Ready || newState == ThreadState.Waiting))
            {
                ScrollToEnd();
            }

            if (newState == ThreadState.Waiting && m_state == GameState.Finished) throw new Exception("Game is finished");
            m_threadState = newState;
            lock (m_threadLock)
            {
                Monitor.PulseAll(m_threadLock);
            }
        }
Exemple #34
0
        static void fun1()
        {
            ThreadWorkItem itemMain = new ThreadWorkItem
            {
                //线程0,1持续运行,设置true后非阻塞,持续运行。需要手动触发Reset()才会阻塞实例所在当前线程
                ManualResetEvent = new ManualResetEvent(true),
            };

            //线程工作集合
            Task.Factory.StartNew(() =>
            {
                Thread t            = null;
                ThreadWorkItem item = null;
                for (int i = 0; i < 2; i++)
                {
                    t = new Thread((o) =>
                    {
                        var w = o as ThreadWorkItem;
                        if (w == null)
                        {
                            return;
                        }

                        while (true)
                        {
                            //阻塞当前线程
                            bool t = w.ManualResetEvent.WaitOne(10000);

                            Console.WriteLine("我是线程:" + Thread.CurrentThread.Name + ":群里无聊吗?" + !t);
                            if (!t)
                            {
                                break;
                            }
                            Thread.Sleep(200);
                        }
                        Console.WriteLine("我是线程:" + Thread.CurrentThread.Name + "退出了群聊");
                    });
                    t.Name = "Hello,i 'am Thread: " + i;
                    item   = new ThreadWorkItem
                    {
                        //线程0,1持续运行,设置true后非阻塞,持续运行。需要手动触发Reset()才会阻塞实例所在当前线程
                        ManualResetEvent = new ManualResetEvent(true),
                        Thread           = t,
                        ThreadManagerId  = t.ManagedThreadId,
                        ThreadName       = t.Name
                    };
                    Works.Add(item);
                    t.Start(item);
                }



                //5秒后准备暂停一个线程1。线程0持续运行
                Thread.Sleep(1000);
                Console.WriteLine("close...");
                Works[1].ManualResetEvent.Reset();

                //5秒后恢复线程1;线程0,1持续运行
                Thread.Sleep(1000);
                Console.WriteLine("open...");
                Works[1].ManualResetEvent.Set();

                //5秒后准备暂停一个线程0。线程1持续运行
                Thread.Sleep(1000);
                Console.WriteLine("close0...");
                Works[0].ManualResetEvent.Reset();

                //5秒后恢复线程1;线程0,1持续运行
                Thread.Sleep(1000);
                Console.WriteLine("open0...");
                Works[0].ManualResetEvent.Set();
                //5秒后恢复线程1;线程0,1持续运行
                Thread.Sleep(5000);
                Console.WriteLine("closeAll...");
                Works[0].ManualResetEvent.Reset();
                Works[1].ManualResetEvent.Reset();
                while (true)
                {
                    ThreadState ts = Thread.CurrentThread.ThreadState;
                    Console.WriteLine("我是线程:" + Thread.CurrentThread.Name + "群主解散了群聊");
                    //while (true)
                    //{
                    //    Thread.CurrentThread.TrySetApartmentState(System.Threading.ThreadState.WaitSleepJoin);
                    //    }
                    Thread.CurrentThread.Interrupt();


                    itemMain.ManualResetEvent.WaitOne();
                    Thread.Sleep(2000);
                    //Reset();
                }
            });

            /// <summary>
            /// 假设的网络请求
            /// </summary>
            /// <param name="state">参数</param>
        }
        private void ProcessEvent(_PRF.ProfilerSession ps, _PRF.ProfilerEvent pe)
        {
            switch (pe.Type)
            {
            case _PRF.ProfilerEvent.EventType.Call:
            {
                _PRF.FunctionCall f = (_PRF.FunctionCall)pe;
                m_currentThread = f.m_thread;

                ThreadState ts;
                if (m_htThreads.ContainsKey(m_currentThread))
                {
                    ts = m_htThreads[m_currentThread];
                }
                else
                {
                    ts                      = new ThreadState();
                    ts.m_threadID           = f.m_thread;
                    m_htThreads[f.m_thread] = ts;
                }

                Call c = new Call();
                c.Function = f.m_callStack[f.m_callStack.Length - 1];

                try
                {
                    m_sess.m_engine.GetMethodName(c.Function, true);
                }
                catch { }

                ts.m_call.AddChild(c);
                ts.m_call = c;
                break;
            }

            case _PRF.ProfilerEvent.EventType.Return:
            {
                _PRF.FunctionReturn f = (_PRF.FunctionReturn)pe;
                ThreadState         ts;
                if (m_htThreads.ContainsKey(m_currentThread))
                {
                    ts = m_htThreads[m_currentThread];
                }
                else
                {
                    ts                      = new ThreadState();
                    ts.m_threadID           = f.m_thread;
                    m_htThreads[f.m_thread] = ts;
                }

                if ((f.duration & 0x80000000) == 0)
                {
                    //OffView really really doesn't like negative times.
                    ts.m_call.Duration += f.duration;
                }

                if (ts.m_call.Parent != null)
                {
                    //Make timing inclusive.
                    ts.m_call.Parent.Duration += ts.m_call.Duration;
                }
                ts.m_call = ts.m_call.Parent;
                break;
            }

            case _PRF.ProfilerEvent.EventType.ContextSwitch:
            {
                _PRF.ContextSwitch c = (_PRF.ContextSwitch)pe;
                m_currentThread = c.m_thread;
                break;
            }
            }
        }
Exemple #36
0
 /// <summary>
 /// Marks the most ram consuming active <see cref="DocumentsWriterPerThread"/> flush
 /// pending
 /// </summary>
 protected virtual void MarkLargestWriterPending(DocumentsWriterFlushControl control, ThreadState perThreadState, long currentBytesPerThread)
 {
     control.SetFlushPending(FindLargestNonPendingWriter(control, perThreadState));
 }
Exemple #37
0
        private void PutThreadToWait(HThread Thread, ThreadState State, int TimeoutMs = -1)
        {
            SchedulerThread SchedThread;

            lock (SchedLock)
            {
                if (!AllThreads.TryGetValue(Thread, out SchedThread))
                {
                    return;
                }

                if (SchedThread.Signaled && SchedThread.State == ThreadState.WaitingSignal)
                {
                    SchedThread.Signaled = false;

                    return;
                }

                ActiveProcessors.Remove(Thread.ProcessorId);

                SchedThread.State = State;

                TryRunningWaitingThead(SchedThread.Thread.ProcessorId);

                if (State == ThreadState.WaitingSignal)
                {
                    InsertSorted(SchedThread);
                }
                else
                {
                    InsertAtEnd(SchedThread);
                }
            }

            if (TimeoutMs >= 0)
            {
                Logging.Debug($"{GetDbgThreadInfo(SchedThread.Thread)} waiting with timeout of {TimeoutMs}ms.");

                SchedThread.WaitEvent.WaitOne(TimeoutMs);
            }
            else
            {
                Logging.Debug($"{GetDbgThreadInfo(SchedThread.Thread)} waiting indefinitely.");

                SchedThread.WaitEvent.WaitOne();
            }

            while (true)
            {
                lock (SchedLock)
                {
                    Logging.Debug($"Trying to run {GetDbgThreadInfo(SchedThread.Thread)}.");

                    if (!ActiveProcessors.Contains(SchedThread.Thread.ProcessorId))
                    {
                        SetThreadAsRunning(SchedThread);

                        break;
                    }
                    else
                    {
                        SchedThread.State = ThreadState.WaitingToRun;

                        Logging.Debug($"{GetDbgThreadInfo(SchedThread.Thread)} waiting to run.");
                    }
                }

                SchedThread.WaitEvent.WaitOne();
            }
        }
Exemple #38
0
 private static void PrintThreadState(ThreadState state)
 {
     Console.WriteLine("{0,-16} : {1}", state, (int)state);
 }
Exemple #39
0
 public static void OnStart()
 {
     threadState = ThreadState.Running;
 }
 private static extern void ClrState(Thread thread, ThreadState clr);
Exemple #41
0
        public override void OnMessage(string message, EChatEntryType type)
        {
            if (message == "LIST" && Bot.MySteamID.Contains(OtherSID.ToString()))
            {
                List <long> contextId = new List <long>();
                contextId.Add(2);
                Bot.mySteamInventory.load(Bot.BotGameUsage, contextId, Bot.SteamClient.SteamID);

                SendChatMessage("My inventory (" + Bot.BotGameUsage + ") contain " + Bot.mySteamInventory.items.Count + " item(s) !");
                foreach (KeyValuePair <ulong, GenericInventory.Item> item in Bot.mySteamInventory.items)
                {
                    SteamTrade.GenericInventory.ItemDescription description = Bot.mySteamInventory.getDescription(item.Key);
                    SendChatMessage(description.name + " in game " + Bot.mySteamInventory.items[item.Key].appid);
                }
            }
            else if (message == "TCP" && Bot.MySteamID.Contains(OtherSID.ToString()))
            {
                ThreadState state = Bot.StartListening.ThreadState;
                SendChatMessage(state.ToString());
            }
            else if (message.StartsWith("EXEC") && Bot.MySteamID.Contains(OtherSID.ToString()))
            {
                message = message.Replace("EXEC", "");
                string[] cmd = message.Split(' ');
                if (cmd.Length >= 2)
                {
                    string command = "";
                    for (int i = 2; i < cmd.Length; i++)
                    {
                        command += cmd[i] + " ";
                    }
                    command.Remove(command.Length - 1);

                    if (Bot.SendCommandToServer(Int32.Parse(cmd[1]), command))
                    {
                        SendChatMessage("Executed '" + command + "' on server id '" + cmd[1] + "' !");
                    }
                    else
                    {
                        SendChatMessage("Wrong server ID, use 'SERVERLIST' to get the server ID.");
                    }
                }
                else
                {
                    SendChatMessage("Usage : EXEC [serverid] [command]");
                    SendChatMessage("Exemple : EXEC 0 sm_test 1 2 3");
                }
            }
            else if (message == "SERVERLIST" && Bot.MySteamID.Contains(OtherSID.ToString()))
            {
                List <string> existingServer = new List <string>();
                SendChatMessage("Number of connection : " + Bot.socket.Clients.Count);
                SendChatMessage("Server ID   Server name");
                for (int i = 0; i < Bot.socket.Clients.Count; i++)
                {
                    if (!existingServer.Contains(Bot.socket.Clients[i].Name) && Bot.socket.Clients[i].clientSocket.Connected)
                    {
                        SendChatMessage(i + "             " + Bot.socket.Clients[i].Name);
                        existingServer.Add(Bot.socket.Clients[i].Name);
                    }
                }
                SendChatMessage("-----------------------");
            }
            else
            {
                SendChatMessage(Bot.chatbotSession.Think(message));
            }
        }
Exemple #42
0
 extern static void ClrState(Thread thread, ThreadState clr);
 private static extern void SetState(Thread thread, ThreadState set);
Exemple #44
0
 /// <summary>
 /// Gets the list of  threads with the given thread-state
 /// </summary>
 /// <param name="status"></param>
 /// <returns>Dataset with thread info.</returns>
 public ThreadStorageView[] GetThreadList(ThreadState status)
 {
     return(ManagerStorageFactory.ManagerStorage().GetThreads(_Id, status));
 }
Exemple #45
0
 public void SetAllThreadsDebugState(ThreadState state, IDebuggerThread thread) =>
 debugger.Dispatcher.UI(() => DnAppDomain.CorAppDomain.SetAllThreadsDebugState((dndbg.COM.CorDebug.CorDebugThreadState)state, thread == null ? null : ((DebuggerThread)thread).DnThread.CorThread));
Exemple #46
0
 extern private static void SetState(InternalThread thread, ThreadState set);
Exemple #47
0
        public string Main(string[] args)
        {
            ////Set Current Dir in UserProfile

            //string currDir = SetAppCurrentDir(nameCurrentDir);

            try
            {
                TestInputArgs(args);
            }
            catch (ArgumentException argEx)
            {
                Console.WriteLine(argEx.Message);
                //Console.WriteLine("\nPress any Key to Exit!\n");
                //Console.ReadKey();
                // return;
                //Directory.
                appDom = AppDomain.CurrentDomain;

                Console.WriteLine("\nappDom.BaseDirectory: <{0}>\nappDom.FriendlyName: <{1}>\n",
                                  appDom.BaseDirectory, appDom.FriendlyName);

                Console.WriteLine("\nPress any Key to Exit!\n");
                //Console.ReadKey();
                return(argEx.Message);
            }
            ////Console.WriteLine("\nPress any Key to Exit!\n");
            ////Console.ReadKey();
            ////return;

            ////====

            //1) Create StreamReader

            strReader = File.OpenText(inputFile); //for Scanner only USING

            inputFileEncoding = strReader.CurrentEncoding;
            Console.WriteLine("\ninputFile: {0} ; File Encoding: {1}", inputFile, inputFileEncoding);
            ////
            //AppDomain BaseDirectory
            AppDomain appDom1 = AppDomain.CurrentDomain;

            Console.WriteLine("\nappDom.BaseDirectory: <{0}>\nappDom.FriendlyName: <{1}>\n",
                              appDom1.BaseDirectory, appDom1.FriendlyName);
            /////
            //2)Create StreamWriter
            //
            //(a)Create one Dir for StreamWriter of Lexer,Scaner and Parser Outputs (after Analisis: options for debugging)
            // and Parser Output as AST Value after Context Analisis with Diagnostics
            //(b)Create one Dir for each Expressions:
            //   Private Partition,Polish,Diagramm,Automaton(not built up yet!)(after Good Context Diagnostics :options)
            //
            //(b==>c)Create one Dir for each Expressions( 0<=i<=n-1):
            // (i)  Private Partition,Polish,Diagramm,Automaton(not built up yet!)
            // (i) Public Partition, Representation of Private on Public,Diagram on Public, Automaton in Public(after Good Context Diagnostics :options)
            //
            //(d)Create one Dir for Public Partition,Cartesian Product,Classification States and Transitiona(RESULT)
            //
            this.nameScaneLexParseDir = currDir + "/" + nameScaneLexParseDir;
            if (!Directory.Exists(this.nameScaneLexParseDir))
            {
                Directory.CreateDirectory(nameScaneLexParseDir);
            }

            //Program.nameScaneLexParseDir Exists!

            string fileParserOutput = (this.nameScaneLexParseDir + "\\") + outputFile;

            File.Delete(fileParserOutput);                 //relative(to the current working directory) or absolute path
            strWriter = File.CreateText(fileParserOutput); //for Parser only USING


            Console.WriteLine("\nNew currDirect: {0}\n", currDir);
            Console.WriteLine("\nfileParserOutput: {0}\n", fileParserOutput);
            Console.WriteLine("\nPress any Key to Exit!\n");
            //Console.ReadKey();
            ////return;

            //3)Create tokenStringQueue and terminalTokenStringQueue

            tokenStringQueue         = new Queue <string>(len_tokenStringQueue);
            terminalTokenStringQueue = new Queue <string>(len_terminalTokenStringQueue);

            //4)Create thrScanner
            Scanner scanner = new Scanner(nameScaneLexParseDir, this.strReader, this.tokenStringQueue);

            ThreadStart delegateStartScanner = new ThreadStart(scanner.Scane);
            Thread      thrScanner           = new Thread(delegateStartScanner);

            //5)Create thrLexer
            //
            Lexer       lexer = new Lexer(nameScaneLexParseDir, tokenStringQueue, terminalTokenStringQueue);
            ThreadStart delegateStartLexer = new ThreadStart(lexer.methodLexem); //Instance Caller method

            //// ThreadStart delegateStartLexer = new ThreadStart(Lexer.Lexem); //Static method
            Thread thrLexer = new Thread(delegateStartLexer);

            //6)Create thrParser
            Parser      parser = new Parser(this.strWriter, this.terminalTokenStringQueue);
            ThreadStart delegateStartParser = new ThreadStart(parser.Parse); ////Parser.TestParse
            Thread      thrParser           = new Thread(delegateStartParser);


            ThreadState thrScannerState = thrScanner.ThreadState;

            //eventScanner = new ManualResetEvent(false);
            ////Scanner.autoResetEvent = new AutoResetEvent(false);

            if (thrScannerState == ThreadState.Unstarted)
            {
                thrScanner.Start();
                Console.WriteLine("\nThread Scanner has just started!\n");
            }

            ////ControlThreadScane(thrScanner);

            thrLexer.Start();
            Console.WriteLine("\nThread Lexer has just started!\n");


            thrParser.Start();
            Console.WriteLine("\nThread Parser has just started!\n");

            thrScanner.Join();
            Console.WriteLine("\nThread Scanner has just ended!\n");

            thrLexer.Join();
            Console.WriteLine("\nThread Lexer has just ended!\n");

            thrParser.Join();
            Console.WriteLine("\nThread Parser has just ended!\n");

            strReader.Close(); //after Scanner Return
            strWriter.Close(); //after Parser Return;
            //1) - 6) Front End of Compiler

            //bool isLeftDerive = true;
            //Derive.TestDerivator(isLeftDerive, Parser.RootAST, "Derivation.txt");
            //
            //7)Back End of Compiler
            int res = EvaluateAST_Verify_GetAutomataInBasicPartition_CartesianProduct(valueASTFile);

            //===Public Automata from Diagramms are ready if  Verification is succeded!
            //
            //
            //**(8)**Test for <Equals_Id1_Id2>: Boath <Private Partitions> and <Regular Expressions> are different,
            //but they are in the public alphabet!!!
            //
            //TODO: 0)Implement Writing File of Automation with its Private(Public too) Alphabet Partition (Modify old Writing);
            //      1)Implement Loading up Automation with its Private Alphabet Partition (without Verification)(Modify old Writing);
            //      2)And Implement Equals for Two Automata with their Private Alphabet Partitions but
            //       before that converting them into Public Alphabet Partition;
            //      Note: Think of '-' (minus symbol in <patterns> at Writing and Reading file)!!!
            //
            if (res > 0)
            {
                Console.WriteLine("\nres: ({0})\n", res);
                Console.WriteLine("\nPress any Key to Exit!\n");
                //Console.ReadKey();
                return(res.ToString());
            }

            goto labelNoEquals;

            string nameRegularExp_1 = "Identifier";
            string fileNameAutomatonFromDiagrammPublic1 = (nameRegularExp_1 + "\\") + (nameRegularExp_1 + "_Private_Automaton.txt");
            string fileAut1 = (currDir + "\\") + fileNameAutomatonFromDiagrammPublic1;

            TestLoadingAutomataAndEquals(fileAut1, fileAut1);

            string nameRegularExp_2 = "AOctodecimal";
            string fileNameAutomatonFromDiagrammPublic2 = (nameRegularExp_2 + "\\") + (nameRegularExp_2 + "_Private_Automaton.txt");
            string fileAut2 = (currDir + "\\") + fileNameAutomatonFromDiagrammPublic2;

            TestLoadingAutomataAndEquals(fileAut1, fileAut2);

labelNoEquals:
            Console.WriteLine("\nres: ({0})\n", res);
            Console.WriteLine("\nPress any Key to Exit!\n");
            //Console.ReadKey();
            return(res.ToString());
        }
Exemple #48
0
 extern private static void ClrState(InternalThread thread, ThreadState clr);
Exemple #49
0
        /// <summary>
        /// Returns the current most RAM consuming non-pending <see cref="ThreadState"/> with
        /// at least one indexed document.
        /// <para/>
        /// This method will never return <c>null</c>
        /// </summary>
        protected virtual ThreadState FindLargestNonPendingWriter(DocumentsWriterFlushControl control, ThreadState perThreadState)
        {
            Debug.Assert(perThreadState.dwpt.NumDocsInRAM > 0);
            long maxRamSoFar = perThreadState.bytesUsed;
            // the dwpt which needs to be flushed eventually
            ThreadState maxRamUsingThreadState = perThreadState;

            Debug.Assert(!perThreadState.flushPending, "DWPT should have flushed");
            IEnumerator <ThreadState> activePerThreadsIterator = control.AllActiveThreadStates();

            while (activePerThreadsIterator.MoveNext())
            {
                ThreadState next = activePerThreadsIterator.Current;
                if (!next.flushPending)
                {
                    long nextRam = next.bytesUsed;
                    if (nextRam > maxRamSoFar && next.dwpt.NumDocsInRAM > 0)
                    {
                        maxRamSoFar            = nextRam;
                        maxRamUsingThreadState = next;
                    }
                }
            }
            Debug.Assert(AssertMessage("set largest ram consuming thread pending on lower watermark"));
            return(maxRamUsingThreadState);
        }
Exemple #50
0
 public ThreadProperties(DbgAppDomain appDomain, string kind, ulong id, ulong?managedId, string name, int suspendedCount, ThreadState threadState)
 {
     AppDomain      = appDomain;
     Kind           = kind;
     Id             = id;
     ManagedId      = managedId;
     Name           = name;
     SuspendedCount = suspendedCount;
     ThreadState    = threadState;
 }
Exemple #51
0
 /// <summary>
 /// Gets the count threads with the given thread-state.
 /// </summary>
 /// <param name="ts"></param>
 /// <returns>Thread count</returns>
 public int ThreadCount(ThreadState ts)
 {
     return(ManagerStorageFactory.ManagerStorage().GetApplicationThreadCount(_Id, ts));
 }
Exemple #52
0
 private bool IsDead()
 {
     // Refresh ThreadState.Stopped bit if necessary
     ThreadState state = GetThreadState();
     return (state & (ThreadState.Stopped | ThreadState.Aborted)) != 0;
 }
Exemple #53
0
 /// <summary>
 /// end this thread
 /// </summary>
 public void EndExecution()
 {
     this.IsRunning       = false;
     this.IsDoneExecuting = true;
     this.State           = ThreadState.Done;
 }
Exemple #54
0
 public static ThreadState SimpleThreadState(ThreadState ts)
 {
     return(ts & (ThreadState.Aborted | ThreadState.AbortRequested |
                  ThreadState.Stopped | ThreadState.Unstarted |
                  ThreadState.WaitSleepJoin));
 }
        private void LaunchProcess()
        {
            try
            {
                const string clientExePath = "Client.exe";
                ProcessStartInfo info = new ProcessStartInfo(clientExePath);
                info.UseShellExecute = false;
                //info.WorkingDirectory = @"C:\Program Files\VTank\";

                Process process = Process.Start(info);

                //bool finished = false;
                long elapsed = 0;
                long lastTime = (long)(DateTime.Now - DateTime.FromBinary(0)).TotalMilliseconds;;
                const long MAX_WAIT_TIME = 15000;
                while (GetActiveWindowTitle() != "VTank") //&& !finished) Might want this at some point
                {
                    try
                    {
                        /*int moduleCount = process.Modules.Count;
                        if (!(moduleCount >= 4 && process.Responding))
                        {*/
                            long currentTime = (long)(DateTime.Now - DateTime.FromBinary(0)).TotalMilliseconds;
                            elapsed += currentTime - lastTime;
                            lastTime = currentTime;
                            if (elapsed > MAX_WAIT_TIME)
                                break;
                        /*}
                        else
                        {
                            finished = true;
                        }*/
                    }
                    catch { }
                    finally
                    {
                        Thread.Sleep(25);
                    }
                }
                State = ThreadState.SUCCESSFUL;
            }
            catch (Exception ex)
            {
                Console.Error.WriteLine(ex);

                failureReason = ex.Message;

                State = ThreadState.FAILED;
            }

            Invoke(new Finished(OnFinish));
        }
Exemple #56
0
 public void RequestInterrupt()
 {
     ThreadState.RequestInterrupt();
 }
Exemple #57
0
		extern private static void SetState (InternalThread thread, ThreadState set);
Exemple #58
0
 static void PrintState(ThreadState state)
 {
     Console.WriteLine($"{state,-16} : {(int)state}");
 }
		private static void ClrState (InternalThread thread, ThreadState clr)
		{
			throw new System.NotImplementedException();
		}
Exemple #60
0
        /// <summary>
        /// Gets the children.
        /// </summary>
        /// <param name="entry">The entry.</param>
        /// <param name="useCache">if set to <c>true</c> [use cache].</param>
        /// <param name="receiver">The receiver.</param>
        /// <returns></returns>
        public FileEntry[] GetChildren(FileEntry entry, bool useCache, IListingReceiver receiver)
        {
            // first thing we do is check the cache, and if we already have a recent
            // enough children list, we just return that.
            if (useCache && !entry.NeedFetch)
            {
                return(entry.Children.ToArray());
            }

            // if there's no receiver, then this is a synchronous call, and we
            // return the result of ls
            if (receiver == null)
            {
                DoLS(entry);
                return(entry.Children.ToArray());
            }

            // this is a asynchronous call.
            // we launch a thread that will do ls and give the listing
            // to the receiver
            Thread t = new Thread(new ParameterizedThreadStart(delegate(object stateData)
            {
                ThreadState state = stateData as ThreadState;

                DoLS(entry);

                receiver.SetChildren(state.Entry, state.Entry.Children.ToArray());

                FileEntry[] children = state.Entry.Children.ToArray();
                if (children.Length > 0 && children[0].IsApplicationPackage)
                {
                    Dictionary <string, FileEntry> map = new Dictionary <string, FileEntry>();

                    foreach (FileEntry child in children)
                    {
                        string path = child.FullPath;
                        map.Add(path, child);
                    }

                    // call pm.
                    string command = PM_FULL_LISTING;
                    try
                    {
                        this.Device.ExecuteShellCommand(command, new PackageManagerListingReceiver(map, receiver));
                    }
                    catch (IOException e)
                    {
                        // adb failed somehow, we do nothing.
                        Log.E("FileListingService", e);
                    }
                }


                // if another thread is pending, launch it
                lock (Threads)
                {
                    // first remove ourselves from the list
                    Threads.Remove(state.Thread);

                    // then launch the next one if applicable.
                    if (Threads.Count > 0)
                    {
                        Thread ct = Threads[0];
                        ct.Start(new ThreadState {
                            Thread = ct, Entry = entry
                        });
                    }
                }
            }))
            {
                Name = "ls " + entry.FullPath
            };

            // we don't want to run multiple ls on the device at the same time, so we
            // store the thread in a list and launch it only if there's no other thread running.
            // the thread will launch the next one once it's done.
            lock (Threads)
            {
                // add to the list
                Threads.Add(t);

                // if it's the only one, launch it.
                if (Threads.Count == 1)
                {
                    t.Start(new ThreadState {
                        Thread = t
                    });
                }
            }

            // and we return null.
            return(null);
        }