How to make my program consume less CPU without disturbing its execution?

Question

I have a program that reads the memory of a computer process continuously (with the while (true)), but it ends up requiring a lot of CPU, arriving at 20% used, my question is, how to decrease CPU usage without losing performance in the program?

I tried the Thread.Sleep(10), has worked, CPU usage has dropped to 1%, but even though it is only 10 thousandths, program performance has dropped dramatically.

while (Vars.GlowActive) //Essa variavel sempre vai ser true
    if (Vars.GlowAlways || Vars.GetKeyState(Vars.GlowButton) == 0)
    {
        for (int num = 1; num < 24; num++)
        {
            int entity = mem.Read<int>(Vars.bClient + Vars.EntList + (num * 0x10));
            ehealth = mem.Read<int>(entity + Vars.Health);

            int Glow = mem.Read<int>(entity + Vars.GlowIndex);
            int EntTeam = mem.Read<int>(entity + Vars.Team);
            if (EntTeam == Vars.MyTeam)
            {
                if (Vars.glowteamenabled)
                {
                    if (Vars.TeamRainbow)
                        TeamColor();
                    color[0] = Vars.glow_team_r / 255;
                    color[1] = Vars.glow_team_g / 255;
                    color[2] = Vars.glow_team_b / 255;
                    DrawGlow(Glow, color);
                }
            }
            else
            {
                if (Vars.glowenemyenabled)
                {
                    if (Vars.EnemyRainbow)
                        EnemyColor();
                    else if (Vars.glowhealth)
                    {
                        Vars.glow_enemy_r = 255 - 2.55f * ehealth;
                        Vars.glow_enemy_g = 2.55f * ehealth;
                        Vars.glow_enemy_b = 0;
                    }
                    color[0] = Vars.glow_enemy_r / 255;
                    color[1] = Vars.glow_enemy_g / 255;
                    color[2] = Vars.glow_enemy_b / 255;
                    DrawGlow(Glow, color);
                }
            }
        }
    }
    else if (one && Vars.BeepEnable)
    {
        Console.Beep(3000, 200);
        one = !one;
    }
}

Sumario:

mem.Read reads the memory of a process.

DrawGlow() writes in memory.

Answer 1

Try decreasing Sleep duration

Thread.Sleep(1);

Or use a Timer

var timer =  new  System.Timers.Timer();
timer.Interval = 10;
timer.Elapsed += (ctx, arg) => /*chama a sua funcao aqui*/;
timer.AutoReset = true;
timer.Start();

Answer 2

Not everything or anything

A program that runs without stopping consumes more CPU. A program that sleeps always loses performance. How about then do both, but not always?

        while ( Vars.GlowActive )
        {
            if ( Vars.GlowAlways || Vars.GetKeyState( Vars.GlowButton ) == 0 )
            {
                for ( int num = 1 ; num < 24 ; num++ ) // Ver observação
                {
                }

                // Já que teve uma execuçao válida, não cairia no elseif abaixo
                // então explicitamente tenta executar de novo
                continue;
            }
            else if ( one && Vars.BeepEnable )
            {
                Console.Beep( 3000 , 200 );
                one = !one;
            }
            // Se chegou aqui, não tinha dados a processar.
            // Dar uma folga a espera de novos dados.
            System.Threading.Thread.Yield();
        }

Observing

• This number 24 looks kind of magical. See if it’s required by the API you’re using. But if it’s just an attempt to balance load between rounds and beeps, the best thing would be to take that for, and move the beep test inside the while.

Answer 3

Decrease the amount of If s in your program, so I saw you can use an and in some if’s, this should improve a little.