Windows Console frame rate dropped after running program

Question

As the title suggests I'm having an issue with my windows console application in c++. So far I've created a class, Console, to represent all of the functions I repeatedly use to construct a windows console. I implemented a line drawing algorithm and had up to 500 fps when filling the screen with magenta characters and drawing a line in white. However, I implemented a triangle drawing algorithm next (just three line drawing calls consecutively) and was surprised to find out that the frame rate dropped to about 20. I removed this code again but the bad frame rate persisted. I really don't know why this has happend because I've essentially ended up not changing anything.

For reference, here is the Console code (without header):

Console::Console(int width, int height):
    m_handle(GetStdHandle(STD_OUTPUT_HANDLE)),
    m_width(width),
    m_height(height),
    m_screen({ 0, 0, 1, 1 }),
    m_title(L"Demo"),
    m_buffer(new CHAR_INFO[(size_t)m_width * (size_t)m_height])
{
    memset(m_buffer, 0, sizeof(CHAR_INFO) * m_width * m_height);
}

Console::~Console()
{
    if (m_buffer)
        delete[] m_buffer;
}

int Console::Construct(int char_w, int char_h)
{
    if (m_handle == INVALID_HANDLE_VALUE)
        return BAD_HANDLE;

    if (!SetConsoleWindowInfo(m_handle, true, &m_screen))
        return WINDOW_INFO_ERROR;

    COORD screen_coord = { (short)m_width, (short)m_height };

    if (!SetConsoleScreenBufferSize(m_handle, screen_coord))
        return SCREEN_BUFFER_SIZE_ERROR;


    CONSOLE_FONT_INFOEX cinfo;
    cinfo.cbSize = sizeof(cinfo);
    cinfo.dwFontSize.X = (short)char_w;
    cinfo.dwFontSize.Y = (short)char_h;
    cinfo.FontFamily = FF_DONTCARE;
    cinfo.FontWeight = FW_NORMAL;
    cinfo.nFont = 0;

    wcscpy_s(cinfo.FaceName, L"Consolas");

    if (!SetCurrentConsoleFontEx(m_handle, false, &cinfo))
        return CONSOLE_FONT_ERROR;

    CONSOLE_SCREEN_BUFFER_INFO cbuffinfo;

    if (!GetConsoleScreenBufferInfo(m_handle, &cbuffinfo))
        return GET_BUFFER_INFO_ERROR;

    if (cbuffinfo.dwMaximumWindowSize.X < m_width)
        return HORIZONTAL_SIZE_TOO_LARGE_ERROR;

    if (cbuffinfo.dwMaximumWindowSize.Y < m_height)
        return VERTICAL_SIZE_TOO_LARGE_ERROR;

    m_screen = { 0, 0, (short)m_width - 1, (short)m_height - 1 };

    if (!SetConsoleWindowInfo(m_handle, true, &m_screen))
        return WINDOW_INFO_ERROR;

    if (!SetConsoleCtrlHandler((PHANDLER_ROUTINE)HandleClose, true))
        return CLOSE_HANDLER_ERROR;

    return OK;
}

void Console::Start()
{
    active = true;

    std::thread t(&Console::DoLoop, this);

    t.join();
}

void Console::DoLoop()
{
    if (!OnCreate())
        active = false;

    std::chrono::high_resolution_clock::time_point t1, t2;

    t1 = std::chrono::high_resolution_clock::now();
    t2 = t1;

    while (active)
    {
        t2 = std::chrono::high_resolution_clock::now();
        std::chrono::duration<float> diff = t2 - t1;
        t1 = t2;

        float dt = diff.count();

        if (!OnUpdate(dt))
            active = false;

        wchar_t title_buff[256];
        swprintf_s(title_buff, L"Console Application - %s - FPS: %3.2f", m_title.c_str(), 1.0f / dt);
        SetConsoleTitle(title_buff);
        WriteConsoleOutput(m_handle, m_buffer, { (short)m_width, (short)m_height }, { 0, 0 }, &m_screen);
    }

    finished.notify_one();
}

