system/freebsd-src
system/freebsd-src
1
0
Fork 0
mirror of https://github.com/freebsd/freebsd-src synced 2024-07-08 20:26:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use a shadow buffer and never read from the frame buffer. Remove large slow

Browse Source 
code for reading from the frame buffer.

Reading from the frame buffer is usually much slower than writing to
the frame buffer.  Typically 10 to 100 times slower.  It old modes,
it takes many more PIOs, and in newer modes with no PIOs writes are
often write-combined while reads remain uncached.

Reading from the frame buffer is not very common, so this change doesn't
give speedups of 10 to 100 times.  My main test case is a floodfill()
function that reads about as many pixels as it writes.  The speedups
are typically a factor of 2 to 4.

Duplicating writes to the shadow buffer is slower when no reads from the
frame buffer are done, but reads are often done for the pixels under the
mouse cursor, and doing these reads from the shadow buffer more than
compensates for the overhead of writing the shadow buffer in at least the
slower modes.  Management of the mouse cursor also becomes simpler.

The shadow buffer doesn't take any extra memory, except twice as much
in old 4-plane modes.  A buffer for holding a copy of the frame buffer
was allocated up front for use in the screen switching signal handler.
This wasn't changed when the handler was made async-signal safe.  Use
the same buffer the shadow (but make it twice as large in the 4-plane
modes), and remove large special code for writing it as well as large
special code for reading ut.  It used to have a rawer format in the
4-plane modes.  Now it has a bitmap format which takes twice as much
memory but can be written almost as fast without special code.

VIDBUFs that are not the whole frame buffer were never supported, and the
change depends on this.  Check for invalid VIDBUFs in some places and do
nothing.  The removed code did something not so good.
This commit is contained in:
Bruce Evans 2019-04-21 16:17:35 +00:00
parent e848f3d19c
commit 1fa5142093
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=346488
5 changed files with 57 additions and 314 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

151
lib/libvgl/bitmap.c
View File

