Code Optimizations

Hey there /prog/, let's talk about optimization or different things we can do to speed up our applications.

Currently I'm writing a game, and it usually takes up around ~50% of my CPU usage on the bigger maps.  I have a vector that contains all of my blocks, enemies, and other things that should be drawn on the screen.

In my draw thread, it could look like this:
player.draw();
for (int bi = 0; bi < blocks.size(); bi++)
{
    if (InCameraView(blocks[bi]))
    {
        draw(blocks[bi]);
    }
}

In my update thread, it looks like:
player.update();
for (int bi = 0; bi < blocks.size(); bi++)
{
    if (InCameraView(blocks[bi]))
    {
        player.TouchGround(blocks[bi]);
        for (int ei = 0; ei < enemies.size(); ei++)
        {
            enemies.update();
            enemies[ei].TouchGround(blocks[bi]);
        }
    }
}

Obviously only an example, and I typically have lots of more objects that are currently being drawn on the screen.  I also understand that it's usually very bad to have nested for loops, but I'm not exactly sure how else I could handle this.

Also, for rendering I have a lot of "switch" blocks to determine what I should render or update.

switch (CurrentWorld)
{
    case Worlds::MainMenu:
        worldMainMenu.draw();
    break
    case Worlds::Level:
        worldLevel.draw();
    break;
}

Also, for updating thread:
while (true)
{
    while (resetTime >= gameTime)
    {
        resetTime -= gameTime;
    switch (CurrentWorld)
    {
            case Worlds::MainMenu:
                mainMenu.update();
            break;
        case Worlds::Level:
            worldLevel.update();
        break;
    }
    }
}

How do you guys like to optimize your applications to run better and use less processing power?

I think that is a good use for a nested loop in the update function. You are filtering out unneeded blocks and avoiding updating the entities in them. Right now, you are determining which blocks need processing by looping over all of them and then testing them with the InCameraView function. So the routine will always run in time that is at least proportional to the number of blocks. You may be able to speed things up by using a method that takes less work to find out which blocks need processing and which ones don't. If you can get this procedure to take time proportional to only the number of active blocks, then you'd probably get a good boost. You would need to take advantage of the type of environment your game has though.