Day26

Author Avatar
CCDV2 4月 27, 2019

今天用了位算法来优化窗口的移动速度，之后提供了命令行的开启与关闭操作。

一些感想

提高窗口移动速度

又来到了优化图像处理算法的环节。这次是优化鼠标移动窗口时的算法。

  1. 减少if的判断次数
    像是这种代码：
    for()
 for()
     if()
    不难想象if在中间被判断了很多次。如果要是在外面判断完之后再进去循环，那样就会减少很多判断次数了。
  2. 位操作的优化。
    之前我们都是按BYTE来赋值的，如果采用DWORD来赋值，同样的时间会将效率提高4倍，这样的话效率就很高了。
  3. 与鼠标绘图同步
    虽然现在窗口移动已经够快了，但是还是赶不上鼠标的速度。由于考虑到鼠标移动操作很可能是连续的，因此我们没必要对于每次微小的移动都重绘鼠标与窗口，可以等缓冲区为空的时候再重绘它们。

命令行的开启和关闭

以前一直不明白，为什么有bootpack.c了，还会有console.c，这两个不应该是一个东西吗？
现在大概明白了：作者做了一个全局的后台处理任务，负责分发各种FIFO、调用控制台之类的。这个任务对于操作系统使用者来说是透明的，但是在操作系统编程者的视角上来说可以说它无处不在了。

提高窗口移动速度（1）

harib23a

改进refreshmap函数。首先是减少if的判断次数

if(sht->col_inv == -1)
{
    // 无透明色图层的专用告诉版
    for(by = by0; by < by1; ++by)
    {
        vy = sht->vy0 + by;
        for(bx = bx0; bx < bx1; ++bx)
        {
            vx = sht->vx0 + bx;
            map[vy * ctl->xsize + vx] = sid;
        }
    }
}
else
{
    // 有透明色图层用的普通版
    for(by = by0; by < by1; ++by)
    {
        vy = sht->vy0 + by;
        for(bx = bx0; bx < bx1; ++bx)
        {
            vx = sht->vx0 + bx;
            if(buf[by * sht->bxsize + bx] != sht->col_inv)
            {
                map[vy * ctl->xsize + vx] = sid;
            }
        }
    }
}

相当于在能省的情况下，省一些判断时间。虽然不知道有多少提升效果。

提高窗口移动速度（2）

harib23b

改成每4字节赋一次值：

if(sht->col_inv == -1)
{
    if((sht->vx0 & 3) == 0 && (bx0 & 3) == 0 && (bx1 & 3) == 0)
    {
        // 无透明色图层专用的高字节版（4字节型）
        bx1 = (bx1 - bx0) / 4; // MOV次数
        sid4 = sid | sid << 8 | sid << 16 | sid << 24;
        for(by = by0; by < by1; ++by)
        {
            vy = sht->vy0 + by;
            vx = sht->vx0 + bx0;
            p = (int *)&map[vy * ctl->xsize + vx];
            for(bx = 0; bx < bx1; ++bx)
            {
                p[bx] = sid4;
            }
        }
    }
    else
    {
        // 无透明色图层专用的高速版（1字节型）
        for(by = by0; by < by1; ++by)
        {
            vy = sht->vy0 + by;
            for(bx = bx0; bx < bx1; ++bx)
            {
                vx = sht->vx0 + bx;
                map[vy * ctl->xsize + vx] = sid;
            }
        }
    }
}
else
{
    // 有透明色图层用的普通版
    for(by = by0; by < by1; ++by)
    {
        vy = sht->vy0 + by;
        for(bx = bx0; bx < bx1; ++bx)
        {
            vx = sht->vx0 + bx;
            if(buf[by * sht->bxsize + bx] != sht->col_inv)
            {
                map[vy * ctl->xsize + vx] = sid;
            }
        }
    }
}

这样提升的性能是很显著的。同时为了尽可能多地使用4字节一起赋值，在API申请的时候将窗口大小强制规定为4的倍数