void Console::Fill(int x, int y, short glyph, short color)
{
    if (x < 0 || y < 0 || x >= m_width || y >= m_height) return;

    CHAR_INFO& ci = m_buffer[y * m_width + x];
    ci.Char.UnicodeChar = glyph;
    ci.Attributes = color;
}

void Console::Fill(int x1, int y1, int x2, int y2, short glyph, short color)
{
    if (x1 < 0) x1 = 0;
    if (y1 < 0) y1 = 0;

    if (x1 >= m_width) return;
    if (y1 >= m_height) return;

    if (x2 >= m_width) x2 = m_width - 1;
    if (y2 >= m_height) y2 = m_height - 1;

    if (x2 < 0) return;
    if (y2 < 0) return;

    for (int x = x1; x <= x2; x++)
    {
        for (int y = y1; y <= y2; y++)
        {
            CHAR_INFO& ci = m_buffer[y * m_width + x];
            ci.Char.UnicodeChar = glyph;
            ci.Attributes = color;
        }
    }
}

void Console::Clear(short glyph, short color)
{
    for (int x = 0; x < m_width; x++)
    {
        for (int y = 0; y < m_height; y++)
        {
            CHAR_INFO& ci = m_buffer[y * m_width + x];
            ci.Char.UnicodeChar = glyph;
            ci.Attributes = color;
        }
    }
}

void Console::Line(int x1, int y1, int x2, int y2, short glyph, short color)
{
    int dx = x2 - x1;
    int dy = y2 - y1;

    int adx = dx > 0 ? dx : -dx;
    int ady = dy > 0 ? dy : -dy;

    int dy2 = dy + dy;
    int dx2 = dx + dx;

    int adx2 = dx2 > 0 ? dx2 : -dx2;
    int ady2 = dy2 > 0 ? dy2 : -dy2;

    if (adx > ady)
    {
        if (x1 > x2)
        {
            int x = x1;
            x1 = x2;
            x2 = x;
            dx = -dx;
            dx2 = -dx2;

            int y = y1;
            y1 = y2;
            y2 = y;
            dy = -dy;
            dy2 = -dy2;
        }

        int sy = dy > 0 ? 1 : dy < 0 ? -1 : 0;

        int err = ady;

        for (int x = x1, y = y1; x <= x2; x++)
        {
            Fill(x, y, glyph, color);

            err += ady2;

            if (err > adx2)
            {
                err -= adx2;
                y += sy;
            }
        }
    }
    else
    {
        if (y1 > y2)
        {
            int x = x1;
            x1 = x2;
            x2 = x;
            dx = -dx;
            dx2 = -dx2;

            int y = y1;
            y1 = y2;
            y2 = y;
            dy = -dy;
            dy2 = -dy2;
        }

        int sx = dx > 0 ? 1 : dx < 0 ? -1 : 0;

        int err = adx;

        for (int x = x1, y = y1; y <= y2; y++)
        {
            Fill(x, y, glyph, color);

            err += adx2;

            if (err > ady2)
            {
                err -= ady2;
                x += sx;
            }
        }
    }
}

void Console::Triangle(int x1, int y1, int x2, int y2, int x3, int y3, short glyph, short color)
{
    Line(x1, y1, x2, y2, glyph, color);
    Line(x2, y2, x3, y3, glyph, color);
    Line(x3, y3, x1, y1, glyph, color);
}

BOOL Console::HandleClose(DWORD evt)
{
    if (evt == CTRL_CLOSE_EVENT)
    {
        active = false;

        std::unique_lock<std::mutex> ul(lock);
        finished.wait(ul);
    }

    return true;
}

Here is the very short main code:

class Game : public Console
{
public:
    Game(int width, int height):
        Console(width, height)
    {

    }

    bool OnCreate() override
    {
        return true;
    }

    bool OnUpdate(float dt) override
    {
        Clear(GLYPH_SOLID, FG_BLACK);

        //Triangle(20, 20, 300, 40, 150, 200);

        return true;
    }
};

int main()
{
    Game game(400, 300);
    int err = game.Construct(2, 2);

    if (err == Console::OK)
        game.Start();
}

The error constants are just defined integer codes in the header file. If any additional code is needed please let me know. Thanks in advance!

EDIT: