OSDev.org

• Never read from display memory. Reading from display memory is extremely slow. Doing it in a "memcpy()" is worse because the memory itself is being "triple banged" (you're trying to read from it while you're trying to write to it while the video card is reading it to send pixels to the monitor), and the PCI bus (and its limited bandwidth) is being "double banged".
• Never write individual bytes in display memory. For every write across a bus (like PCI) it's a little bit like a network packet (e.g. maybe consisting of a type, address, payload length, the data itself, then probably a checksum of some sort to detect bus errors). For that single byte of actual data you could be sending 16+ bytes. Instead you want to write larger amounts at once (e.g. 32-bit or larger).
• Never use a "putpixel()" function. Not only is it bad because you only write one pixel at a time; it's bad because you have to calculate the address of every single pixel (your "where = video.screen + x*bar + y*video.Xres*bar" calculation, which is wrong anyway but that's a different problem). It's far better/faster to calculate "where" once (for the top/left pixel) and then do "where += bytes_per_pixel;" to find the next pixel to the right, or "where += bytes_per_line;" to find the next pixel down, and avoid a huge number of multiplications.
• Avoid unnecessary writes. If you look at most "screens of text" you'll notice that about half of it is white space, there's a gap between lines, etc. There's even cases where (e.g.) a 'B' on one line is replaced by 'P' on the next line and only a small part (the bottom right part of the character) actually changes. When the screen scrolls, I'd guess that typically about 80% of pixels aren't changed at all, and by not writing those pixels you'd get a significant performance improvement.

Brendan wrote:

• Never read from display memory. Reading from display memory is extremely slow. Doing it in a "memcpy()" is worse because the memory itself is being "triple banged" (you're trying to read from it while you're trying to write to it while the video card is reading it to send pixels to the monitor), and the PCI bus (and its limited bandwidth) is being "double banged".

626788149 wrote:But if I don't reading from display memory, how could I achieve scroll screen?

Brendan wrote:you want to write larger amounts at once (e.g. 32-bit or larger).

626788149 wrote:

Brendan wrote:

• Never read from display memory. Reading from display memory is extremely slow. Doing it in a "memcpy()" is worse because the memory itself is being "triple banged" (you're trying to read from it while you're trying to write to it while the video card is reading it to send pixels to the monitor), and the PCI bus (and its limited bandwidth) is being "double banged".

Thanks a lot.
But if I don't reading from display memory, how could I achieve scroll screen?

• The number of lines to scroll is zero. In this case you can just add appended characters using the "last line previously displayed" pointer.
• The number of lines to scroll is greater than zero but less than the number of character rows on the screen. In this case you can do a single "memcpy();" then add appended characters using the "last line previously displayed" pointer (e.g. with 96 character rows, if 36 new lines were added you'd shift the bottom 60 character rows to the top of the screen then add the last/new 36 lines).
• The number of lines to scroll is greater than the number of character rows on the screen. In this case everything that was on the screen will scroll off the top, so you can wipe the "X * Y grid of characters" and add appended characters starting from the "pointer to new first line to display" you already have.

    for(x = 0; x < bytes_per_line/4; x++) {
        if(buffer1[src] != buffer2[src]) {
            // This dword is different to what's in display memory
            buffer2[src] = buffer1[src];
            displayMemory[dest] = buffer1[src];
        }
        src += 4;
        dest += 4;
    }

Antti wrote:

Brendan wrote:you want to write larger amounts at once (e.g. 32-bit or larger).

On some rare cases, writing larger units may cause problems. This is quite irrelevant but may be worth taking into account if you want to be as defensive as possible.

Brendan wrote:You wouldn't want to cripple performance on all video cards just because one rare video card is a buggy piece of crud.

Brendan wrote:Hi,

626788149 wrote:

Brendan wrote:

• Never read from display memory. Reading from display memory is extremely slow. Doing it in a "memcpy()" is worse because the memory itself is being "triple banged" (you're trying to read from it while you're trying to write to it while the video card is reading it to send pixels to the monitor), and the PCI bus (and its limited bandwidth) is being "double banged".

Thanks a lot.
But if I don't reading from display memory, how could I achieve scroll screen?

You'd have some sort of buffer in RAM; which might be raw pixel data, or might be "grid of characters", or might be a big string. It can even be multiple "things" (rather than just one buffer).

For an example, I'll describe what I'd probably do (and what I've done before).
.....
.....
.....
This extra buffer means more reads (from RAM) and more writes (to RAM), but a lot less writes to display memory; and because RAM is a lot faster than display memory it ends up being faster despite the extra reads/writes.

Of course if that "one bit per character row" says the row wasn't modified I'd skip the row during blitting too.


Cheers,

Brendan

alexfru wrote:

626788149 wrote:But if I don't reading from display memory, how could I achieve scroll screen?

Buffer?