Why is console animation so slow on Windows? (And is there a way to improve speed?)

Question

Well I was bored so wanted to make an animation in a console window.

Now when I setup the first bits I noticed it is very slow, something around 333ms for a whole screen to fill with characters..

I am wondering if there is a way to at least get ~20 fps?

Here is my code:

#include <stdio.h>
#include <tchar.h>
#include <Windows.h>
#include <iostream>
#include <array>

#define WIDTH (100)
#define HEIGHT (35)

bool SetWindow(int Width, int Height) { 
    _COORD coord; 
    coord.X = Width; coord.Y = Height; 

    _SMALL_RECT Rect; 
    Rect.Left = 0;              Rect.Top = 0;  
    Rect.Bottom = Height - 1;   Rect.Right = Width - 1; 

    HANDLE Handle = GetStdHandle(STD_OUTPUT_HANDLE); 
    if (Handle == NULL)return FALSE; 
    SetConsoleScreenBufferSize(Handle, coord);
    if(!SetConsoleWindowInfo(Handle, TRUE, &Rect)) return FALSE; 
    return TRUE; 
} 

std::array<std::array<unsigned char, WIDTH+1>, HEIGHT> Screen;//WIDTH+1 = prevent cout from undefined behaviour

void Putchars(unsigned char x){
    for(int row = 0; row < HEIGHT; ++row){
        std::fill(Screen[row].begin(),Screen[row].end(),x);
        Screen[row].at(WIDTH) = 0;//here = prevent cout from undefined behaviour
    }
}

void ShowFrame(DWORD delay = 0,bool fPutchars = false, unsigned char x = 0){
    if(fPutchars)Putchars(x);
    if(delay)Sleep(delay);
    system("CLS");
    for(int row = 0; row < HEIGHT; ++row)
        std::cout << Screen[row].data() << std::flush;
}

int _tmain(int argc, _TCHAR* argv[]){//sould execute @~63 fps, yet it executes @~3-4 fps
    if(SetWindow(100,HEIGHT)){
        for(unsigned char i = 219; i != 0; --i)
        ShowFrame(16,true, i);
    }
    return 0;
}

Edit: after reading numerous answers, tips and comments I finally worked it out, thank you guys, this is my final "base" code:

#include <stdio.h>
#include <tchar.h>
#include <Windows.h>
#include <iostream>
#include <array>

#define WIDTH (100)
#define HEIGHT (34)

HANDLE current;
HANDLE buffer;

bool SetWindow(int Width, int Height) { 
    _COORD coord; 
    coord.X = Width; coord.Y = Height; 

    _SMALL_RECT Rect; 
    Rect.Left = 0;              Rect.Top = 0;  
    Rect.Bottom = Height - 1;   Rect.Right = Width - 1; 

    HANDLE Handle = GetStdHandle(STD_OUTPUT_HANDLE); 
    if (Handle == NULL)return FALSE; 
    SetConsoleScreenBufferSize(Handle, coord);
    if(!SetConsoleWindowInfo(Handle, TRUE, &Rect)) return FALSE; 
    return TRUE; 
} 

std::array<std::array<CHAR, WIDTH+1>, HEIGHT> Screen;//WIDTH+1 = prevent cout from undefined behaviour

void Putchars(CHAR x){
    for(int row = 0; row < HEIGHT; ++row){
        std::fill(Screen[row].begin(),Screen[row].end(),x);
        Screen[row].at(WIDTH) = 0;//here = prevent cout from undefined behaviour
    }
}

void ShowFrame(DWORD delay = 0, bool fPutchars = false, CHAR x = 0){
    if(fPutchars)Putchars(x);
    if(delay)Sleep(delay);
    //system("CLS");
    _COORD coord;
    coord.X = 0;
    for(int row = 0; row < HEIGHT; ++row)
    {
        coord.Y = row;
        FillConsoleOutputCharacterA(buffer,Screen[row].data()[0],100,coord,NULL);
    }
}

int _tmain(int argc, _TCHAR* argv[]){//sould execute @~63 fps, yet it executes @~3-4 fps
    SetWindow(WIDTH, HEIGHT);
    current = GetStdHandle (STD_OUTPUT_HANDLE);
    buffer = CreateConsoleScreenBuffer (
        GENERIC_WRITE,
        0,
        NULL,
        CONSOLE_TEXTMODE_BUFFER,
        NULL
    );
    SetConsoleActiveScreenBuffer (buffer);

    if(SetWindow(WIDTH,HEIGHT)){
        for(CHAR i = 219; i != 0; --i)
        ShowFrame(250,true, i);
    }
    CloseHandle (buffer); //clean up
    return 0;
}

and it seems to work very fast :)

Answer 1