case 5:
    sht = sheet_alloc(shtctl);
    sht->task = task;
    sht->flags |= 0x10;
    sheet_setbuf(sht, (char *) ebx + ds_base, esi, edi, eax);
    make_window8((char *) ebx + ds_base, esi, edi, (char *) ecx + ds_base, 0);
    sheet_slide(sht, ((shtctl->xsize - esi) / 2) & ~3, (shtctl->ysize - edi) / 2);
    sheet_updown(sht, shtctl->top);    // 将窗口图层高度指定为当前鼠标所在图层的高度，鼠标移到最上层
    reg[7] = (int)sht;
    break;

向下取整
鼠标移动窗口时，四舍五入到4的倍数：

sheet_slide(sht, (mmx2 + x + 2) & ~3, sht->vy0 + y);

这样移动窗口速度就得到了显著的提升。

提高窗口移动速度（3）

harib23c

这一节顺便修改了其它绘制函数，使其支持4字节写入
于是修改refreshsub：

if((sht->vx0 & 3) == 0)
{
    // 4字节型
    i  = (bx0 + 3) / 4; // bx0除以4（小数进位）
    i1 =  bx1 / 4; // bx1除以4（小数舍去）
    i1 = i1 - i;
    sid4 = sid | sid << 8 | sid << 16 | sid << 24;
    for(by = by0; by < by1; ++by)
    {
        vy = sht->vy0 + by;
        for(bx = bx0; bx < bx1 && (bx & 3) != 0; ++bx) // 前面被4除多余的部分逐个字节写入
        {
            vx = sht->vx0 + bx;
            if(map[vy * ctl->xsize + vx] == sid)
            {
                vram[vy * ctl->xsize + vx] = buf[by * sht->bxsize + bx];
            }
        }
        vx = sht->vx0 + bx;
        p = (int *)&map[vy * ctl->xsize + vx];
        q = (int *)&vram[vy * ctl->xsize + vx];
        r = (int *)&buf[by * sht->bxsize + bx];
        for(i = 0; i < i1; ++i) // 4的倍数部分
        {
            if(p[i] == sid4)
            {
                q[i] = r[i]; // 估计大多数会是这种情况，因此速度会变快
            }
            else
            {
                bx2 = bx + i * 4;
                vx = sht->vx0 + bx2;
                if(map[vy * ctl->xsize + vx + 0] == sid)
                {
                    vram[vy * ctl->xsize + vx + 0] = buf[by * sht->bxsize + bx2 + 0];
                }
                if(map[vy * ctl->xsize + vx + 1] == sid)
                {
                    vram[vy * ctl->xsize + vx + 1] = buf[by * sht->bxsize + bx2 + 1];
                }
                if(map[vy * ctl->xsize + vx + 2] == sid)
                {
                    vram[vy * ctl->xsize + vx + 2] = buf[by * sht->bxsize + bx2 + 2];
                }
                if(map[vy * ctl->xsize + vx + 3] == sid)
                {
                    vram[vy * ctl->xsize + vx + 3] = buf[by * sht->bxsize + bx2 + 3];
                }
            }
        }
        for(bx += i1 * 4; bx < bx1; ++bx) // 后面被4除多余的部分逐个字节写入
        {
            vx = sht->vx0 + bx;
            if(map[vy * ctl->xsize + vx] == sid)
            {
                vram[vy * ctl->xsize + vx] = buf[by * sht->bxsize + bx];
            }
        }
    }
}
else
{
    // 1字节型
    for(by = by0; by < by1; ++by)
    {
        vy = sht->vy0 + by;
        for(bx = bx0; bx < bx1; ++bx)
        {
            vx = sht->vx0 + bx;
            if(map[vy * ctl->xsize + vx] == sid)
            {
                vram[vy * ctl->xsize + vx] = buf[by * sht->bxsize + bx];
            }
        }
    }
}

提高窗口移动速度（4）

harib23d

解决鼠标与窗口的速度不匹配问题

if(fifo32_status(&fifo) == 0)
{
    // FIFO为空，当存在搁置的绘图操作时立即执行
    if(new_mx >= 0)
    {
        io_sti();
        sheet_slide(sht_mouse, new_mx, new_my);
        new_mx = -1;
    }
    else if(new_wx != 0x7fffffff)
    {
        io_sti();
        sheet_slide(sht, new_wx, new_wy);
        new_wx = 0x7fffffff;
    }
    else
    {
        task_sleep(task_a);
        io_sti();
    }
}

