Пример #1
0
        private void outputWorker()
        {
            List <byte> dataToSend = new List <byte>();

            socket.NoDelay = true;

            while (ShouldBeRunning && socket.Connected)
            {
                Thread.Sleep(1);

                dataToSend.Clear();

                while (DataToSendQueue.Count > 0)
                {
                    dataToSend.AddRange(DataToSendQueue.Dequeue());
                }

                if (dataToSend.Count == 0)
                {
                    continue;
                }

                try
                {
                    //Send ALL bytes at once instead of "per packet", should be better
                    int r = socket.Send(dataToSend.ToArray());
                }
                catch (Exception E)
                {
                    Debug.WriteLine(E.StackTrace);
                }
            }
        }
Пример #2
0
 private void inputWorker()
 {
     while (ShouldBeRunning)
     {
         while (InputQueue.Count > 0)
         {
             ProcessInputPacket(InputQueue.Dequeue());
         }
         Thread.Sleep(1);
     }
 }
    /// <summary>
    /// [AI thread] Retrieves the last parameters sent  to the AI thread.
    /// </summary>
    /// <returns></returns>
    public static AI_Params Get()
    {
        AI_Params p;

        ThreadSignal.WaitOne(); // Waiting for a Send() call
        lock (ThreadQueue) { p = ThreadQueue.Dequeue(); }
        if (ThreadQueue.Count == 0)
        {
            ThreadSignal.Reset(); // Going to sleep if nothing else in the queue
        }
        return(p);
    }
Пример #4
0
        private void CheckQueue()
        {
            lock (checklock)
            {
                while (_queue.Count > 0 && _threads.Count < ThreadsMaxCount)
                {
                    StartThread(_queue.Dequeue());
                }

                if (_queue.Count == 0 && _threads.Count == 0 && RaiseCompleteEventIfQueueEmpty)
                {
                    OnCompleted();
                }
            }
        }
Пример #5
0
        /// <summary>
        /// メインスレッドでの処理
        /// </summary>
        private void Update()
        {
            threadQueue.Commit();
            var queue = threadQueue.Dequeue();

            foreach (var q in queue)
            {
                try
                {
                    q.Invoke();
                }
                catch (Exception ex)
                {
                    Debug.LogError(ex);
                }
            }
        }
Пример #6
0
        /// <summary>
        /// Run the first thread in the ThreadQueue
        /// </summary>
        private void RunThread(bool nullifyThreadInst = false)
        {
            ThreadQueue.Peek().IsBackground = true;
            ThreadQueue.Peek().Start();
            runningThreads++;

            if (runningThreads >= 3)
            {
                ThreadQueue.Peek().Join();
                runningThreads--;
            }

            ThreadingEventArgs removeArgs = new ThreadingEventArgs();

            removeArgs.Thread = ThreadQueue.Peek();

            ThreadQueue.Dequeue();

            ItemRemovedFromThreadQueue(removeArgs);
        }
Пример #7
0
        private void inputWorker()
        {
            int count = 0; // Using this since its possible one can get added to the queue while another is being processed

            while (ShouldBeRunning)
            {
                while (InputQueue.myCount > 0)
                {
                    ProcessInputPacket(InputQueue.Dequeue());
                    count++;
                }

                if (count > 0)
                {
                    //Counter.AddTick("pps_in", maxThisSecond);
                    //Counter.AddTick("average_pps_in", Counter.GetAverageValue("pps_in"));
                }
                Thread.Sleep(1);
            }
        }
Пример #8
0
    internal void ScheduleNextThread()
    {
        Thread t = readyQueue.Dequeue();

        if (t == null)
        {
            if (collectionRequested)
            {
                CompilerIntrinsics.Cli(); // TODO: superfluous
                NucleusCalls.DebugPrintHex(70, ++gcCount);
                NucleusCalls.DebugPrintHex(60, 0);
                long t1 = NucleusCalls.Rdtsc();

                // No ready threads.
                // Make anyone waiting for GC ready:
                while (true)
                {
                    t = collectionQueue.Dequeue();
                    if (t == null)
                    {
                        break;
                    }
                    readyQueue.Enqueue(t);
                }

                t = readyQueue.Dequeue();

                // Garbage collect, then we're ready to go.
                CompilerIntrinsics.Sti();
                System.DebugStub.Print("GarbageCollecting. ");
                CompilerIntrinsics.Cli();
                NucleusCalls.GarbageCollect();
                collectionRequested = false;

                long t2   = NucleusCalls.Rdtsc();
                uint diff = (uint)((t2 - t1) >> 10);
                NucleusCalls.DebugPrintHex(60, diff);
            }

            while (t == null)
            {
                // TODO: let the CPU sleep here
                // TODO: enable interrupts
                CompilerIntrinsics.Cli(); // TODO: superfluous
                if (!CheckWakeUp())
                {
                    // No threads to run.  The system is finished.
                    CompilerIntrinsics.Cli(); // TODO: superfluous
                    NucleusCalls.DebugPrintHex(0, 0x76543210);
                    while (true)
                    {
                    }
                }

                t = readyQueue.Dequeue();
                CompilerIntrinsics.Cli(); // TODO: superfluous
            }
        }

        // Go to t.
        RunThread(t);

        // We're back.  Somebody (not necessarily t) yielded to us.
    }