{"id":54823,"date":"2008-11-25T11:26:00","date_gmt":"2008-11-25T11:26:00","guid":{"rendered":"https:\/\/blogs.technet.microsoft.com\/heyscriptingguy\/2008\/11\/25\/hey-scripting-guy-how-can-i-determine-the-average-process-utilization-for-my-computer\/"},"modified":"2008-11-25T11:26:00","modified_gmt":"2008-11-25T11:26:00","slug":"hey-scripting-guy-how-can-i-determine-the-average-process-utilization-for-my-computer","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/scripting\/hey-scripting-guy-how-can-i-determine-the-average-process-utilization-for-my-computer\/","title":{"rendered":"Hey, Scripting Guy! How Can I Determine the Average Process Utilization for My Computer?"},"content":{"rendered":"

\"Hey, <\/h2>\n

I would like to determine the average processor utilization for my computer over a certain period of time. If I could run this remotely, it would be even better. Can this be done?<\/p>\n

– MP<\/p>\n

\"Spacer\"\"Hey,<\/p>\n

Hi MP,<\/p>\n

We can certainly do this. In fact, it can be done both locally and remotely. But you do need to be careful of the Heisenberg uncertainty principle<\/a>.<\/p>\n

There are a couple of ways we can query for performance information. We can use the Get-WmiObject<\/b> cmdlet, which is very easy to use and understand. We can also use the System.Management.Management<\/b> .NET Framework class directly. This is perhaps a bit easier to do than it might seem because of the existence of the [WMI]<\/b> type accelerator. Before choosing our approach, let’s examine each potential solution to see which code is the best to use.<\/p>\n

For our test, let’s obtain the total processor utilization time for the first CPU in our machine. Let’s print this value out ten times. This command is one logical command and uses the line continuation character at the end of the first line to allow for multiline entry. This command uses the [WMI]<\/b> type accelerator. The command begins by using a for<\/b> statement that begins counting at 1, continues until the value of $i<\/b> is less than or equal to 10, and increments the value of $i<\/b> by one. The code block, which is demarked by the curly brackets, uses the [WMI]<\/b> type accelerator to return a specific instance of the Win32_PerfFormattedData_PerfOS_Processor<\/b> WMI class. These instances are seen in the WbemTest tool<\/a> when you choose the instances<\/b> button from the class<\/b> page:<\/p>\n

\"Image<\/p>\n

 <\/p>\n

You will notice that each instance is referenced by the name of the class, the name<\/b> property, and then a value for the name<\/b> property. The name<\/b> property is the key<\/b> property for the Win32_PerfFormattedData_PerfOS_Processor<\/b> WMI class. When you are using the [WMI]<\/b> type accelerator, you always need to give it a value for the key<\/b> property of the class. This process of using the [WMI]<\/b> type accelerator to connect to a specific instance of a class is similar to the VBScript Get<\/b> method. The Get<\/b> method of the sWbemServices<\/b> object is talked about on this page<\/a>. After we have the specific instance of the Win32_PerfFormattedData_PerfOS_Processor<\/b> WMI class, we can return the percentProcessorTime<\/b> property value:<\/p>\n

for($i = 1 ; $i -le 10 ; $i++) `\n{ \n ([wmi]\"Win32_PerfFormattedData_PerfOS_Processor.name='0'\").percentProcessorTime\n}\n<\/pre>\n
When it is run, it prints out the current processor utilization 10 different times.<\/p>\n
If you were to use Get-WmiObject<\/b> , the code would be very similar in concept. The Get-WmiObject<\/b> cmdlet takes the –class<\/b> parameter, which allows it to query a specific WMI class. This is similar to using the ExecQuery<\/b> method from the sWbemServices<\/b> object. The ExecQuery<\/b> method is documented here<\/a>. To keep the cmdlet from returning information from all the processors, the –filter<\/b> parameter is used to limit the amount of information that is returned. This is similar to using a where<\/b> clause in a VBScript WMI query<\/a>. Because only one instance of the class is returned, we can also use the dotted notation to retrieve a specific property from the object. This code is shown here:<\/p>\n
for($i = 1 ; $i -le 10 ; $i++) `\n{ \n (Get-WmiObject -class Win32_PerfFormattedData_PerfOS_Processor –filter \"name='0'\").percentProcessorTime \n}\n<\/pre>\n
If we use the measure-command<\/b> cmdlet to see if one approach is faster than the other, we would see that both commands take approximately five seconds to execute. There is no appreciable difference in the performance of the two commands. So the choice is the syntax with which you are the most familiar. <\/p>\n
So here it is, the GetWmiPerformanceData.ps1<\/b> script.<\/p>\n
Function GetWmiPerformanceData()\n{\n For($i = 1 ; $i -le $reps ; $i++)\n  {\n   ([wmi]\"\\\\$computer\\root\\cimv2:$class.$key='$instance'\").$Property\n   Start-Sleep -Seconds $delay\n  } #end for\n}#end GetWmiPerformanceData\n\n$computer = \"vista\"\n$delay = 1\n$reps = 2\n$class = \"Win32_PerfFormattedData_PerfOS_Processor\"\n$key = \"name\"\n$instance = \"_Total\"\n$property = \"PercentProcessorTime\"\n\nGetWmiPerformanceData\n<\/pre>\n
The GetWmiPerformanceData.ps1<\/b> script begins by declaring a function that is named GetWmiPerformanceData<\/b>. This function is used to query the WMI class a certain number of times, and to return a specific property from a specific instance on a specific computer. The cool thing about the function is that everything is abstracted. This follows the prime directive<\/a> for scripting which means do not mess with the worker section of the script. The four parts of a script are detailed in the Microsoft VBScript Step by Step<\/a> book. The for<\/b> statement begins with the value of $i<\/b> equal to 1, and continues until it is less than or equal the value set in the variable $reps<\/b>. It is incremented by one on each loop. This is seen here:<\/p>\n
For($i = 1 ; $i -le $reps ; $i++)<\/pre>\n
Inside the code block, the [WMI]<\/b> type accelerator is used to connect to the root\\cimv2<\/b> WMI namespace on the computer that is specified in the $computer<\/b> variable. The WMI class that will be queried is stored in the $class<\/b> variable and the key<\/b> property name is in the $key<\/b> variable. The particular instance to return is defined in the $instance<\/b> variable, and the property we are interested in is stored in the $property<\/b> variable. Although this particular syntax is a bit complicated, the fact that it is stored in a function with everything abstracted into a variable means it can be used over again without requiring any changes. This line of code is shown here:<\/p>\n
([wmi]\"\\\\$computer\\root\\cimv2:$class.$key='$instance'\").$Property<\/pre>\n
Because you might want to pause the script between polling cycles, the start-sleep<\/b> cmdlet is used to halt script execution. The specified time is supplied in seconds, although milliseconds could have been used. This line of code is shown here:<\/p>\n
Start-Sleep -Seconds $delay<\/pre>\n
The bulk of the script is supplying values for the variables. The computer<\/b> variable holds the name of the computer to query. This could be a local or a remote computer. The $delay<\/b> variable controls the time between polling, and the $reps<\/b> variable controls how many times the script will poll. The $class<\/b> variable holds a WMI performance counter<\/b> class, and the $key<\/b> variable holds the key<\/b> property for the class. Note that this script will not work on a WMI class that contains a composite key (more than one key property). The $instance<\/b> variable is used to supply the name of the particular instance to query. This is seen is seen here:<\/p>\n
$computer = \"vista\"\n$delay = 1\n$reps = 2\n$class = \"Win32_PerfFormattedData_PerfOS_Processor\"\n$key = \"name\"\n$instance = \"_Total\"\n$property = \"PercentProcessorTime\"\n<\/pre>\n
Once all the variables have been supplied values, the last thing to do is to actually call the function. This is easily done by simply placing the function name on a line by itself as seen here:<\/p>\n
GetWmiPerformanceData<\/pre>\n
When we run the script, the results are not all that impressive. It is just a list of numbers displayed on the console.<\/p>\n
MP, this should move you closer to using the WMI performance counter<\/b> classes. Tomorrow, we will see what we can do about processing the numbers that are written to the screen. See ya!<\/p>\n
Ed Wilson and Craig Liebendorfer, Scripting Guys<\/b><\/b><\/span><\/span><\/p>\n
<\/b><\/span><\/p>\n","protected":false},"excerpt":{"rendered":"
I would like to determine the average processor utilization for my computer over a certain period of time. If I could run this remotely, it would be even better. Can this be done? – MP Hi MP, We can certainly do this. In fact, it can be done both locally and remotely. But you do […]<\/p>\n","protected":false},"author":595,"featured_media":87096,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[31,60,3,45],"class_list":["post-54823","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-scripting","tag-operating-system","tag-performance","tag-scripting-guy","tag-windows-powershell"],"acf":[],"blog_post_summary":"
I would like to determine the average processor utilization for my computer over a certain period of time. If I could run this remotely, it would be even better. Can this be done? – MP Hi MP, We can certainly do this. In fact, it can be done both locally and remotely. But you do […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/54823","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/users\/595"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/comments?post=54823"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/54823\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/media\/87096"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/media?parent=54823"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/categories?post=54823"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/tags?post=54823"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}