CPU LIMITER - LIMITEZ L'UTILISATION DU PROCESSEUR DE CHAQUE PROCESSUS

Commentaire de Fraer9 le 03/02/2009 15:22:48

Merci pour ce code !

Voici la meme chose en c#, c'est une variante plus simple (qu'un seul timer) a utiliser avec l'api JobObjectWrapper (voir http://www.codeplex.com/JobObjectWrapper) pour la limitation d'un ensemble de processus (1 limite pour n processus).

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Timers;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Process[] par = Process.GetProcessesByName("ProcessLauncher");
            CPULimiter cpuLimiter = new CPULimiter(10);

            cpuLimiter.addProcessToWatchList(par[0]);

            // Wait a little
            System.Threading.Thread.Sleep(5000);

            cpuLimiter.addProcessToWatchList(par[1]);

            Console.ReadLine();
        }
    }

    class ProcessWatcher
    {
        private readonly Process _watchedProcess;
        private readonly PerformanceCounter _performanceCounter;
        private bool _isSuspended;

        public ProcessWatcher(Process processToWatch)
        {
          this._watchedProcess = processToWatch;
          this._performanceCounter = new PerformanceCounter(
                    "Process",
                    "% Processor Time",
                    processToWatch.ProcessName);
          // Init the perf counter
          this._performanceCounter.NextValue();            
          this._isSuspended = false;
        }

        public Process watchedProcess
        {
            get { return this._watchedProcess; }
        }

        public PerformanceCounter performanceCounter
        {
            get { return this._performanceCounter; }
        }

        public bool isSuspended
        {
            get { return this._isSuspended; }
            set { this._isSuspended = value; }
        }
    }

    class CPULimiter
    {
        [DllImport("ntdll.dll", EntryPoint = "NtResumeProcess", SetLastError = true)]
        private static extern uint NtResumeProcess(IntPtr processHandle);

        [DllImport("ntdll.dll", EntryPoint = "NtSuspendProcess", SetLastError = true)]
        private static extern uint NtSuspendProcess(IntPtr processHandle);
        
        // see if 1sec based rate in ms is not too often
        public const int REFRESH_RATE_BASE_MS = 100;

        private readonly List<ProcessWatcher> watchList;

        private readonly float maxCpuUsagePercetage;
        private readonly Timer watchingTimer;

        public CPULimiter(int maxCpuUsagePercentageBase100)
        {
            // Initialize the list
            this.watchList = new List<ProcessWatcher>();
            // Convert to processor count based percentage
            this.maxCpuUsagePercetage = maxCpuUsagePercentageBase100 * Environment.ProcessorCount;
            // Create the watching timer
            this.watchingTimer = new Timer();
            // Hook up the Elapsed event for the timer.
            this.watchingTimer.Elapsed += new ElapsedEventHandler(OnTimedEvent);
            // Set the timer refresh rate
            this.watchingTimer.Interval = REFRESH_RATE_BASE_MS;            
        }

        public void addProcessToWatchList(Process processToWatch)
        {
            // Stop the timer...
            this.watchingTimer.Enabled = false;
            // Add this watcher to the watch list
            this.watchList.Add(new ProcessWatcher(processToWatch));
            // Restart the timer      
            this.watchingTimer.Enabled = true;
        }

        // Executed by a timer every REFRESH_RATE_BASE_MS        
        public void OnTimedEvent(object source, ElapsedEventArgs e)
        {
            // Manually stop the timer...            
            this.watchingTimer.Enabled = false;            
            // Save the last exceeding cpu usage
            float lastExceedingCpuUsage = 0;
            bool cpuUsageLimitExceeded = false;
            for (int i = this.watchList.Count - 1; i >= 0; i--)
            {
                ProcessWatcher processWatcher = this.watchList[i];
                // Check if the process has exited
                if (processWatcher.watchedProcess.HasExited)
                {
                    // Remove this process watcher from the watch list
                    this.watchList.RemoveAt(i);
                }
                else
                {
                    // If the process is suspended resume it
                    if (processWatcher.isSuspended)
                    {
                        // Re init the perf counter since the process was suspended
                        processWatcher.performanceCounter.NextValue();
                        if (NtResumeProcess(processWatcher.watchedProcess.Handle) == 0)
                        {
                            processWatcher.isSuspended = false;
                        }
                        else
                        {
                            // Something bad happended so remove this watcher
                            this.watchList.RemoveAt(i);
                        }                        
                    }
                    else
                    {
                        lastExceedingCpuUsage = processWatcher.performanceCounter.NextValue();
                        if (lastExceedingCpuUsage > this.maxCpuUsagePercetage)
                        {
                            //Console.WriteLine("Process reached the limit Process:{0} CPU% {1}", processWatcher.performanceCounter.InstanceName, lastExceedingCpuUsage);
                            cpuUsageLimitExceeded = true;
                            break;
                        }
                    }
                }
            }

            int nextInterval = REFRESH_RATE_BASE_MS;

            // If cpu usage has been reached
            if (cpuUsageLimitExceeded)
            {
                for (int i = this.watchList.Count - 1; i >= 0; i--)
                {
                    ProcessWatcher processWatcher = this.watchList[i];
                    // Check if the process has exited
                    if (processWatcher.watchedProcess.HasExited)
                    {
                        // Remove this process watcher from the watch list
                        this.watchList.RemoveAt(i);
                    }
                    else
                    {
                        // Since some process watchers can already be suspended we need to check the state
                        if (!processWatcher.isSuspended)
                        {
                            // Suspend the process
                            if (NtSuspendProcess(processWatcher.watchedProcess.Handle) == 0)
                            {
                                processWatcher.isSuspended = true;
                            }
                            else
                            {
                                // Something bad happended so remove this watcher                                
                                this.watchList.RemoveAt(i);
                            }
                        }
                    }
                }
                // Compute the time to wait in order to reach the given percentage
                // formula : TimeToWait = BASE * ((previous_percentage / wanted_percentage) - 1)
                nextInterval = Convert.ToInt32(REFRESH_RATE_BASE_MS * ((lastExceedingCpuUsage / this.maxCpuUsagePercetage) - 1));
                if (nextInterval < 20) {            
                    nextInterval = 20;
                }                
            }
            
            // Change the next start            
            this.watchingTimer.Interval = nextInterval;
            this.watchingTimer.Enabled = true;
        }
    }
}