Styjun

I have this program that checks the amount of CPU being used by the current Python process.

import os
import psutil

p = psutil.Process(os.getpid())

counter = 0
while True:
 if counter % 1000 == 0:
 print(p.cpu_percent())
 counter += 1

The output is:

98.79987719751766
98.79981257674615
98.79975442677997
98.80031017770553
98.80022615662917
98.80020675841527
98.80027781367056
98.80038116157328
98.80055555555509
98.80054906013777
98.8006523704943
98.80072337402265
98.80081374321833
98.80092993219198
98.80030995738038
98.79962549234794
98.79963842975158
98.79916715088079
98.79930277598402
98.7993480085206
98.79921895171654
98.799154456851

As seen by the output, this program is taking up 100% of my CPU and I'm having a tough time understanding why. I noticed that putting a time.sleep(0.25) causes CPU usage to go down to zero.

In my actual application, I have a similar while loop and can't afford to have a sleep in the while loop since it is reading a video from OpenCV and needs to stay realtime.

import cv2

cap = cv2.VideoCapture("video.mp4")
while True:
 success, frame = cap.retrieve()

This program takes the same amount of CPU as the first program I wrote, but this one decodes video!

If someone could explain a bit more that'd be awesome.

I hope you are doing great!

When you do:

while True:
if counter % 1000 == 0:
 print(p.cpu_percent())
counter += 1

You actually ask your computer to process constantly.

It is going to increment counter as fast as possible and will display the cpu_percent every time counter is modulo of 1000.

It means that your program will feed the CPU constantly with the instructions of incrementing that counter.

When you use sleep, you basically say to the OS (operating system) that your code shouldn't execute anything new before sleep time. Your code will then not flood the CPU with instructions.

Sleep suspends execution for the given number of seconds.

Currently it is better to use a sleep than the counter.

import os
import psutil
import time
p = psutil.Process(os.getpid())

counter = 0
while True:
 time.sleep(1)
 print(p.cpu_percent())

I hope it is helping.

Have a lovely day,

G

Your original loop is doing something as fast as it can. Any program that is doing purely CPU bound work, with no significant blocking operations involved, will happily consume the whole CPU, it just does whatever it's doing faster if the CPU is faster.

Your particular something is mostly just incrementing a value and dividing it by 1000 over and over, which is inefficient, but making it more efficient, e.g. by changing the loop to:

import os
import psutil

p = psutil.Process(os.getpid())

while True:
 for i in range(1000): pass
 print(p.cpu_percent())

removing all the division work and having a more efficient addition (range does the work at the C layer), would just mean you do the 1000 loops faster and print the cpu_percent more often (it might slightly reduce the CPU usage, but only because you might be printing enough that the output buffer is filled faster than it can be drained for display, and your program might end up blocking on I/O occasionally).

Point is, if you tell the computer to do something forever as fast as it can, it will. So don't. Use a sleep; even a small one (time.sleep(0.001)) would make a huge difference.

For your video capture scenario, seems like that's what you want in the first place. If the video source is producing enough output to occupy your whole CPU, so be it; if it isn't, and your code blocks when it gets ahead, that's great, but you don't want to slow processing just for the sake of lower CPU usage if it means falling behind/dropping frames.

You might want to add in a time.sleep(numberOfSeconds) to your loop if you don't want it to be using 100% CPU all the time, if it's only checking for a certain condition over and over.
i think this will solve your problem