Discussion :

[azstar]

Bonjour,

je cherche a savoir comment extraire les pourcentage de utilisation de processeur par un processus ?


Nb:

que j'arrive a extraire la liste des processus par la methodes GetProcesses

et merci par avance

[azstar]

Bonjour,

en demandant a Mr google

j'ai trouve que il faut faire un sort de calcule dont je n'est rien compris

si qlq un a une idée sur ce sujet

[Pol63]

jette un oeil sur wmi peut etre

[azstar]

Pol63 jette un oeil sur wmi peut etre

je laisse l'utilisations des WMI en dernier etape

[Pol63]

et sur le class process ? je vois qu'il y a TotalProcessorTime et UserProcessorTime ...

edit, j'ai fait F1 dessus et c'est un timespan ^^ donc ca doit etre ca dont tu parles pour le calcul ...

[azstar]

j'ai trouve ca sur internet mais c'est avoir le % total de CPU

[azstar]

j'ai trouve cette classe mais j'arrive pas de bien comprendre comment on peut extriare les pourcentage dedie a un processus

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
using System;using System.Collections.Generic;
 using System.Text;
 using System.Runtime.InteropServices;
 using ComTypes = System.Runtime.InteropServices.ComTypes;
 using System.Threading;
 using System.Diagnostics;
 
   namespace CpuUsageCs
   {
       class CpuUsage
       {
           [DllImport("kernel32.dll", SetLastError = true)]
           static extern bool GetSystemTimes(
                       out ComTypes.FILETIME lpIdleTime,
                      out ComTypes.FILETIME lpKernelTime,
                      out ComTypes.FILETIME lpUserTime
                       );
 
           ComTypes.FILETIME _prevSysKernel;
           ComTypes.FILETIME _prevSysUser;
 
           TimeSpan _prevProcTotal;
 
           Int16 _cpuUsage;
           DateTime _lastRun;
           long _runCount;
 
           public CpuUsage()
           {
               _cpuUsage = -1;
             _lastRun = DateTime.MinValue;
              _prevSysUser.dwHighDateTime = _prevSysUser.dwLowDateTime = 0;
               _prevSysKernel.dwHighDateTime = _prevSysKernel.dwLowDateTime = 0;
               _prevProcTotal = TimeSpan.MinValue;
               _runCount = 0;
           }
 
           public short GetUsage()
           {
               short cpuCopy = _cpuUsage;
               if (Interlocked.Increment(ref _runCount) == 1)
               {
                   if (!EnoughTimePassed)
                  {
                       Interlocked.Decrement(ref _runCount);
                       return cpuCopy;
                   }
 
                   ComTypes.FILETIME sysIdle, sysKernel, sysUser;
                   TimeSpan procTime;
 
                   Process process = Process.GetCurrentProcess();
                   procTime = process.TotalProcessorTime;
 
                   if (!GetSystemTimes(out sysIdle, out sysKernel, out sysUser))
                   {
                       Interlocked.Decrement(ref _runCount);
                       return cpuCopy;
                   }
 
                   if (!IsFirstRun)
                   {
                       UInt64 sysKernelDiff =
                           SubtractTimes(sysKernel, _prevSysKernel);
                       UInt64 sysUserDiff =
                         SubtractTimes(sysUser, _prevSysUser);
 
                       UInt64 sysTotal = sysKernelDiff + sysUserDiff;
 
                       Int64 procTotal = procTime.Ticks - _prevProcTotal.Ticks;
 
                      if (sysTotal > 0)
                       {
                           _cpuUsage = (short)((100.0 * procTotal) / sysTotal);
                       }
                   }
 
                   _prevProcTotal = procTime;
                   _prevSysKernel = sysKernel;
                   _prevSysUser = sysUser;
 
                   _lastRun = DateTime.Now;
 
                   cpuCopy = _cpuUsage;
               }
               Interlocked.Decrement(ref _runCount);
 
               return cpuCopy;
 
           }
 
           private UInt64 SubtractTimes(ComTypes.FILETIME a, ComTypes.FILETIME b)
           {
               UInt64 aInt =
               ((UInt64)(a.dwHighDateTime << 32)) | (UInt64)a.dwLowDateTime;
              UInt64 bInt =
               ((UInt64)(b.dwHighDateTime << 32)) | (UInt64)b.dwLowDateTime;
 
              return aInt - bInt;
          }
 
          private bool EnoughTimePassed
          {
              get
              {
                  const int minimumElapsedMS = 250;
                  TimeSpan sinceLast = DateTime.Now - _lastRun;
                  return sinceLast.TotalMilliseconds > minimumElapsedMS;
              }
          }
 
         private bool IsFirstRun
          {
              get
              {
                  return (_lastRun == DateTime.MinValue);
              }
          }
      }
 }

[azstar]

Bonjour,

si j'ai bien compris le

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

UserProcessorTime

est le temps qui a la passé le processus en CPU en mode utilisateur.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

TotalProcessorTime

est le temps qui la passé le processus en CPU en mode utilisateur+en mode Kernel .

alors pour avoir le % d'utilisation de CPU de ce processus je doit calculer le temps total de tt les Processus et faire le "/"

j'obtient alors "peut etre"

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
int PR=(pr.TotalProcessorTime.TotalMilliseconds/TotaltempsCPU)*100/NbredesCPU

????