@ -163,108 +163,6 @@ WriteVerticalLine(VGLBitmap *dst, int x, int y, int width, byte *line)
}
}
static void
ReadVerticalLine(VGLBitmap *src, int x, int y, int width, byte *line)
{
int i, bit, pos, count, planepos, start_offset, end_offset, offset;
int width2, len;
byte *address;
byte *VGLPlane[4];
switch (src->Type) {
case VIDBUF4S:
start_offset = (x & 0x07);
end_offset = (x + width) & 0x07;
count = (width + start_offset) / 8;
if (end_offset)
count++;
VGLPlane[0] = VGLBuf;
VGLPlane[1] = VGLPlane[0] + count;
VGLPlane[2] = VGLPlane[1] + count;
VGLPlane[3] = VGLPlane[2] + count;
for (i=0; i<4; i++) {
outb(0x3ce, 0x04);
outb(0x3cf, i);
pos = VGLAdpInfo.va_line_width*y + x/8;
for (width2 = count; width2 > 0; ) {
offset = VGLSetSegment(pos);
len = min(VGLAdpInfo.va_window_size - offset, width2);
bcopy(src->Bitmap + offset, &VGLPlane[i][count - width2], len);
pos += len;
width2 -= len;
}
}
goto read_planar;
case VIDBUF4:
address = src->Bitmap + VGLAdpInfo.va_line_width * y + x/8;
start_offset = (x & 0x07);
end_offset = (x + width) & 0x07;
count = (width + start_offset) / 8;
if (end_offset)
count++;
VGLPlane[0] = VGLBuf;
VGLPlane[1] = VGLPlane[0] + count;
VGLPlane[2] = VGLPlane[1] + count;
VGLPlane[3] = VGLPlane[2] + count;
for (i=0; i<4; i++) {
outb(0x3ce, 0x04);
outb(0x3cf, i);
bcopy(address, &VGLPlane[i][0], count);
}
read_planar:
pos = 0;
planepos = 0;
bit = 7 - start_offset;
while (pos < width) {
for (; bit >= 0 && pos < width; bit--, pos++) {
line[pos] = (VGLPlane[0][planepos] & (1<<bit) ? 1 : 0) |
((VGLPlane[1][planepos] & (1<<bit) ? 1 : 0) << 1) |
((VGLPlane[2][planepos] & (1<<bit) ? 1 : 0) << 2) |
((VGLPlane[3][planepos] & (1<<bit) ? 1 : 0) << 3);
}
planepos++;
bit = 7;
}
break;
case VIDBUF8X:
address = src->Bitmap + VGLAdpInfo.va_line_width * y + x/4;
for (i=0; i<4; i++) {
outb(0x3ce, 0x04);
outb(0x3cf, (x + i)%4);
for (planepos=0, pos=i; pos<width; planepos++, pos+=4)
line[pos] = address[planepos];
if ((x + i)%4 == 3)
++address;
}
break;
case VIDBUF8S:
case VIDBUF16S:
case VIDBUF24S:
case VIDBUF32S:
width = width * src->PixelBytes;
pos = (src->VXsize * y + x) * src->PixelBytes;
while (width > 0) {
offset = VGLSetSegment(pos);
i = min(VGLAdpInfo.va_window_size - offset, width);
bcopy(src->Bitmap + offset, line, i);
line += i;
pos += i;
width -= i;
}
break;
case MEMBUF:
case VIDBUF8:
case VIDBUF16:
case VIDBUF24:
case VIDBUF32:
address = src->Bitmap + (src->VXsize * y + x) * src->PixelBytes;
bcopy(address, line, width * src->PixelBytes);
break;
default:
;
}
}
int
__VGLBitmapCopy(VGLBitmap *src, int srcx, int srcy,
VGLBitmap *dst, int dstx, int dsty, int width, int hight)
@ -304,37 +202,10 @@ __VGLBitmapCopy(VGLBitmap *src, int srcx, int srcy,
yextra = hight - 1;
ystep = -1;
}
if (src->Type == MEMBUF) {
for (srcline = srcy + yextra, dstline = dsty + yextra; srcline != yend;
srcline += ystep, dstline += ystep) {
WriteVerticalLine(dst, dstx, dstline, width,
src->Bitmap+(srcline*src->VXsize+srcx)*dst->PixelBytes);
}
}
else if (dst->Type == MEMBUF) {
for (srcline=srcy, dstline=dsty; srcline<srcy+hight; srcline++, dstline++) {
ReadVerticalLine(src, srcx, srcline, width,
dst->Bitmap+(dstline*dst->VXsize+dstx)*src->PixelBytes);
}
}
else {
byte buffer[2048]; /* XXX */
byte *p;
if (width * src->PixelBytes > sizeof(buffer)) {
p = malloc(width * src->PixelBytes);
if (p == NULL)
return 1;
} else {
p = buffer;
}
for (srcline = srcy + yextra, dstline = dsty + yextra; srcline != yend;
srcline += ystep, dstline += ystep) {
ReadVerticalLine(src, srcx, srcline, width, p);
WriteVerticalLine(dst, dstx, dstline, width, p);
}
if (width * src->PixelBytes > sizeof(buffer))
free(p);
for (srcline = srcy + yextra, dstline = dsty + yextra; srcline != yend;
srcline += ystep, dstline += ystep) {
WriteVerticalLine(dst, dstx, dstline, width,
src->Bitmap+(srcline*src->VXsize+srcx)*dst->PixelBytes);
}
return 0;
}
@ -345,12 +216,20 @@ VGLBitmapCopy(VGLBitmap *src, int srcx, int srcy,
{
int error;
if (src == VGLDisplay)
src = &VGLVDisplay;
if (src->Type != MEMBUF)
VGLMouseFreeze(srcx, srcy, width, hight, 0);
if (dst->Type != MEMBUF)
return -1; /* invalid */
if (dst == VGLDisplay) {
VGLMouseFreeze(dstx, dsty, width, hight, 0);
__VGLBitmapCopy(src, srcx, srcy, &VGLVDisplay, dstx, dsty, width, hight);
src = &VGLVDisplay;
srcx = dstx;
srcy = dsty;
} else if (dst->Type != MEMBUF)
return -1; /* invalid */
error = __VGLBitmapCopy(src, srcx, srcy, dst, dstx, dsty, width, hight);
if (src->Type != MEMBUF || dst->Type != MEMBUF)
if (dst == VGLDisplay)
VGLMouseUnFreeze();
return error;
}

102
lib/libvgl/main.c
View File

@ -48,6 +48,7 @@ __FBSDID("$FreeBSD$");
#define max(x, y) (((x) > (y)) ? (x) : (y))
VGLBitmap *VGLDisplay;
VGLBitmap VGLVDisplay;
video_info_t VGLModeInfo;
video_adapter_info_t VGLAdpInfo;
byte *VGLBuf;
@ -334,6 +335,13 @@ VGLInit(int mode)
}
VGLDisplay->Bitmap = VGLMem;
VGLVDisplay = *VGLDisplay;
VGLVDisplay.Type = MEMBUF;
if (VGLModeInfo.vi_depth < 8)
VGLVDisplay.Bitmap = malloc(2 * VGLBufSize);
else
VGLVDisplay.Bitmap = VGLBuf;
VGLSavePalette();
#ifdef LIBVGL_DEBUG
@ -365,10 +373,6 @@ VGLCheckSwitch()
exit(0);
}
while (VGLSwitchPending) {
unsigned int offset;
unsigned int len;
int i;
VGLSwitchPending = 0;
if (VGLOnDisplay) {
if (VGLModeInfo.vi_mem_model != V_INFO_MM_DIRECT)
@ -440,98 +444,12 @@ VGLCheckSwitch()
VGLRestoreBorder();
VGLMouseRestore();
VGLPanScreen(VGLDisplay, VGLDisplay->Xorigin, VGLDisplay->Yorigin);
switch (VGLDisplay->Type) {
case VIDBUF4S:
outb(0x3c6, 0xff);
outb(0x3ce, 0x01); outb(0x3cf, 0x00); /* set/reset enable */
outb(0x3ce, 0x08); outb(0x3cf, 0xff); /* bit mask */
for (offset = 0; offset < VGLBufSize/VGLModeInfo.vi_planes;
offset += len) {
VGLSetSegment(offset);
len = min(VGLBufSize/VGLModeInfo.vi_planes - offset,
VGLAdpInfo.va_window_size);
for (i = 0; i < VGLModeInfo.vi_planes; i++) {
outb(0x3c4, 0x02);
outb(0x3c5, 0x01<<i);
bcopy(&VGLBuf[i*VGLBufSize/VGLModeInfo.vi_planes + offset],
VGLMem, len);
}
}
break;
case VIDBUF4:
case VIDBUF8X:
outb(0x3c6, 0xff);
outb(0x3ce, 0x01); outb(0x3cf, 0x00); /* set/reset enable */
outb(0x3ce, 0x08); outb(0x3cf, 0xff); /* bit mask */
for (i = 0; i < VGLModeInfo.vi_planes; i++) {
outb(0x3c4, 0x02);
outb(0x3c5, 0x01<<i);
bcopy(&VGLBuf[i*VGLAdpInfo.va_window_size], VGLMem,
VGLAdpInfo.va_window_size);
}
break;
case VIDBUF8:
case VIDBUF8S:
case VIDBUF16:
case VIDBUF16S:
case VIDBUF24:
case VIDBUF24S:
case VIDBUF32:
case VIDBUF32S:
for (offset = 0; offset < VGLBufSize; offset += len) {
VGLSetSegment(offset);
len = min(VGLBufSize - offset, VGLAdpInfo.va_window_size);
bcopy(&VGLBuf[offset], VGLMem, len);
}
break;
}
VGLBitmapCopy(&VGLVDisplay, 0, 0, VGLDisplay, 0, 0,
VGLDisplay->VXsize, VGLDisplay->VYsize);
VGLRestorePalette();
ioctl(0, VT_RELDISP, VT_ACKACQ);
}
else {
switch (VGLDisplay->Type) {
case VIDBUF4S:
for (offset = 0; offset < VGLBufSize/VGLModeInfo.vi_planes;
offset += len) {
VGLSetSegment(offset);
len = min(VGLBufSize/VGLModeInfo.vi_planes - offset,
VGLAdpInfo.va_window_size);
for (i = 0; i < VGLModeInfo.vi_planes; i++) {
outb(0x3ce, 0x04);
outb(0x3cf, i);
bcopy(VGLMem, &VGLBuf[i*VGLBufSize/VGLModeInfo.vi_planes + offset],
len);
}
}
break;
case VIDBUF4:
case VIDBUF8X:
/*
* NOTE: the saved buffer is NOT in the MEMBUF format which
* the ordinary memory bitmap object is stored in. XXX
*/
for (i = 0; i < VGLModeInfo.vi_planes; i++) {
outb(0x3ce, 0x04);
outb(0x3cf, i);
bcopy(VGLMem, &VGLBuf[i*VGLAdpInfo.va_window_size],
VGLAdpInfo.va_window_size);
}
break;
case VIDBUF8:
case VIDBUF8S:
case VIDBUF16:
case VIDBUF16S:
case VIDBUF24:
case VIDBUF24S:
case VIDBUF32:
case VIDBUF32S:
for (offset = 0; offset < VGLBufSize; offset += len) {
VGLSetSegment(offset);
len = min(VGLBufSize - offset, VGLAdpInfo.va_window_size);
bcopy(VGLMem, &VGLBuf[offset], len);
}
break;
}
VGLMem = MAP_FAILED;
munmap(VGLDisplay->Bitmap, VGLAdpInfo.va_window_size);
ioctl(0, VGLOldMode, 0);

31
lib/libvgl/mouse.c
View File

@ -82,9 +82,6 @@ static VGLBitmap VGLMouseStdAndMask =
static VGLBitmap VGLMouseStdOrMask =
VGLBITMAP_INITIALIZER(MEMBUF, MOUSE_IMG_SIZE, MOUSE_IMG_SIZE, StdOrMask);
static VGLBitmap *VGLMouseAndMask, *VGLMouseOrMask;
static byte map[MOUSE_IMG_SIZE*MOUSE_IMG_SIZE*4];
static VGLBitmap VGLMouseSave =
VGLBITMAP_INITIALIZER(MEMBUF, MOUSE_IMG_SIZE, MOUSE_IMG_SIZE, map);
static int VGLMouseVisible = 0;
static int VGLMouseShown = 0;
static int VGLMouseXpos = 0;
@ -117,10 +114,9 @@ VGLMousePointerShow()
gdcidx = inb(0x3ce);
gdcval = inb(0x3cf);
}
__VGLBitmapCopy(VGLDisplay, VGLMouseXpos, VGLMouseYpos,
&VGLMouseSave, 0, 0, MOUSE_IMG_SIZE, MOUSE_IMG_SIZE);
bcopy(VGLMouseSave.Bitmap, buffer.Bitmap,
MOUSE_IMG_SIZE*MOUSE_IMG_SIZE*VGLDisplay->PixelBytes);
buffer.PixelBytes = VGLDisplay->PixelBytes;
__VGLBitmapCopy(&VGLVDisplay, VGLMouseXpos, VGLMouseYpos,
&buffer, 0, 0, MOUSE_IMG_SIZE, MOUSE_IMG_SIZE);
for (pos = 0; pos < MOUSE_IMG_SIZE*MOUSE_IMG_SIZE; pos++)
for (i = 0; i < VGLDisplay->PixelBytes; i++) {
pos1 = pos * VGLDisplay->PixelBytes + i;
@ -154,8 +150,8 @@ VGLMousePointerHide()
gdcidx = inb(0x3ce);
gdcval = inb(0x3cf);
}
__VGLBitmapCopy(&VGLMouseSave, 0, 0, VGLDisplay,
VGLMouseXpos, VGLMouseYpos, MOUSE_IMG_SIZE, MOUSE_IMG_SIZE);
__VGLBitmapCopy(&VGLVDisplay, VGLMouseXpos, VGLMouseYpos, VGLDisplay,
VGLMouseXpos, VGLMouseYpos, MOUSE_IMG_SIZE, MOUSE_IMG_SIZE);
if (VGLModeInfo.vi_mem_model != V_INFO_MM_DIRECT) {
outb(0x3c4, crtcidx);
outb(0x3c5, crtcval);
@ -302,8 +298,6 @@ VGLMouseStatus(int *x, int *y, char *buttons)
int
VGLMouseFreeze(int x, int y, int width, int hight, u_long color)
{
int i, xstride, ystride;
INTOFF();
if (width > 1 || hight > 1 || (color & 0xc0000000) == 0) { /* bitmap */
if (VGLMouseShown == 1) {
@ -327,20 +321,7 @@ VGLMouseFreeze(int x, int y, int width, int hight, u_long color)
if (VGLMouseShown &&
x >= VGLMouseXpos && x < VGLMouseXpos + MOUSE_IMG_SIZE &&
y >= VGLMouseYpos && y < VGLMouseYpos + MOUSE_IMG_SIZE) {
xstride = VGLDisplay->PixelBytes;
ystride = MOUSE_IMG_SIZE * xstride;
if (color & 0x40000000) { /* Get */
color = 0;
for (i = xstride - 1; i >= 0; i--)
color = (color << 8) |
VGLMouseSave.Bitmap[(y-VGLMouseYpos)*ystride+
(x-VGLMouseXpos)*xstride+i];
return 0x40000000 | (color & 0xffffff);
} else { /* Set */
color &= 0xffffff; /* discard flag and other garbage */
for (i = 0; i < xstride; i++, color >>= 8)
VGLMouseSave.Bitmap[(y-VGLMouseYpos)*ystride+
(x-VGLMouseXpos)*xstride+i] = color;
if (color & 0x80000000) { /* Set */
if (VGLMouseAndMask->Bitmap
[(y-VGLMouseYpos)*MOUSE_IMG_SIZE+(x-VGLMouseXpos)]) {
return 1;

86
lib/libvgl/simple.c
View File

@ -55,6 +55,8 @@ VGLSetXY(VGLBitmap *object, int x, int y, u_long color)
VGLCheckSwitch();
if (x>=0 && x<object->VXsize && y>=0 && y<object->VYsize) {
if (object == VGLDisplay)
VGLSetXY(&VGLVDisplay, x, y, color);
if (object->Type == MEMBUF ||
!VGLMouseFreeze(x, y, 1, 1, 0x80000000 | color)) {
offset = (y * object->VXsize + x) * object->PixelBytes;
@ -113,78 +115,37 @@ static u_long
__VGLGetXY(VGLBitmap *object, int x, int y)
{
int offset;
int i;
u_long color;
byte mask;
offset = (y * object->VXsize + x) * object->PixelBytes;
switch (object->Type) {
case VIDBUF8S:
case VIDBUF16S:
case VIDBUF24S:
case VIDBUF32S:
offset = VGLSetSegment(offset);
/* FALLTHROUGH */
case MEMBUF:
case VIDBUF8:
case VIDBUF16:
case VIDBUF24:
case VIDBUF32:
switch (object->PixelBytes) {
case 1:
memcpy(&color, &object->Bitmap[offset], 1);
return le32toh(color) & 0xff;
case 2:
memcpy(&color, &object->Bitmap[offset], 2);
return le32toh(color) & 0xffff;
case 3:
memcpy(&color, &object->Bitmap[offset], 3);
return le32toh(color) & 0xffffff;
case 4:
memcpy(&color, &object->Bitmap[offset], 4);
return le32toh(color);
}
break;
case VIDBUF8X:
outb(0x3ce, 0x04); outb(0x3cf, x & 0x3);
return object->Bitmap[(unsigned)(VGLAdpInfo.va_line_width*y)+(x/4)];
case VIDBUF4S:
offset = VGLSetSegment(y*VGLAdpInfo.va_line_width + x/8);
goto get_planar;
case VIDBUF4:
offset = y*VGLAdpInfo.va_line_width + x/8;
get_planar:
color = 0;
mask = 0x80 >> (x%8);
for (i = 0; i < VGLModeInfo.vi_planes; i++) {
outb(0x3ce, 0x04); outb(0x3cf, i);
color |= (((volatile VGLBitmap *)object)->Bitmap[offset] & mask) ?
(1 << i) : 0;
}
return color;
switch (object->PixelBytes) {
case 1:
memcpy(&color, &object->Bitmap[offset], 1);
return le32toh(color) & 0xff;
case 2:
memcpy(&color, &object->Bitmap[offset], 2);
return le32toh(color) & 0xffff;
case 3:
memcpy(&color, &object->Bitmap[offset], 3);
return le32toh(color) & 0xffffff;
case 4:
memcpy(&color, &object->Bitmap[offset], 4);
return le32toh(color);
}
return 0; /* XXX black? */
return 0; /* invalid */
}
u_long
VGLGetXY(VGLBitmap *object, int x, int y)
{
u_long color;
VGLCheckSwitch();
if (x<0 || x>=object->VXsize || y<0 || y>=object->VYsize)
return 0;
if (object->Type != MEMBUF) {
color = VGLMouseFreeze(x, y, 1, 1, 0x40000000);
if (color & 0x40000000) {
VGLMouseUnFreeze();
return color & 0xffffff;
}
}
color = __VGLGetXY(object, x, y);
if (object == VGLDisplay)
object = &VGLVDisplay;
if (object->Type != MEMBUF)
VGLMouseUnFreeze();
return color;
return 0; /* invalid */
return __VGLGetXY(object, x, y);
}
/*
@ -493,8 +454,11 @@ VGLClear(VGLBitmap *object, u_long color)
int i;
VGLCheckSwitch();
if (object->Type != MEMBUF)
if (object == VGLDisplay) {
VGLMouseFreeze(0, 0, object->Xsize, object->Ysize, color);
VGLClear(&VGLVDisplay, color);
} else if (object->Type != MEMBUF)
return; /* invalid */
switch (object->Type) {
case MEMBUF:
case VIDBUF8:
@ -545,7 +509,7 @@ VGLClear(VGLBitmap *object, u_long color)
outb(0x3ce, 0x05); outb(0x3cf, 0x00);
break;
}
if (object->Type != MEMBUF)
if (object == VGLDisplay)
VGLMouseUnFreeze();
}

1
lib/libvgl/vgl.h
View File

@ -100,6 +100,7 @@ typedef struct VGLObject {
extern video_adapter_info_t VGLAdpInfo;
extern video_info_t VGLModeInfo;
extern VGLBitmap *VGLDisplay;
extern VGLBitmap VGLVDisplay;
extern byte *VGLBuf;
/*