99% cpu

[rudolf]

Hi,

I developed a small app that uses the following code snippet:

for (x=0;x<clipBitmap.Width;x+=2)
{
for (y=0;y<clipBitmap.Height;y+=2)
{

/* get hue of current pixel (0-360) */

index=Convert.ToInt16(clipBitmap.GetPixel(x,y).GetHue());

/* increment hue value */

Hue[index]++;

/* same with brightness */

index=Convert.ToInt16(clipBitmap.GetPixel(x,y).GetBrightness()*360.0);
Bri[index]++;
}
}

When the application reaches that code, the CPU goes up to 99% for the
time the code
needs to run. Is it possible to define a CPU limit or something else so
that the CPU does
not hit 99%?

Thanks in advance.

M.

 

[Michael Bray]

(e-mail address removed) wrote in @g44g2000cwa.googlegroups.com:

Is it possible to define a CPU limit or something else so
that the CPU does
not hit 99%?

What would you rather the CPU be doing during that time? Nothing?

Smart Answer:

If there are other processes that need the CPU they will get CPU time
according to the process priority. Set the priority of your thread lower
if you are really worried about impacting other applications. But even in
that case, if there are no other threads that need the CPU, you will still
hit high CPU usage.

Silly Answer:

Use Thread.Sleep(...). This will really only slow your process down and
not really gain you anything except a smaller number on your CPU
utilization report.

-mdb

 

[Kevin Spencer]

I'm not sure I would be as concerned about the CPU percentage used (which is
regulated by the Framework and the OS) as I would about the expense of using
GetPixel to read every pixel from a Bitmap. Here's a little technique that
will speed things up immensely, using unsafe code:

BitmapData bmData = b.LockBits(new Rectangle(0, 0, b.Width, b.Height),
ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);

int stride = bmData.Stride;
System.IntPtr Scan0 = bmData.Scan0;

unsafe
{
byte * p = (byte *)(void *)Scan0;

int nOffset = stride - b.Width*3;
int nWidth = b.Width * 3;

for(int y=0;y<b.Height;++y)
{
for(int x=0; x < nWidth; ++x )
{
// do something with the 3 bytes of the pixel,
//.....
// then increment the pointer.
p +=3;
}
p += nOffset;
}
}

b.UnlockBits(bmData);

--
HTH,

Kevin Spencer
Microsoft MVP
..Net Developer
You can lead a fish to a bicycle,
but it takes a very long time,
and the bicycle has to *want* to change.

 

[Randy A. Ynchausti]

rudolf,

When the application reaches that code, the CPU goes up to 99% for the
time the code needs to run. Is it possible to define a CPU limit or
something else so that the CPU does not hit 99%?

I believe I understand your question. However, there is not just one right
answer. Mainly because the CPU load is not controlled by one application or
thread. It is controlled by the operating system. There is no way you can
guarantee that the CPU load will not reach 99% because your application may
not be able to control what other applications are running at the time it
runs. Some approaches that you might try are:

1) If you want to guarantee that your application does not cause the CPU to
reach 99%, you can monitor the CPU load (see articles about integrating
performance monitoring in an application) and then monitor and detect if the
CPU load is high. When the CPU load is high, activate sleep statements in
your code. The duration of the sleep could be a function of how close to
the 99% CPU load the computer is current at.

2) Set the priority of the thread in which the application is running to a
low priority and then let the operating system manage the distribution of
CPU cycles. However, this may still achieve a 99% CPU load.

3) You can make your application yield the CPU every cycle through your
loops with the statement: Thread.Sleep(0);

There are other ways, but these are a few that you might try to see if they
achieve your objective.

Regards,

Randy

 

[rudolf]

Hi,

thanks for the answers. I will try the other method of reading out the
pixels of the bitmap as
well as the Thread.Sleep(0) command.

Cheers,
M.