Just glancing at your code, you're spawning a separate program ("CLS") once per frame. That's horrendously slow all by itself.

Contrary to some of the comments, the Windows console is capable of at least fairly reasonable speed if used even close to correctly (as in: you can update the console faster than any monitor can display the data).

Just for reference, here's a version of John Conway's Game of Life written for the Windows console. For timing purposes, it just generates a random starting screen and runs for 2000 generations, then stops. On my machine, it does 2000 generations in about 2 seconds, or around 1000 frames per second (useless, since a typical monitor can only update at around 60-120 Hz). Under 32-bit Windows with a full-screen console, it can roughly double that (again, at least on my machine). I'm pretty sure with a little work, this could be sped up some more, but I've never seen any reason to bother.

#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <conio.h>
#include <io.h>

#define     ROWS        50
#define     COLS        80

// The total number of generations is really double this number.
int generations = 1000;

int civ1[ROWS+2][COLS+2], civ2[ROWS+2][COLS+2];

CHAR_INFO disp[ROWS][COLS];
HANDLE console;
COORD size = { COLS, ROWS };
COORD src = { 0, 0};
SMALL_RECT  dest = { 0, 0, COLS, ROWS };

void ClrScrn(char attrib) {
    COORD pos = { 0, 0};
    DWORD written;
    unsigned size;

    size = ROWS * COLS;

    FillConsoleOutputCharacter(console, ' ', size, pos, &written);
    FillConsoleOutputAttribute(console, attrib, size, pos, &written);
    SetConsoleCursorPosition(console, pos);
}

void fill_edges(int civ1[ROWS+2][COLS+2]) {
    int i, j;

    for (i=1; i<=ROWS; ++i) {
        civ1[i][0] = civ1[i][COLS];
        civ1[i][COLS+1] = civ1[i][1];
    }
    for (j=1; j<=COLS; ++j) {
        civ1[0][j] = civ1[ROWS][j];
        civ1[ROWS+1][j] = civ1[1][j];
    }
    civ1[0][0] = civ1[ROWS][COLS];
    civ1[ROWS+1][COLS+1] = civ1[1][1];
    civ1[0][COLS+1] = civ1[ROWS][1];
    civ1[ROWS+1][0] = civ1[1][COLS];
}

void update_generation(int old_gen[ROWS+2][COLS+2], 
                       int new_gen[ROWS+2][COLS+2])
{
    int i, j, count;

    for (i = 1; i <= ROWS; ++i)
    {
        for (j = 1; j <= COLS; ++j)
        {
            count = old_gen[i - 1][j - 1] +
                old_gen[i - 1][j] +
                old_gen[i - 1][j + 1] +
                old_gen[i][j - 1] +
                old_gen[i][j + 1] +
                old_gen[i + 1][j - 1] +
                old_gen[i + 1][j] +
                old_gen[i + 1][j + 1];

            switch(count) 
            {
            case 2:
                new_gen[i][j] = old_gen[i][j];
                break;

            case 3:
                new_gen[i][j] = 1;
                disp[i-1][j-1].Char.AsciiChar = '*';
                break;
            default:
                new_gen[i][j] = 0;
                disp[i-1][j-1].Char.AsciiChar = ' ';
                break;
            }
        }
    }
    WriteConsoleOutput(console, (CHAR_INFO *)disp, size, src, &dest);
    fill_edges(new_gen);
}

void initialize(void)
{
    int i, j;

    ClrScrn(0x71);
    srand(((unsigned int)time(NULL))|1);

    for (i = 1; i <= ROWS; ++i)
    {
        for (j = 1; j <= COLS; ++j)
        {
            civ1[i][j] = (int)(((__int64)rand()*2)/RAND_MAX);
            disp[i-1][j-1].Char.AsciiChar = civ1[i][j] ? '*' : ' ';
            disp[i-1][j-1].Attributes = 0x71;
        }
    }
    WriteConsoleOutput(console, (CHAR_INFO *)disp, size, src, &dest);
    fill_edges(civ1);
}

int main(int argc, char **argv) {

    int i;

    if ( argc != 1)
        generations = atoi(argv[1]);

    console = GetStdHandle(STD_OUTPUT_HANDLE);
    initialize();
    for (i = 0; i <generations; ++i)
    {
        update_generation(civ1, civ2);
        update_generation(civ2, civ1);
    }
    return EXIT_SUCCESS;
}

If nothing else, this has a ClrScrn function you may find handy.

Answer 2

Do not use cout to write to console. Use the WriteConsole from console API instead. And you can use double buffering like in normal graphical animations with SetConsoleActiveScreenBuffer. http://msdn.microsoft.com/en-us/library/windows/desktop/ms682073.aspx

Also don't use system ("cls") to clear the screen, FillConsoleOutputCharacter is a lot faster.