new_mx为鼠标移动后，暂时存储的鼠标移动后坐标的x值。
new_wx为鼠标移动后，暂时存储的窗口移动后坐标的x值。
这样省去了过多微小的重绘操作。

启动时只打开一个命令行窗口 & 增加更多的命令行窗口

harib23e
harib23f

按下shift+F2，就会新建一个命令行窗口。
这里把命令行的初始化封装了起来：

struct SHEET *open_console(struct SHTCTL *shtctl, unsigned int memtotal)
{
    struct MEMMAN *memman = (struct MEMMAN *)MEMMAN_ADDR;
    struct SHEET *sht = sheet_alloc(shtctl);
    unsigned char *buf = (unsigned char *)memman_alloc_4k(memman, 256 * 165);
    struct TASK *task = task_alloc();
    int *cons_fifo = (int *)memman_alloc_4k(memman, 128 * 4);
    sheet_setbuf(sht, buf, 256, 165, -1); // 无透明色
    make_window8(buf, 256, 165, "console", 0);
    make_textbox8(sht, 8, 28, 240, 128, COL8_000000);
    task->tss.esp = memman_alloc_4k(memman, 64 * 1024) + 64 * 1024 - 12;
    task->tss.eip = (int)&console_task;
    task->tss.es = 1 * 8;
    task->tss.cs = 2 * 8;
    task->tss.ss = 1 * 8;
    task->tss.ds = 1 * 8;
    task->tss.fs = 1 * 8;
    task->tss.gs = 1 * 8;
    *((int *)(task->tss.esp + 4)) = (int) sht;
    *((int *)(task->tss.esp + 8)) = memtotal;
    task_run(task, 2, 2); // level=2, priority=2
    sht->task = task;
    sht->flags |= 0x20;    // 有光标
    fifo32_init(&task->fifo, 128, cons_fifo, task);
    return sht;
}

判断shift+F2：

if(i == 256 + 0x3c && key_shift != 0) // Shift+F2
{
    // 自动将输入焦点切换到新打开的命令行窗口（这样比较方便吧？）
    keywin_off(key_win);
    key_win = open_console(shtctl, memtotal);
    sheet_slide(key_win, 32, 4);
    sheet_updown(key_win, shtctl->top);
    keywin_on(key_win);
}

上面用了是f小节的逻辑，因为sht_cons已经没有用了。

关闭命令行窗口（1）

harib23g

这次是输入exit指令，就可以关闭命令行
因为命令行窗口有自己的栈，所以释放的时候也要将其释放。于是TASK结构体要多记录一个cons_stack，用于表示（如果是命令行任务的情况下）栈大小。

task->cons_stack = memman_alloc_4k(memman, 64 * 1024);
task->tss.esp = task->cons_stack + 64 * 1024 - 12;

新增释放命令行任务、释放命令行图层的函数：

void close_constask(struct TASK *task)
{
    struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
    task_sleep(task);
    memman_free_4k(memman, task->cons_stack, 64 * 1024);
    memman_free_4k(memman, (int)task->fifo.buf, 128 * 4);
    task->flags = 0; // 用来替代task_free(task);
    return;
}

void close_console(struct SHEET *sht)
{
    struct MEMMAN *memman = (struct MEMMAN *)MEMMAN_ADDR;
    struct TASK *task = sht->task;
    memman_free_4k(memman, (int)sht->buf, 256 * 165);
    sheet_free(sht);
    close_constask(task);
    return;
}

输入exit指令之后，调用以下函数：

void cmd_exit(struct CONSOLE *cons, int *fat)
{
    struct MEMMAN *memman = (struct MEMMAN *)MEMMAN_ADDR;
    struct TASK *task = task_now();
    struct SHTCTL *shtctl = (struct SHTCTL *)*((int *)0x0fe4);
    struct FIFO32 *fifo = (struct FIFO32 *)*((int *)0x0fec);
    timer_cancel(cons->timer);
    memman_free_4k(memman, (int) fat, 4 * 2880);
    io_cli();
    fifo32_put(fifo, cons->sht - shtctl->sheets0 + 768); // 768～1023
    io_sti();
    for(;;)
    {
        task_sleep(task);
    }
}

这里并没有立即终止掉命令行程序，而是将一个信息发送给task_a，让它来帮忙终止命令行。但是不能在当前任务为命令行的时候终止自己，那样就不能继续执行之后的程序了。emm简单来说就是不能自己终结自己。

if(768 <= i && i <= 1023) // 命令行窗口关闭处理
{
    close_console(shtctl->sheets0 + (i - 768));
}

如果所有窗口都被关闭的话，此时key_win应该等于0（没有地方可以发数据）。因此在各种输入的情况下，要判断key_win是否等于0。

关闭命令行窗口（2）

harib23h

增加对鼠标点击的支持：

if(sht->bxsize - 21 <= x && x < sht->bxsize - 5 && 5 <= y && y < 19)
{
    // 点击“×”按钮
    if((sht->flags & 0x10) != 0) // 是否为应用程序窗口？
    {
        task = sht->task;
        cons_putstr0(task->cons, "\nBreak(mouse) :\n");
        io_cli(); // 强制结束处理时禁止任务切换
        task->tss.eax = (int) &(task->tss.esp0);
        task->tss.eip = (int) asm_end_app;
        io_sti();
    }
    else // 命令行窗口
    {
        task = sht->task;
        io_cli();
        fifo32_put(&task->fifo, 4);
        io_sti();
    }
}

往命令行发了个4，告诉命令行该自己结束了，之后就和键盘结束没有什么区别了。
为什么不直接在这里结束呢？是因为让命令行处理完手头的工作（比如显示字符什么的），再安全结束它。

start命令

harib23i

新建一个控制台窗口，并在里面启动后序指令。

void cmd_start(struct CONSOLE *cons, char *cmdline, int memtotal)
{
    struct SHTCTL *shtctl = (struct SHTCTL *)*((int *)0x0fe4);
    struct SHEET *sht = open_console(shtctl, memtotal);
    struct FIFO32 *fifo = &sht->task->fifo;
    int i;
    sheet_slide(sht, 32, 4);
    sheet_updown(sht, shtctl->top);
    // 将命令行输入的字符串逐字复制到新的命令行窗口中
    for(i = 6; cmdline[i] != 0; ++i)
    {
        fifo32_put(fifo, cmdline[i] + 256);
    }
    fifo32_put(fifo, 10 + 256);    // 回车键
    cons_newline(cons);
    return;
}

新建一个命令行之后，把后序指令输入到对应的FIFO中就可以了。

ncst命令

harib23j

不打开新的命令行，直接打开应用程序。
与之前直接打开的不同是之前的打开是阻塞命令行的，而这个不会。
但其实是打开了一个隐藏的命令行，并不是在原来的命令行上执行的）

void cmd_ncst(struct CONSOLE *cons, char *cmdline, int memtotal)
{
    struct TASK *task = open_constask(0, memtotal);
    struct FIFO32 *fifo = &task->fifo;
    int i;
    // 将命令行输入的字符串逐字复制到新的命令行窗口中
    for(i = 5; cmdline[i] != 0; ++i)
    {
        fifo32_put(fifo, cmdline[i] + 256);
    }
    fifo32_put(fifo, 10 + 256);    // 回车键
    cons_newline(cons);
    return;
}

当cons->sht指定为0的时候，需要禁用字符显示等操作。和之前key_win一样，需要修改相关的函数。

为了创建一个隐藏的命令行，console_task这个函数也需要修改。当sheet为0时，禁用光标定时器，退出时cons为0.
cmd_exit:

if(cons->sht != 0)
{
    fifo32_put(fifo, cons->sht - shtctl->sheets0 + 768); // 768～1023
}
else
{
    fifo32_put(fifo, task - taskctl->tasks0 + 1024); // 1024～2023
}

下面是无窗口的情况，将任务地址告知task_a

最开始打开命令行的函数也被分成了打开图层与打开任务。
最后能够处理单独关闭任务的情况就行了：

if(768 <= i && i <= 1023) // 命令行窗口关闭处理
{
    close_console(shtctl->sheets0 + (i - 768));
}
else if(1024 <= i && i <= 2023)
{
    close_constask(taskctl->tasks0 + (i - 1024));
}

目前还有点bug。。看起来明天才会讲