RSS Feed

2020 年终总结

Mon, 11 Jan 2021 13:42:33 GMT

现在是2021年1月1号的下午，就像每天的早晨、每周的周日、每个月的1号一样，这个时间点是适合做回顾和展望。在对旧事物的记忆消逝之前，回顾一下过去，在新事物到来之前，展望一下未来。

2020 的碎碎念

疫情在家的无聊/有聊时光

2020年的1月，刚放寒假我就溜回家里去了，本想着说早点回去过年，然后早点回学校干活的。谁知道疫情就这样悄然爆发了。因此2020年的前半年几乎都是在家里渡过的，直到7月末才回到学校。从初中开始，我似乎就没有在家呆过这么长的时间了，即使是高中毕业，也只在家呆了3个月而已。说实话是一种蛮奇怪的感觉，因为从初中住校开始，就再也没有像是在家一样过一些比较慢的生活了。周围人的生活就像车轮一样飞快的滚动起来，各种各样的考试，各种各样的人生节点，似乎一个不小心就要掉队，就要从人生的赛道上跌倒，然后再也回不去。疫情就像是公路上的减速带，突然让人像是越过减速带的车子一样在空中思考，思考着那些在地上不会思考的事情。

由于过年期间在家一直怀着休息一下的心情在过日子，导致在开始上网课后还是一直这样慢悠悠的生活。因为整天无所事事，导致有段时间极度无聊。人在无聊的时候就会疯狂找一些新奇的事情来满足自己，疫情在家也的确做了一些以前想做或者不想做的事情：

日记：可能是因为在家表达欲有点旺盛，需要一个宣泄口，而我又实在不想在社交网络上记录，所以在2月多开始尝试写日记。虽然现在已经断掉了，但是竟然也记录了256天。在写这篇博客的时候还回顾了一下当时的碎碎念，想想如果当时没有记录下来，可能很多有趣的事情都会被忘记吧，希望2021年多记录一下生活。
读书：二月份的时候开始尝试读一些书来消磨在家的无聊时光，印象中读的第一本书应该是麦家的《人生海海》。一开始还是用微信读书来读书。用手机读的话，可以很方便的在任何地点看，任何时间看，但是对眼睛的确不好，看了一段时间后就有点受不了。加上感觉所谓的碎片化阅读对于读书其实是不太现实的，即使是小说这种偏消遣类型的书籍，都需要一个“进入书籍”的过程。所以后面就入手了一个美版的 Kindle，在网上买了一些实体书，养成了睡觉前看书的习惯。2月到5月基本上是阅读的高峰期，每个月都读了超过10本书。4月初的时候还顺势水了一篇博客（2020 02 & 03 Reading）。当时还想着按这个趋势，今年说不定可以读100本书呢，哈哈。然而随着期末的临近，读书的数量开始下降，并且在回到学校后，基本上每个月平均也就读5本左右，所有今年算下来是读完了81本书。读的小说比较多，关于技术的书籍也就6本，希望明年可以读多一点技术相关的书籍。
跳绳：在家虽然也能去公路上跑步，但是的确没有在学校的感觉了（晨跑实在不适合我），所以每天的运动就是下午5点左右开始的跳绳。这件事情其实是因为老乾升中考需要考跳绳，所以他每天下午都跑到楼顶去要跳绳（学校要求每天打卡，哎，现在的中学生真心累）。看他跳了几次之后，感觉这是一个在家运动的不错选择，在家人的怂恿下，就开始每天的30分钟到40分钟的跳绳。一开始跳两三个就会被绳子抽头或脚到，后来把绳子放长了才好一点。这个习惯回到学校后就停下来了，一来是感觉在楼上跳绳有点扰民，楼下跳绳有点傻逼；二来是晚上夜跑显然更舒服。（被我从家里面带过来的跳绳一直放在衣柜里没拿出来过）
播客：其实我想不起来我是因为什么接触到播客的了，隐约记得最开始听应该是2019年末的时候，那时听过几期 GGTalk 和几期捕蛇者说。但当时也只是突然想起或者看到感兴趣的话题才会去听。在家这段时间貌似播客也突然进入了一个爆发期的样子，每天都有有趣的播客可以听。当时是每天跳绳的时候都会带上耳机听播客，可能是因为习惯在跳绳时听播客了，所以在回到学校后，基本就没听过了。

回到学校后瞬息万变的生活

说实话，这个学期还是发生了蛮多事情的。

我大概是在7月下旬的时候回到学校的，由于师兄师姐们都毕业了，老师又不来学校，所以暑假在学校实验室几乎是只有我一个人。同时在舍友的介绍下，还接了一个 C 语言的家教，每天早上去上3个小时的课（虽然钱收少了，但是好像也算是蛮好玩的一次体验吧）。在这种状态下，效率显然不会太高，整天在实验室划水摸鱼。
本来在开学老师是说让我接手廖大哥的论文的，但是在8月底的时候，黄志鸿的论文被退回来大改，所以被拉过去搞他那篇论文了。9月份和10月的前半个月基本都在弄他论文的实验，当然还穿插着烦人的报账。
等到实验基本搞定后，华为那边和学院签了一个项目，老师希望我能参与进去，所以在12月中旬的时候，本应该开始搞毕业论文的我又跑来华为这边打工了（BTW，等到我都已经在华为这边干活了，老师才把论文投出去）。虽说是打工，但是其实干的事情和实验室差不多，只是没像在实验室一样天天睡懒觉了而已，不过好像也不是很累。感觉这边的节奏还是比较快的，明明之前计划好要做半年的事情，现在似乎过年前就要搞定了（我对这件事情是持质疑态度的，现在的工作根本还远远不够嘛，但打工人怎敢质疑boss们的决定呢）。

除了上面的事情还有一些其他值得吐槽或者记录的事：

暑期时花了好几天修复服务器上无法开机的 Linux，后来翻启动日志才发现是我 fstab 文件写的有问题，导致某个盘挂载不上。期间学会了用启动盘和 chroot 来修复坏掉的 Linux 系统。
由于系统编程课程需要一些虚拟机来给学生用，所以在两台 Taishan 服务器上搭建 KVM 来跑多台虚拟机，OpenEuler 的生态的确有点差，很多包都没法直接用 yum 下，而且 manual 也缺了很多东西，好在可以直接拿 CentOS 的包来装。
10月初修复了断电后无法开机的集群。这个当时真的是心态炸裂了，刚好在跑实验就遇上这种事。后来是不断尝试和咨询之前师兄才修复成功的。这个无法开机有很多原因，一来是这个集群开机方式有点奇特，没有接触过的人很难摸索出来；二来是跳板机主板内的电池没电了，所以得把机器拆下来换个电池上去；三是由于断电后跳板机文件系统损坏了，所以 Linux 系统启动不起来，这个只需要进入修复模式，然后用命令修复一下就好了。
用 DeskMini 组了一台黑苹果，入手了一个 4K 屏，换了一个适配 Mac 的蓝牙键盘。加上年初入的Kindle和618时把小米6换成了K30 Pro，今年入手的东西有点多啊。哎，万恶的消费主义啊。
参加了六级，哎，估计又过不了，明年继续努力吧。

技术与三分钟热度

在家的半年，除了只想躺着和娱乐自己的咸鱼时光，当然还穿插着咸鱼后罪恶感爆棚然后下定决心要好好学习的时候啦。由于本人极其擅长三分钟热度，所以有很多东西都是接触一下，然后就弃掉了：

Flutter：日常三分钟热度，稍微接触了一下，然后就弃掉了。为啥弃掉了，没啥原因，就是三分钟热度而已。
6.824：MIT 的分布式计算课程，由于 2020 Spring 的课程有放出视频，所以也看了一波，看了 GFS、MapReduce和 Raft 的前一半论文，完成了第一个实验，然而后面就渐渐忘掉这门课了。。。
Java：在家突然产生了找不到工作的焦虑感，下定决心好好学一学后端的东西。苦思冥想后还是觉得学比较多岗位的 Java。默默买了一本《Java编程思想》后，翻了一半后就放弃了，只想躺尸。冗长的 Java 代码是在是让人受不了啊。
Scala & Spark：因为在6月份左右老师同意让我后面搞分布式计算了，让我接手廖大哥的坑。接手的时候，当然要先学一波 Scala 和 Spark 啦，所以找出了两本评价还不错的书（《Scala 实用指南》和《Spark 权威指南》）看了一下，但是都是翻到一半就放下了。这有挺多原因的，一来是后面接手黄志鸿的论文了，不需要用 Scala 和 Spark；二来是感觉的确不需要对 Scala 和 Spark 掌握太深，而且 Spark 那本书给我的感觉就是，Spark 日常使用只需要用 SQL 写就 OK 了。这也难怪大数据工程师似乎越来越不吃香了，因为一旦平台搭建起来后，后面的使用其实并不需要太多计算机的背景。
SQL & Database：这个东西怎么说呢，我好像每年都会尝试系统的学习一下，但是每次都是很快的放弃了，一直不得要领。哎，这都快成一个执念了。

虽然大部分尝试学习的技术都没啥进展和成果，很快的就被遗忘了，但是有些东西还是有一定产出的：

前端：尝试过 Vue 和 React ，学过 Node.js，看过 MDN 的文档和教程，在不同的 Tutorial 中反复横跳，一直不得要领，最后是在开始用 Gastby.js 做博客后感觉有点入门的感觉了，最终还是有点小收获，小成果。后来仔细想过为啥之前一直学不来前端，而用 Gatsby.js 搭建博客却能有一个比较好的进展？一来是前端的东西确实琐碎，想要做出一个东西需要用到其他很多工作或者背景知识，而我又带着一种希望系统学完某个东西的念头去学，所以导致之前一直没啥进展。后来是意识到了它的琐碎的特性，尝试用之前学 Linux 的方式去学（遇到问题再解决，没有问题就忽略，不深究其细节），才有所成果；二来是 Gatsby.js 的确是一个非常适合做（静态）博客的框架，并且文档和 Tutorial 都非常详细。现在回去看看 GitHub 的 Commit，会发现 aa-gatsby-blog 几乎是在一两周内就实现出来的。而且如果一开始不头铁尝试用 Tailwind.css 的话，可能会在更短的时间内搞定。虽然现在的确没法很轻松、很快速的完成一个前端项目，但的确不会再对这个东西有太多的恐惧感了（如果不涉及到 CSS 的话，哈哈哈哈）
LeetCode：这个东西怎么说呢，也有点三分钟热度吧。年初准备整理一下之前刷过的题，但是连一个专题都没完成就结束了。后来想每周都参加周赛，但也才参加了19场而已。不过也不是没有产出。首先是，周赛。虽然大部分时间都是200名开外，属于前三题好说，最后一天打死做不出来的状态，但是的确有次AC了第四题，并拿到了64名（就是第一次打周赛，也是因为这个，后面才会想着打的）。其次是，题解。在整理刷过的题时，发现之前用一种比较 Fancy 的方法 AC 了一道题，所以就把博客的内容转到了 LeetCode 的题解中去了（用有限状态机的思想来解这道题），并收获了7个赞和6个收藏。最后，一年下来竟然也 AC 了85道题目，让 AC 过的题目数量达到了330。
Java & Hadoop：是的，你没看错，在上半年被放弃的 Java，在后面的9月份的时候又捡起来了。原因是因为接手的那篇论文是基于 Hadoop 做的，所以用的是 Java。因此在9月份的时候用 Java 实现了几个并行算法，并使用 perf 等东西尝试对现有算法进行了优化，还拿 Hadoop 复现了一个算法。之前一直嫌弃 Java 的我在写的时候竟然觉得“真香”了（主要是 IDEA 太好用了）。当然我也知道自己也就半瓶水，没有 Google 根本没法干活的那种。对 Hadoop 也只是写 Mapper 和 Reducer 而已。
Pytorch：由于12月份要去华为，所以在11末的时候，老师已经不太管我了。由于在那边是做机器学习相关的项目，所以就提前学习了一下 Pytorch（动态图真香），用Pytorch复现了一两篇论文（DA-RNN和DSANet），后面这个竟然在12月31号的晚上收到了一个 Star，实在是太开心了。
TensorFlow：是的，事情就是那么尴尬，过去那边后他们觉得用 TensorFlow。。。所以就现学现卖的用 TensorFlow 了。嗯，TensorFlow 2 真香。
Blog：（这个也算是技术嘛？）Anyway，今年也写了10篇左右的博客。虽然都挺水的，但是还是希望明年可以写多一点，多记录一下生活，沉淀一下技术。

关于 2021

2021 年可预见会发生的大事就挺多的：

结束华为的项目：希望这件事情能够顺利吧，也希望可以在这里面水一篇论文出来作为毕业设计。
毕业论文开题：哎，这可能是下学期最让人头疼的事情了。
6月份的六级考试：emmmm，再不过的话就会影响到秋招了。
秋招：虽说还有春招，但是还是希望能在秋招就找到满意的工作。

我是一个很喜欢做计划的人，但是几乎从来不会按计划做事情，所以未来的事情交给未来的我烦恼吧。

6.S081 lab2 system calls

Mon, 14 Dec 2020 15:20:55 GMT

6.S081 的第二个实验，system calls，虽然是好久之前做的了，但是一直没把它放到博客里面。今天略无聊，就弄了一下。BTW，第三个实验我到现在都还没开始呢。

system call

在完成实验之前，我们可以先了解一下系统调用的相关的代码。

首先在user/usys.pl中包含生成系统调用汇编的 Perl 代码，其核心为下面这段代码：

sub entry {
    my $name = shift;
    print ".global $name\n";
    print "${name}:\n";
    print " li a7, SYS_${name}\n";
    print " ecall\n";
    print " ret\n";
}

可以看出来这是一个创建汇编的代码，例如调用entry("fork");会得到一下汇编：

fork:
 li a7, SYS_fork
 ecall
 ret

从xv6-book中，我们可以知道：

ecall是rsic-v中用来从用户态转到特权态的指令
a7用来保存要调用的系统调用号。
SYS_fork在kernel/syscall.h中被定义。

在ecall被调用时，RISC-V 的 CPU 会设置一些寄存器（如将pc保存在sepc），然后将stvec保存到pc中，这时，CPU就会执行stvec所指向的代码了，stvec在返回用户态时会被设置成kernel/trampoline.S中uservec（见kernel/trap.c#L100）.

uservec的主要做了以下几件事情：

交换a0和sscratch寄存器，而sscratch是进程用户空间的trapframe的虚拟地址，此时已经将a0保存到sscratch寄存器中了。
保存寄存器到trapframe中（包括a0）
从trapframe中恢复内核栈、切换页表
跳转到usertrap中

usertrap（kernel/trap.c#32）主要做了以下几件事：

检验是否从用户态进入（通过sstatus确认）。
设置stvec为kernelvec，保存用户态pc（在调用ecall时被保存到了sepc中了）。
关中断
执行syscall进行系统调用
调用usertrapret返回

前面的步骤已经将用户态转换成内核态，并将需要保存的信息保存到对应的位置，并将栈和页表等切换成内核所使用的栈和页表了。

syscall（kernel/syscall.c#133）的代码如下：

void
syscall(void)
{
  int num;
  struct proc *p = myproc();

  num = p->trapframe->a7;
  if(num > 0 && num < NELEM(syscalls) && syscalls[num]) {
    p->trapframe->a0 = syscalls[num]();
  } else {
    printf("%d %s: unknown sys call %d\n",
            p->pid, p->name, num);
    p->trapframe->a0 = -1;
  }
}

可以看到在syscall中，它从a7取出system call number，并调用了对应的handler，然后把返回值保存到用户态的a0中。

系统调用返回的过程有点像是刚才的逆过程，uservec和usertrap分别对应userret和usertrapret。这里不在赘述。

总结以下，当我们调用fork()时会发生的事情。

通过usys.pl生成的汇编fork()将参数放到a7中，并调用ecall
调用ecall时，CPU 会执行一些操作（保存用户态pc到sepc，拷贝stvec到pc中）
由于stvec在用户态时指向uservec，所以会执行uservec来保存寄存器、切换页表、恢复内核堆栈，并跳转到usertrap
usertrap会将stvec修改成kernelvec，关中断调用syscall
syscall会根据a7中保存的system call number来调用对应的handler，执行完后返回值保存在a0中。
usertrap末尾调用usertrapret，而usertrapret会跳转到userret，这两个过程会逆向uservec和usertrap的操作。

trace

由于前面已经分析过调用系统调用的过程了，但是添加一个系统调用还是有所不同的，我们要进行以下步骤：

在kernel/syscall.h中设置系统调用号，如#define SYS_trace 22
在kernel/syscall.c中的syscalls数组中设置对应的 handler 函数，同时需要在该数组的上方加入相关的函数声明，如extern unit64 sys_trace(void);
在kernel/sysproc.c中实现对应的 handler 函数，如sys_trace函数
在user/user.h中添加函数声明，如int trace(int);
在user/usys.pl添加对应的entry已生成相应系统调用的汇编，如entry("trace");

添加完成后，我们可以就需要实现kernel/sysproc.c中sys_trace的实现了。

首先，题目要求我们能够通过trace系统调用来设置哪些系统调用会被trace，而且trace的参数也已经提示我们要用1 << SYS_*的方式来设置mask了，mask应该由trace命令来设置。trace应该是只时对某个进程有效的，所以这个mask应该与进程绑定，所以我们可以在进程proc结构体中加入一个新的变量tracemask。然后sys_trace只需要获取用户态传入的参数，并设置进程的tracemask即可。

sys_trace的实现如下：

uint64
sys_trace(void)
{
    int mask;
    if (argint(0, &mask) < 0)
        return -1;
    myproc()->tracemask = mask;
    return 0;
}

从上面关于系统调用的分析可以知道，每个系统调用的 handler 都会由syscall来调用，所以我们可以在修改这个函数来实现每次系统调用 handler 返回后都输出对应的信息。pid和系统调用返回值都可以直接获取到，而系统调用名称则需要自己手动写一个字符串数组来映射。下面是实现代码：

void
syscall(void)
{
  int num;
  struct proc *p = myproc();

  num = p->trapframe->a7;
  if(num > 0 && num < NELEM(syscalls) && syscalls[num]) {
    p->trapframe->a0 = syscalls[num]();
    if (!!(1 << num  & p->tracemask)) {
        printf("%d: syscall %s -> %d\n", p->pid, syscall_name[num], p->trapframe->a0);
    }
  } else {
    printf("%d %s: unknown sys call %d\n",
            p->pid, p->name, num);
    p->trapframe->a0 = -1;
  }
}

由于题目要求某个进程被trace后，其子进程也要被trace，所以我们只需要在fork中简单的添加np->tracemask = p->tracemask即可。

sysinfo

这里要增加一个系统调用来实现sysinfo，因为前面已经描述过给xv6增加系统调用的过程了，这里不在赘述。

因为sysinfo需要传入一个struct sysinfo的指针，然后通过这个指针返回一个struct sysinfo，这个结构体主要包含两个属性：freemem和nproc，即当前空闲内存和当前状态不为UNUSED的proc数量。所以这个实验主要要解决三个问题：

计算当前空闲内存大小
计算当前状态不为UNUSED的proc数量
将计算得到的值从内核态拷贝到用户态。

freemem

在kernel/kalloc.c代码中可以看到：

struct run {
  struct run *next;
};

struct {
  struct spinlock lock;
  struct run *freelist;
} kmem;

这里有一个全局变量kmem，她包含了一个名为freelist的链表指针和保护该链表的锁。从其他相关代码可以看出这个freelist所代表的链表是空闲页，每一个空闲页的开头都保存着下一个空闲页的位置，由于每一页的大小都是固定的，已知的（由PGSIZE确定），所以通过遍历一个freelist可以计算出空闲内存大小。这个要主要的是在遍历链表时，需要想获取锁。实现代码如下：

uint64
kfreemem(void)
{
    uint64 size = 0;
    struct run *r;
    acquire(&kmem.lock);

    for(r = kmem.freelist ; r ; r = r->next)
        size += PGSIZE;
    release(&kmem.lock);
    return size;
}

nproc

从kernel/proc.c可以看出来内核中可用的struct proc是由一个数组存储的，我们可以简单的遍历这个数组，然后判断每个元素的状态是否为UNUSED，然后计数即可。代码如下：

uint64
nproc(void)
{
    uint64 n = 0;
    struct proc *p;
    for(p = proc;p < &proc[NPROC]; p++) {
        if (p->state != UNUSED)
            n++;
    }
    return n;
}

copyout

由于sys_sysinfo系统调用读到的地址是用户态的虚拟地址，所以不能在内核直接使用，copyout函数来将内存中的数据拷贝到用户态。从实验给出的提示可以看出，可以从参考sys_fstat和filestat来使用copyout。由于sys_fstat只涉及到读取参数和调用filestat，所以这里只给出filestat的代码，它的第二个参数就是用户态的地址。

// Get metadata about file f.
// addr is a user virtual address, pointing to a struct stat.
int
filestat(struct file *f, uint64 addr)
{
  struct proc *p = myproc();
  struct stat st;

  if(f->type == FD_INODE || f->type == FD_DEVICE){
    ilock(f->ip);
    stati(f->ip, &st);
    iunlock(f->ip);
    if(copyout(p->pagetable, addr, (char *)&st, sizeof(st)) < 0)
      return -1;
    return 0;
  }
  return -1;
}

上面的代码关键在于copyout(p->pagetable, add, (char*)&st, sizeof(st))，这里可以看出copyout是通过进程的页表来计算实地址的位置。

因此，我们可以写出sys_sysinfo的代码如下：

uint64
sys_sysinfo(void)
{
    struct sysinfo info;
    struct proc *p = myproc();
    uint64 pinfo;

    if (argaddr(0, &pinfo) < 0)
        return -1;

    info.freemem = kfreemem();
    info.nproc = nproc();


    if (copyout(p->pagetable, pinfo, (char *)&info, sizeof(info)) < 0)
        return -1;
    return 0;
}

6.S081 laba1 util

Fri, 20 Nov 2020 21:09:55 GMT

最近在看6.S081的实验，希望这次别半途而废吧。

sleep

简单的解析命令行参数，然后调用user.h里面sleep函数即可。这道题应该只是让人熟悉一下环境。

记得要修改Markfile来编译 sleep 命令。
./grade-lab-util sleep可以快速的运行测试。

#include "kernel/types.h"
#include "kernel/stat.h"
#include "user/user.h"

int
main(int argc, char *argv[])
{
    if (argc == 1) {
        fprintf(2, "usage: sleep ticks\n");
        exit(1);
    }
    
    int ticks = atoi(argv[1]);
    sleep(ticks);
    
    exit(0);
}

pingpong

这一题要实现通过pipe的进程间通信，虽然只是简单的pingpong。但也有需要注意的点：

因为两个进程需要相互发信息，所以需要两个pipe，如果只有一个pipe的话，第一个进程向pipe写完后，需要读取第二个进程发过来的pong，这时就会出现两个进程同时读管道的情况，进而导致

#include "kernel/types.h"
#include "kernel/stat.h"
#include "user/user.h"

int
main(int argc, char *argv[])
{
    int fds1[2], fds2[2];
    if (pipe(fds1) != 0) {
        fprintf(2, "make pipe fail.\n");
        exit(1);
    }
    
    if (pipe(fds2) != 0) {
        fprintf(2, "make pipe fail.\n");
        exit(1);
    }

    char byte1 = '1';
    char byte2 = '2';
    char temp;

    int pid = fork();
    if (pid < 0) {
        fprintf(2, "fork fail\n");
        exit(2);
    } else if (pid > 0) {
        // parent
        write(fds1[1], &byte1, 1);
        read(fds2[0], &temp, 1);
        if (temp == '2') {
            printf("%d: received pong\n", getpid());
        }
		wait(0);
    } else {
        // child
        read(fds1[0], &temp, 1);
        if (temp == '1') {
            printf("%d: received ping\n", getpid());
        }
        write(fds2[1], &byte2, 1);
    }
    
    exit(0);

}

primes

这道题是想让我们用pipe和fork来实现一个CSP风格的程序，从给出的链接可以找到要是程序的核心伪代码和图例：

p = get a number from left neighbor
print p
loop:
    n = get a number from left neighbor
    if (p does not divide n)
        send n to right neighbor

简单来讲就是，第一个进程先创建一个子进程，并使用管道和子进程通信，然后父进程向管道写入2到35的数字。子进程执行下面操作：

从与父进程之间的管道读取数字
如果没读到（read返回0），则退出
如果读到了，则输出该数字p，并创建新的子进程，同时创建与新进程间的管道，子进程跳转到1。
从与父进程之间的管道读取数字n，并判断n是否能够被p整除，如果不能则向与子进程的管道中写入该数字。当读不到数字时就退出。

上面的流程其实没有提及到管道的关闭和父进程的wait操作，但是这些对于程序的正确性是非常重要的，如果没有及时关闭不必要的读端和写端，会导致操作系统文件描述符耗尽，从而创建管道失败。而如果父进程在结束前没有wait的话，会导致子进程的输出与shell的输出混在一起。

实现代码如下：

#include "kernel/types.h"
#include "kernel/stat.h"
#include "user.h"

int
main(int argc, char *argv[]) 
{
    int fds[2];
    int pid, i, res, readfd, writefd;
    int p, n;
    if (pipe(fds)) {
        fprintf(2, "make pipe fail\n");
        exit(1);
    }

    pid = fork();
    if (pid < 0) {
        fprintf(2, "fork fail\n");
        exit(1);
    } else if (pid) {
        // parent
        close(fds[0]); // close read
        for(i = 2;i <= 35;i++) {
            write(fds[1], &i, 4);
        }
        close(fds[1]);
        wait(0);
        exit(0);
    }
    
    // child
    while(1) {
        close(fds[1]);
        readfd = fds[0];
        res = read(readfd, &p, 4);
        if (res == 0) {
            close(readfd);
            exit(0);
        }
        if (pipe(fds)) {
            fprintf(2, "make pipe fail");
            exit(1);
        }

        pid = fork();
        if (pid < 0) {
            fprintf(2, "fork fail\n");
            exit(2);
        } else if (pid) {
            // parent
            writefd = fds[1];
            close(fds[0]);
            
            printf("prime %d\n", p);
            while(read(readfd, &n, 4)) {
                if (n % p) {
                    write(writefd, &n, 4);
                }
            }
            close(readfd);
            close(writefd);
            wait(0);
            break;
        }
    }
    exit(0);
}

find

这道题要求实现一个简易的find命令，虽然看上去听复杂的，但是基本上将ls里面的代码修改一下即可搞定。

所以我们可以先分析一下user/ls.c的代码，这个程序的核心在于ls函数中的实现，所以我们只看这个即可。

ls 的实现

首先是用open打开给定路径，然后用fstat来获取文件的一下属性：

if((fd = open(path, 0)) < 0){
	fprintf(2, "ls: cannot open %s\n", path);
	return;
}

if(fstat(fd, &st) < 0){
	fprintf(2, "ls: cannot stat %s\n", path);
	close(fd);
	return;
}

其中st是一个struct stat类型的变量，它的定义可以在kernel/stat.h中找到：

#define T_DIR     1   // Directory
#define T_FILE    2   // File
#define T_DEVICE  3   // Device

struct stat {
  int dev;     // File system's disk device
  uint ino;    // Inode number
  short type;  // Type of file
  short nlink; // Number of links to file
  uint64 size; // Size of file in bytes
};

从stat中我们可以获取到文件类型，通过这个我们就可以来判断当前打开的是目录还是文件了，如果是文件则输出文件信息，如果是目录则解析目录中所包含的文件，并逐个输出文件信息，解析目录的代码如下：

if(strlen(path) + 1 + DIRSIZ + 1 > sizeof buf){
  printf("ls: path too long\n");
  break;
}
strcpy(buf, path);
p = buf+strlen(buf);
*p++ = '/';
while(read(fd, &de, sizeof(de)) == sizeof(de)){
  if(de.inum == 0)
	continue;
  memmove(p, de.name, DIRSIZ);
  p[DIRSIZ] = 0;
  if(stat(buf, &st) < 0){
	printf("ls: cannot stat %s\n", buf);
	continue;
  }
  printf("%s %d %d %d\n", fmtname(buf), st.type, st.ino, st.size);
}

上面的代码的核心在于通过while循环来从目录的文件描述符中读取目录项，目录项的是一个struct dirent结构体，可以从kernel/fs.h找到相关的定义：

#define DIRSIZ 14
struct dirent {
   ushort inum;
   char name[DIRSIZ];
 };

其中inum是inode编号。

find 实现

find和ls的实现基本一致，区别点在于：

当打开的是文件时，需要与输入pattern进行比较，来决定是否输出
当打开的是目录时，需要递归调用find函数
由于与pattern进行比较是文件名，而不是路径，所以为了简便，find 的三个参数分别为path，filename，pattern。

#include "kernel/types.h"
#include "kernel/stat.h"
#include "user.h"
#include "kernel/fs.h"

void
find(char *path, char *filename, char *pattern) 
{
    int fd;
    char buf[512], *p;
    struct stat st;
    struct dirent de;

    if ((fd = open(path, 0)) < 0) {
        fprintf(2, "find: cannot open %s\n", path);
        exit(1);
    }

    if (fstat(fd, &st) < 0) {
        fprintf(2, "find: cannot stst %s\n", path);
        close(fd);
        exit(1);
    }

    switch(st.type) {
        case T_FILE:
            if (strcmp(filename, pattern) == 0) {
                printf("%s\n", path);
            }
            break;
        case T_DIR:
            if (strlen(path) + 1 + DIRSIZ + 1 > sizeof buf) {
                printf("find: path too long\n");
            }
            strcpy(buf, path);
            p = buf + strlen(buf);
            *p++ = '/';
            while(read(fd, &de, sizeof(de)) == sizeof(de)) {
                if (de.inum == 0) {
                    continue;
                }
                if (strcmp(de.name, ".") == 0 || strcmp(de.name, "..") == 0) {
                    continue;
                }
                memmove(p, de.name, DIRSIZ);
                p[DIRSIZ] = 0;
                find(buf, de.name, pattern);
            }
            break;
    }
    close(fd);
}

int 
main(int argc, char *argv[]) 
{
    if (argc < 3) {
        fprintf(2, "usage: find <path> <pattern>\n");
        exit(1);
    }

    find(argv[1], argv[1], argv[2]);
    exit(0);
}

xargs

在解决这道题前，我们先了解一下xargs的使用。

xargs 基本使用

我们知道在shell中可以使用|将两个命令的输出和输入连接在一起，比如说cat text.txt | more，这可以让我们将多个简单的程序连接在一起实现复杂的功能。而有时候，我们希望将第一个命令的输出作为第二个命令的命令行参数来调用。比如说我们有一个文件cmd.txt包含以下内容：

echo
ls

我们希望用which命令来查询cmd.txt中每行命令所在的路径。如果我们直接通过|来连接cat cmd.txt和which的话，会没有任何输出，这是因为which命令是从命令行参数中读取要查询的命令名，而不是从标准输入中读取。这种时候，我们就可以用xargs来将标准输入转化为命令行参数了：

# wuxiaobai24 @ wuxiaobai24-pc in ~/code/6.828/xv6-labs-2020 on git:util x [15:56:08] 
$ cat cmd.txt
echo
ls

# wuxiaobai24 @ wuxiaobai24-pc in ~/code/6.828/xv6-labs-2020 on git:util x [15:56:13] 
$ cat cmd.txt | which

# wuxiaobai24 @ wuxiaobai24-pc in ~/code/6.828/xv6-labs-2020 on git:util x [15:56:18] C:1
$ cat cmd.txt | xargs which
/usr/bin/echo
/usr/bin/ls

xargs 的使用格式xargs [options] [command [initial-arguments]]

echo "world\nos" | xargs echo hello 会被转化成echo hello world和echo hello os来执行。

xargs

因为题目给出了这里的xargs是类似于xargs -n 1的执行效果就好了，这其实就降低了难度了，因为它其实限制了xargs一次只会传入一个参数，我们逐字符读取输入，然后判断是否为\n，如果不是就将该字符暂存，如果是就将这之前保存字符串添加到原本命令行参数的后面，并调用fork和exec执行即可。

但是其实正常xargs好像也没太大问题，即支持一行中有多个参数，只是需要在解析时考虑多一个和\t即可。

#include "kernel/types.h"
#include "kernel/stat.h"
#include "kernel/param.h"
#include "user.h"

int
main(int argc, char *argv[])
{
    int i, cmdLen;
    char *cmd[MAXARG];
    char buf[512];
    char c;

    if (argc < 2) {
        fprintf(2, "usage: xargs <command>\n");
        exit(1);
    }

    cmdLen = 0;
    for(i = 1;argv[i];i++) {
        cmd[cmdLen++] = argv[i];
    }

    i = 0;
    cmd[cmdLen] = buf;
    while(read(0, &c, 1)) {
        switch(c) {
            case ' ':
            case '\t':
                buf[i++] = '\0';
                cmd[++cmdLen] = buf + i;
                break;
            case '\n':
                cmd[++cmdLen] = 0;
                buf[i++] = '\0';
                int pid = fork();
                if (pid < 0) {
                    fprintf(2, "xargs: fork fail\n");
                    exit(1);
                } else if (pid == 0) {
                    // child
                    exec(cmd[0], cmd);
                }
                wait(0);
                cmdLen = argc - 1;
                cmd[cmdLen] = buf;
                i = 0;
                break;
            default:
                buf[i++] = c;
        }
    }
    exit(0);
}

uptime

貌似是只需要调用uptime的返回值即可？

#include "kernel/types.h"
#include "kernel/stat.h"
#include "user.h"

int 
main(int argc, char *argv[]) {
    int ticks = uptime();
    printf("%d\n", ticks);
    exit(0);
}

grep with regular expressions

因为给出了提示，在user/grep.c里面有关于正则表达式的代码，所以可以直接把那部分代码拷贝过来，然后将strcmp修改成对应的match即可。

正则表达式match代码实现如下：

// Regexp matcher from Kernighan & Pike,
// The Practice of Programming, Chapter 9.

int matchhere(char*, char*);
int matchstar(int, char*, char*);

int
match(char *re, char *text)
{
  if(re[0] == '^')
    return matchhere(re+1, text);
  do{  // must look at empty string
    if(matchhere(re, text))
      return 1;
  }while(*text++ != '\0');
  return 0;
}

// matchhere: search for re at beginning of text
int matchhere(char *re, char *text)
{
  if(re[0] == '\0')
    return 1;
  if(re[1] == '*')
    return matchstar(re[0], re+2, text);
  if(re[0] == '$' && re[1] == '\0')
    return *text == '\0';
  if(*text!='\0' && (re[0]=='.' || re[0]==*text))
    return matchhere(re+1, text+1);
  return 0;
}

// matchstar: search for c*re at beginning of text
int matchstar(int c, char *re, char *text)
{
  do{  // a * matches zero or more instances
    if(matchhere(re, text))
      return 1;
  }while(*text!='\0' && (*text++==c || c=='.'));
  return 0;
}

sh

not print $ when processing shell command from a file

一开始挺懵的，要判断sh的输入是否从文件中来，后来发现它提供了一个fstat的系统调用，函数头为int fstat(int fd, struct stat*)，而这里的struct stat可以从kernel/stat.h中找到：

#define T_DIR     1   // Directory
#define T_FILE    2   // File
#define T_DEVICE  3   // Device

struct stat {
  int dev;     // File system's disk device
  uint ino;    // Inode number
  short type;  // Type of file
  short nlink; // Number of links to file
  uint64 size; // Size of file in bytes
};

通过fstat，我们可以判断一个文件描述符是否为设备，而从user/init.c中可以看到sh的标准输入正式从设备console中来的，所以我们在sh程序的开始判断一次即可。如果是终端，则每次getcmd都输出$ ，如果不是，则每次都不输出。

int cmdFromConsole; // check whether cmd from console

int
getcmd(char *buf, int nbuf)
{
  if (cmdFromConsole)
    fprintf(2, "$ ");
	//....
}

//....
  fstat(0, &st);
  cmdFromConsole = (st.type == T_DEVICE);

ST-MVL: Filling Missing Values in Geo-sensory Time Series Data

Mon, 09 Nov 2020 21:09:55 GMT

这篇文章发表在 IJCAI 2016 上。
解决的问题：如何在Geo-sensory Time Series上进行缺失值填充？
主要的idea：结合 IDW，SES，ICF 和 UCF 四种方法提出一种Multi-View learning based的方法来进行缺失值填充。

Introduction

为什么需要`Filling Missing Values`

为了监测环境（如空气质量、天气），大量的传感器被部署在不同的地方，进而产生了大量的Geo-sensory Time Series数据。
由于传感器故障和网络传输故障等原因，Geo-sensory Time Series数据往往存在大量的缺失：
- Block missing包含
  - Spatial block missing：所有传感器的读数同时缺失。
  - temporal block missing：某个传感器的读数在一段时间（时间长度由 $w$ 给定)内出现缺失
- 2014/05/01 - 2015/04/30 Beijing

Challenge

Readings （仪表读数） can be absent at arbitrary sensors and timestamps.
同时可能会出现block missing（如下图 t2 时刻所有传感器都出现了缺失），这种情况某些方法是无法处理的（比如非负矩阵分解 non-negative matrix factorization NMF)
Affected by multiple complex factors, sensor readings change over location and time significantly and non-linearly。
对于某个传感器的读数来说，相隔比较的远的传感器的读数可能会比相隔比较近的传感器的读数对于当前传感器更加相近，如下图，相比于S3，S1和S2更近，但是S2和S3的AQI变化却更加相似。

Contribution
ST-MVL simultaneously considers 1) the spatial correlation between different time series and 2) the temporal correlation between readings at different timestamps in the same series, to generate a more accurate estimate.
ST-MVL integrates the advantages of global views, i.e. empirical models derived from the data over a long period, and those of local views, i.e. data-driven algorithms that are concerned with recent readings, to achieve better accuracy.
ST-MVL can handle the block missing problem, combining the four views in a multi-view learning
framework.
We evaluate our method using Beijing air quality and meteorological data. The results demonstrate the advantages of our method compared with ten baselines.
Overview
Problem Definition
由于作者没有显式的提出Problem Definition，所以这里只是简单描述一下问题。
假设有m个传感器（记录的都是同一种数据，如PM2.5），其分别记录了长度为n的时间序列，我们可以将其表示成一个矩阵（如下图），第 i 行表示第 i 个传感器的所记录的时间序列，第 j 列表示 j 时刻所有传感器所记录的值， $v_{i,j}$ 表示第 i 个传感器第 j 时刻的读数。下图中 $v_{2,j}$ 和 $v_{1,j+1}$ 是缺失值，我们的问题就是利用已有的信息来填充缺失值，使其尽量与真实值接近。注意：这里不同的传感器只是在不同地方而已，它们记录的是同一种数据，例如都是记录PM2.5或都是记录空气湿度。

Multi View

对于相似度计算这个问题，我们可以通过不同的view/角度进行分析。view可以以下两种方式进行划分：

利用同一空间维度还是同一时间维度上的信息：
- spatial view：利用同一时刻空间上相邻的传感器的值去估计缺失值
- temporal view：利用同一传感器相邻时刻的值去估计缺失值
利用全部数据还是部分数据（这里特制是否只使用一段时间内的数据）
- global view：考虑所有时刻的数据去估计缺失值
- local view：考虑一个时间段内去估计缺失值

这一部分可以接合上面那张图来理解。

Framework

以下描述不是原文内容，但是将文中所使用的的方法统一到该框架下，有助于理解。

对于缺失值填充这个问题来说，我们可以把大部分方法（起码这篇文章所用到四个方法都可以）归结到同一个框架上去。

我们有 $n$ 个已知值 $v_1,v_2,v_3,...,v_n$ 和一个缺失值 $u$ ，我们认为缺失值可以通过已知值的加权求和来进行预估，因此可以通过下面的公式对缺失值 $u$ 进行估计：

u=\sum_{i=1}^n{w_i*v_i}

那么现在问题的关键就是如何计算权重 $w_i$ 了，如果我们能够计算出 $v_i$ 和 $u$ 之间的相似度 $sim(v_i, u)$ ，那么我们就可以通过这样一个公式来计算权重 $w_i$ :

w_i = \frac{sim(v_i,u)}{\sum_{i=1}^n sim(v_i,u)}

因此我们可以得到以下公式：

u = \frac{ \sum_{i=1}^n sim(v_i,u)*vi}{\sum_{i=1}^n sim(v_i,u)}

那么接下来的问题就是如何去计算 $v_i$ 和 $u$ 之间的相似度 $sim(v_i, u)$ 了。

ST-MLV

该文章的主要想法就是结合四个现有的缺失值填充方法，将他们得到的估计值进行综合得到预估值，四个方法分别为:

IDW (Inverse Distance Weighting)
SES (Simple Exponential Smoothing)
UCF (User-based Collaborative filtering)
ICF (Item-based Collaborative filtering)

四个方法分别代表不同的view（从下图中可以看出看出每种方法所代表的view），ST-MLV的主要想法就是先使用四种方法计算出缺失值的估计值，然后对这些估计值进行加权求和（Multi-View Learning)，这里权值通过训练得到。

接下来，我们分别介绍这个四种方法以及 Multi-View Learning。因为前面介绍过这四种方法都可以同一到一个框架下，将问题转化成相似度计算问题，因此在后面介绍着四种方法的时候，我们只分析它如何计算相似度。

为了方便，在下面的讨论中，假定要进行缺失值填充的值为 $v_{2, j}$

Global Spatial View - IDW

IDW的想法是两个传感器在空间上越靠近，那么他们所记录的时间序列应该越相似，因此我们可以使用两个传感器之间距离的倒数来作为他们的相似度，同时，为了控制权值随着距离增加的衰减速度，增加一个恒为正的指数：

IDW(v_{i,j}, v_{2,j})=distance(v_{i,j}, v_{2,j})^{-\alpha}

由于IDW是 Global View ，因此它会利用 $t$ 时刻的所有传感器（不含缺失值）进行预估（如下图所示，IDW利用的是红框内所有非缺失的值）。

Global Temporal View - SES

SES的想法是一个传感器/时间序列上，越相近的两个时刻越相似。它借鉴了指数平滑模型 $\hat{v_{gt}}=\beta v_j + \beta (1-\beta)v_j-1 + \cdots + \beta(1-\beta)^{t_j-1}v_1$ ，将相似度表示为：

SES(v_{2, i}, v_{2,j}) = \beta (1 - \beta)^{|j-i| - 1}

由于SES是Global View，因此它会利用第 $j$ 个传感器所有时刻（不含缺失值）的值来进行预估（如下图所示，SES利用的是红框内所有非缺失的值）。

Local View

在介绍 UCF 和ICF之前，由于他们都是local view和Collaborative filtering，所以这里先描述一下local view和Collaborative filtering。

首先，local view是计算相似度时只考虑一个时间窗内的数据，时间窗长度由 $w$ 给定，如果缺失值所在的时刻为 $t$ ，则时间窗为 $[j- \frac {w-1} {2}, j + \frac {w+1} {2}]$ 如下图，我们想要预测 $v_{2,j}$ ，而 $w=2$ ，所以我们在计算相似度的时候就只考虑 $t-2$ 到 $t+2$ 的的数据。

Local Spatial View - UCF

UCF是一种常见的推荐算法，它主要的想法是，相似的用户对于同一个物品的评分是相近的。对于我们这个问题，一个传感器被当成一个用户。两个传感器的相似度的计算公式为：

UCF(s_i, s) = 1 / {\sqrt{\frac {\sum_{k= j- \frac {w-1} {2}}^{ j + \frac {w+1} {2}} (v_{i,k}-v_{2,k})} {NT}}}

其中 $NT$ 为时间窗内，两个传感器同时有读数的时刻数。

因为 UCF 计算的是两个传感器之间的相似度，按照之前提到的 framework，我们可以把这个相似度作为权值对同一时刻所有传感器的读数进行加权求和。

Local Temporal View - ICF

ICF 也是一种常见的推荐算法，它的主要想法是某个用户对相似的物品会做出相似的评分。对于我们这个问题，一个时刻被当成一个物品。则两个时刻的相似度的计算公式为：

sim(t_i, t_2) = 1 / \sqrt {\frac {\sum_{k=i}^m(v_{k,i} - v_{k, 2})} {NS}}

其中 $m$ 是传感器个数， $NS$ 是在 $t_i$ 和 $t_j$ 同时有读数的传感器的个数。

因为ICF计算的是两个时刻之间的相似度，按照之前提出的 framework，我们可以把这个相似度作为权值对这个传感器在时间窗内值进行加权求和。

Multi-View Learning

对于缺失值 $v_{2, j}$ ，我们可以使用上面提到的四种方法计算分别得到 $\hat {v_{gs}},\hat {v_{gt}},\hat {v_{ls}},\hat {v_{lt}}$ ，对这四个值进行一次线性回归得到最终的预测值 $\hat{v_{2,j}}$ :

\hat{v_{2,j}} = w_1 * \hat {v_{gs}} + w_2 * \hat {v_{gt}} + w_3 * \hat {v_{ls}} + w_4 * \hat {v_{lt}} + b

其中 $w_k$ 是分别对每个传感器进行训练得到的。

同时，由于 UCF 和 ICF 不能很好的处理 block missing （因为如果时间窗内所有值都缺失，那么就无法计算出相似度了），所以遇到 block missing 的时候就先用 SES 或 IDW 进行一次填充先。ST-MVL的具体算法如下：

Experiment

Dataset

2014/05/01 - 2015/04/30 北京的空气质量和天气数据。

Metric

Mean Absolute Error (MAE):
$MAE = \frac {\sum_i{|v_i - \hat{v_i}|}} n$
Mean Relative Error (MRS):
$MRE = \frac {\sum_i{|v_i - \hat{v_i}|}} {\sum_i v_i}$

Result

Conclusion

这篇问题主要解决了时空数据上缺失值的问题，当时空数据集存在大量缺失值的问题时，可以考虑引入这篇文章的方法来解决这个问题，算法简洁有效，而且跑起来应该挺快的，算是一个比较好的 baseline。

Reference

Docker Quick Start

Sat, 18 Jul 2020 17:42:33 GMT

基础概念

Docker 引擎主要的组件构成为：

Docker client
Docker daemon
containerd
runc

它们的关系如下：

Docker daemon 实现了 Docker 引擎的 API，默认情况下，Docker client 与 Docker daemon 之间的通信有本地的 IPC/UNIX socket 完成（/var/run/docker.sock）。

Cheat Sheet

Image

列出本地镜像

$ docker image ls # 列出本地镜像
$ docker images # 两条命令等效

可以使用--filter来过滤docker image ls返回的镜像列表：

dangling：true/false，是否为悬虚镜像。
before：<image name or id>，返回在其之前被创建的全部镜像
since：<image name or id>，返回在其之后被创建的全部镜像
label：标注（label）的名称或值。标注在Dockerfile通过 LABEL 指定，但是docker image ls不显示。
reference：用正则表达式对镜像名称和标签过滤

Example：

$ docker image ls --filter dangling=true
$ docker image ls -f before=alpine # -f 是 --filter 的简写
$ docker image ls -f reference="*:latest"

使用--format可以对输出内容镜像格式化输出：

$ docker image ls --format "{{.Size}}" # 只输出 SIZE

如果只是想要IMAGE ID的话，可以直接用-q，这个和删除命令结合可以快速删除所有镜像：

$ docker image ls -q # 只输出 IMAGE ID
$ docker image rm $(docker image ls -q) # 删除所有镜像

拉取镜像

$ docker pull ubuntu:latest # 拉取镜像
$ docker image pull <repository>:<tag> # 加上 -a 表示拉取所有标签

如果没有指定标签，则默认为 latest
latest 不保证这是仓库中最新的镜像。
从非官方仓库中拉取镜像需要在仓库名称加上 Docker Hub的用户名或组织名，如docker image pull wuxiaobai24/demo:v2
如果希望在第三方镜像仓库服务获取镜像，则需要在仓库名称前面加上第三方镜像仓库服务的 DNS 名称，如docker image pull grc.io/wuxiaobai24/demo:v2

我们可以用docker search来对 Docker Hug 进行搜索：

$ docker search alpine

搜索时可以使用过滤器：
- is-official：true/false，是否为官方镜像
- is-automated:true/false，是否为自动创建的镜像
搜索结果默认返回 25 个结果，可以用--limit来指定个数

删除镜像

$ docker image rm 0267 # 通过镜像ID来删除 docker 镜像
$ docker image rm $(docker image ls -q) # 删除所有镜像
$ docker image rm -f 0267 # -f mean --force

一个Docker镜像是由多个镜像层组成的，如果一个在删除某个镜像时，其中某个镜像层还被本地某个镜像引用的话，那么该镜像层不会被删除。
如果某个镜像存在正在运行的容器的话，删除操作不会被允许
可以用docker image prune来移除所有悬挂镜像。
- 悬虚镜像：没有标签的镜像，<none>:<none>。通常是因为构建了一个新的镜像并为该镜像打了一个已经存在的标签。这时候旧镜像就会变成悬虚镜像。

构造镜像

# Dockerfile 在当前目录（注意最后面那个`.`）， -t 表示设置镜像
$ docker image build -t web:latest .
$ docker image tag web:1.0 wuxiaobai24/web:latest # 给镜像重新打标签
$ docker image build --squash # 将多个镜像层合并成一层

Container

启动容器

$ docker container run <image> <app> # 基础格式
$ docker container run -it <image> <app> # -it 表示启动一个交互性程序，并将当前终端连接到容器的Shell终端上
$ docker container run -d <image> <app> # -d 表示以后台的方式启动容器
$ docker container run -d --name <container-name> <image> <app> # --name 给容器命名
$ docker container run -d -p <host-port>:<container-port> <image> # -p 配置端口转发，不指定 <app>的话会运行默认应用
$ docker container run -it 67fa /bin/bash # -it 表示以交互模式启动，并attach到tty上

在容器中可以用 Ctrl-PQ 来退出容器（同时保持容器继续运行）

在退出容器后可以用下面的命令来attach到已运行的容器：

$ docker container exec -it <container name or id> bash # 连接到在运行中的容器

列出镜像

$ docker container ls # 查看系统内处于运行状态的容器
$ docker ps # 同上
$ docker container ls --all # 查看系统内所有容器，包已经stop的。
$ docker container ls -a # 同上
$ docker container ls -q # 显示运行中容器的 id

停止/删除容器


$ docker container stop <container name or id> # 停止容器
$ docker container start <container id or name> # 再次启动该容器
$ docker container rm <container name or id> # 删除容器
$ docker container rm $(docker container ls -aq) -f # 快速删除所有容器

Others

查看 Docker 相关信息：

$ docker system info

将用户加入到本地 Docker 组中

这样可以将sudo docker ...省略成docker ...。

$ usermod -aG docker <user>

查看 Image 信息

$ docker image inspect <image> # 显示关于 Image 的信息，可以用来看默认运行的应用

用自动机实现一个简易的正则表达式引擎

Wed, 08 Jul 2020 21:17:30 GMT

起因

这学期上了一门《计算机软件理论》的课，其实就是本科的《自动机与形式语言》的翻版。由于疫情的缘故，这门课从原来的笔试改成了大作业的形式，其中有一道题目就是让我们将正则表达式转换成自动机，并用自动机来判断输入的文本时候满足正则表达式的描述。写完之后觉得蛮好玩的，就决定写个博客记录一下。

BTW，这里只是实现了一个非常简易的版本。

理论

在这门课中证明了正则表达式与自动机的对应关系，可以通过递归构造的方式先将一个正则表达式转换为子表达式，然后构建子表达式对应的子自动机（或者说 $\epsilon-NFA$ )，并通过一定的规则将这些子自动机连接成一个大的自动机。

不妨假设正则表达式中只有ab，a|b，a*三种运算（当然这里支持用括号嵌套）,不妨假设，a 和 b 对应自动机分别为：FA1 和 FA2，那么我们这三种运算所对应的链接方式分别为:

利用上面的规则，我们就可以将正则表达式转换为一个 $\epsilon-NFA$ ，然后当读入输入的时候，我们就默认 $\epsilon-NFA$ 对输入进行判断，当然我们也可以先将 $\epsilon-NFA$ 转换为 $DFA$ ，在对输入进行判断。

实现

为了方便，我们先将连接操作ab转换为a-b：

ab转换为a-b的规则可以通过找规律得到，即当左边的字符不为(或|，且右边的字符不为*、)或|时，两个字符之间就是连接关系，应该加入-符号：

def addConcatOp(s):
    if len(s) == 0:
        return s
    output = s[0]
    for i in range(len(s) - 1):
        L, R = s[i], s[i+1]
        if L not in '(|' and R not in '*)|':
            output += '-'
        output += R
    return output

然后将正则表达式从中缀表示转换为后缀表示，这样在后面解析的时候会方便许，中缀转后缀只需要利用一个栈来记录操作即可搞定：

def infix2postfix(s):
    output = ''
    st = []
    for c in s:
        if c in '(|-':
            st.append(c)
        elif c == ')':
            assert(len(st) != 0)
            assert(st[-1] == '(')
            st.pop()
        else:
            output += c
            # print(st, c)
            if len(st) != 0 and st[-1] != '(':
                output += st[-1]
                st.pop()
    while len(st) != 0:
        output += st[-1]
        st.pop()
    return output

在实现正则表达式之前，我们先定义一下 State 和 NFA 的数据结构，我们在State中存储一个isEnd的 Flag 来记录是否为接收状态以及一个字典来记录跳转，为了实现空跳转，我们用一个特殊的字符串Epsilon来表示 $\epsilon$ ：

Epsilon = 'Epsilon'

class State:

    def __init__(self, isEnd = False):
        self.isEnd = isEnd
        self.next = {}

    def addNext(self, token, to):
        # print(self.next, token, to)
        if token not in self.next: 
            self.next[token] = []
        self.next[token].append(to)

NFA 的数据结构只需要记住一个开始状态和接收状态即可，记住开始状态就可以遍历出整个 NFA，而记住接收状态是为了后面连接 NFA 时方便操作，而之所以只有一个接收状态是因为如果有多个接收状态，可以通过空跳转将其转换成只有一个接收状态。因此其数据结构为：

class NFA:
    def __init__(self, start, end):
        self.start = start
        self.end= end

然后是就是正则表达式转换为 NFA 的过程，我们逐字符读取已经转成后缀表示的正则表达式：

如果读到一个字符，我们就构造一个start -- token --> end形式的 NFA，并将其压入栈中。
如果读到一个-或者|，我们就从栈中弹出两个 NFA，并按照上面提到的规则重新构造一个NFA，并将其压入栈中。
如果读到一个*，我们就从栈中弹出一个 NFA，并按照上面提到的规则构造一个NFA，并将其压入栈中。

最后在栈中留下来的 NFA 就是正则表达式对应的 NFA：

def re2nfa(pattern):
    st = []
    for c in pattern:
        if c == '|':
            assert(len(st) >= 2)
            nfa1, nfa2 = st[-2], st[-1]
            st.pop(), st.pop()
            st.append(NFA.OR(nfa1, nfa2))
        elif c == '-':
            assert(len(st) >= 2)
            nfa1, nfa2 = st[-2], st[-1]
            st.pop(), st.pop()
            st.append(NFA.CONCAT(nfa1, nfa2))
        elif c == '*':
            assert(len(st) >= 1)
            nfa = st[-1]
            st.pop()
            st.append(NFA.CLOSURE(nfa))
        else:
            st.append(NFA.BASIC(c))
    return st[-1]

其中，构造 NFA 的过程被封装到NFA类的静态方法中去了，其实现为：

class NFA:
    def __init__(self, start, end):
        self.start = start
        self.end= end
    
    @staticmethod
    def _initState():
        return State(), State(True)

    @staticmethod
    def BASIC(token):
        start, end = NFA._initState()
        start.addNext(token, end) # S -- token --> E
        return NFA(start, end)

    @staticmethod
    def OR(nfa1, nfa2):
        start, end = NFA._initState()
        
        start.addNext(Epsilon, nfa1.start) # S -- e --> NFA1
        start.addNext(Epsilon, nfa2.start) # S -- e --> NFA2
        nfa1.end.addNext(Epsilon, end)  # NFA1 -- e --> E
        nfa2.end.addNext(Epsilon, end)  # NFA2 -- e --> E

        nfa1.end.isEnd, nfa2.end.isEnd = False, False
        return NFA(start, end)
    
    @staticmethod
    def CONCAT(nfa1, nfa2):
        start, end = NFA._initState()
        
        start.addNext(Epsilon, nfa1.start) # E -- e --> NFA1
        nfa1.end.addNext(Epsilon, nfa2.start) # NFA1 -- e --> NFA2
        nfa2.end.addNext(Epsilon, end) # NFA2 -- e --> NFA1

        nfa1.end.isEnd = False
        nfa2.end.isEnd = False

        return NFA(start, end)

    @staticmethod
    def CLOSURE(nfa):
        start, end = NFA._initState()
        start.addNext(Epsilon,nfa.start) # S -- e --> NFA
        nfa.end.addNext(Epsilon,end) # NFA -- e --> NFA
        end.addNext(Epsilon, start) # E -- e --> S

        nfa.end.isEnd = False
        return NFA(start, end)

由于我们的 NFA 是一个 $\epsilon-NFA$ ，所以在使用它时需要大量进行求空闭包的操作，所以我们在实现match操作前，我们需要实现求闭包的操作。我们用一个队列来实现空跳转的遍历，然后返回遍历到的状态：

def GetEpsilonClosure(states):
		visited = set(states)
		q = deque(states)
		while len(q):
				state = q.popleft()
				for item in state.next.get(Epsilon, []):
						if item not in visited:
								q.append(item)
								visited.add(item)
		return visited

然后是match操作，就是根据读入的字符串来决定如何跳转，遍历完字符串之后再判断一下当前状态是否存在接收状态即可：

def match(self, s):
    states = set([self.start])
    for c in s:
        # Epsilon ->
        states = NFA.GetEpsilonClosure(states)
        nextStates = set()
        for state in states:
            for nextState in state.next.get(c, []):
                nextStates.add(nextState)
        states = nextStates
        if len(states) == 0:
            break
    states = NFA.GetEpsilonClosure(states)
    for state in states:
        if state.isEnd:
            return True
    return False

上面实现的部分已经可以实现一个支持a*,a|b,ab三种操作的正则表达式了，为了支持更多的特性，我们可以可以通过转换的方式，将其他操作转化为上面三种操作，如{a,b,c}可以转换为(a|b|c)，a+可以转换为aa*等。

同时，我们还实现了将 NFA 使用graphviz绘制成图片和 $\epsilon-NFA$ 到 $DFA$ 的转换的功能。

因为使用了graphviz库，所以需要先安装对应的包：

pip install graphviz

绘制的过程其实就是用广度优先遍历去遍历所有状态，在遍历的时候给这些状态标好序，同时记录所有跳转，然后在用graphviz绘制即可：

def toGraph(self, state_prefix='State'):
    dot = Digraph(name='nfa', format="png")
    dot.attr(rankdir='LR')
    state2index = {}
    q = deque()
    q.append(self.start)
    g = []

    while len(q):
        state = q.popleft()
        if state in state2index:
            continue
        state2index[state] = state_prefix + str(len(state2index))
        index = state2index[state]
        dot.node(name = index, label=index, shape= 'doublecircle' if state.isEnd else 'circle')
        for token, states in state.next.items():
            for nextState in states:
                g.append((state, token, nextState))
                q.append(nextState)

    # output
    for start, token, end in g:
        startIndex, endIndex = state2index[start], state2index[end]
        print('{} -- {} --> {}'.format(startIndex, token, endIndex))
        dot.edge(startIndex, endIndex, label=token)

    dot.node(name='start', label='S', shape="plaintext")
    dot.edge('start', state2index[self.start])

    dot.render(filename='nfa', directory='./')
    return state2index

因为在实现 $\epsilon-NFA$ 到 $DFA$ 的转换时需要先知道字母表，所以我们同样用遍历的方式得到字母表，同时构造一个状态到序号的字典，先给 NFA 的状态标序可以帮助我们给后面构造 DFA 时判断两个状态集合是否相同提供便利：

def geneState2Index(self, state_prefix='State', alphabet_flag = False):
    state2index = {}
    alphabet = []
    q = deque()
    q.append(self.start)

    while len(q):
        state = q.popleft()
        if state in state2index:
            continue
        state2index[state] = state_prefix + str(len(state2index))
        index = state2index[state]
        for token, states in state.next.items():
            if alphabet_flag:
                alphabet.append(token)
            for nextState in states:
                q.append(nextState)
    if alphabet_flag:
        return state2index, set(alphabet)
    return state2index

NFA 转 DFA 的基本原理就是 NFA 中一个状态集合对应与 DFA 中的一个状态，所以我们刚才生成的状态到序号的字典来生成 DFA 的序号，其实就是简单拼接字符串，只不过拼接前先做一次排序，我们将其写成一个函数hashfun，利用hashfun就可以将其 NFA 的状态集合映射成 DFA 的序号。我们通过递归的方式来生成 DFA，从 NFA 开始状态为初始的状态集合（当然这里要先求个克林闭包），调用递归函数GeneNewState：

通过hashfun来生成 DFA 中的序号，如果这个序号对应的 DFA 状态已经存在了（被记录在一个全局的字典中），我们就直接返回该状态。
如果不存在，我们就生成一个新的 DFA 状态与该序号对应起来，这个状态是否为接收状态通过输入的状态集合中时候存在接收状态来判断；然后遍历字母表中的所有字符来确定输入了这个字符后，当前状态集合会跳转到的状态集合next_states（别忘记了求克林闭包），然后对next_states递归调用GeneNewState，并将返回的状态与当前状态连接起来即可

实现代码如下：

def toDFA(self):
    state2index, alphabet = self.geneState2Index('', alphabet_flag=True)
    alphabet.remove(Epsilon)
    # print(alphabet)
    index2state = {}
    def hashfunc(states):
        return '#'.join(sorted(set([state2index[state] for state in states])))

    def statesIsEnd(states):
        for state in states:
            if state.isEnd:
                return True
        return False
    
    def GeneNewState(states):
        index = hashfunc(states)
        if index not in index2state:
            isEnd = statesIsEnd(states)
            new_state = State(isEnd)
            index2state[index] = new_state
            for c in alphabet:
                next_states = [] 
                for i_state in states:
                    next_states += i_state.next.get(c, [])
                next_states = NFA.GetEpsilonClosure(set(next_states))
                next_index = hashfunc(next_states)
                next_state = GeneNewState(next_states)
                next_state = index2state[next_index]
                new_state.addNext(c, next_state)
        return index2state[index]

    states = NFA.GetEpsilonClosure([self.start])
    start = GeneNewState(states)
    return NFA(start, None)

2020 02 & 03 Reading

Thu, 02 Apr 2020 21:09:55 GMT

从2月7号开始，开始每天花一定的时间看书，想要养成读书的习惯，为了激励一下自己，所以在这里记录下 2、3 月份读的书。

2020-02

2月份读了10本书，大部分书都是在微信上看完的，当时应该有点刻意的让虚构和非虚构的数量相同，所以基本上是一本虚构、一本非虚构的。

《人生海海》

开始时间：2020-02-07
完成时间：2020-02-09
评分：★★★★☆

发现了一个本土的好作家——麦家

《牛奶可乐经济学》

开始时间：2020-02-11
完成时间：2020-02-17
评分：★★★☆☆

一开始看感觉还挺好玩的，但看到3分之一时就觉得有些无趣了，可能因为经济学本来就不是什么太有趣的东西吧。ps：有种看十万个为什么的感觉。

《白夜行》

开始时间：2020-02-17
完成时间：2020-02-20
评分：★★★★★

东野圭吾的书，果然没让我失望，“枪虾和虾虎鱼的故事”，强烈推荐。

《精进》

开始时间：2020-02-17
完成时间：2020-02-19
评分：★★★☆☆

知乎式“干货”。第2，3章的一些观点感觉还不错，但后面真的是越看越无趣。

《娱乐至死》

开始时间：2020-02-19
完成时间：2020-02-21
评分：★★★★★

“人们感到痛苦的不是他们用笑声代替了思考，而是他们不知道自己为什么笑以及为什么不再思考。”

值得多读几遍的书籍。

《美丽新世界》

开始时间：2020-02-21
完成时间：2020-02-28
评分：★★★★★

看这本书是因为看了《娱乐至死》，hhh，貌似我在高中就看过开头，然而当时并没有看下去。

《呼吸》

开始时间：2020-02-21
完成时间：2020-02-23
评分：★★★★☆

看起来像是一部作品集，我对这本书的期望值好像有点过高了，有几篇读起来和寓言故事的感觉。恩，像是《一千零一夜》的感觉。

《练习的心态》

开始时间：2020-02-23
完成时间：2020-02-26
评分：★★★☆☆

翻译真的是太烂了吧，有些句子读起来都拗口难懂，书中观点也呈现的不够清晰（也可能是翻译的锅），不过感觉书中有些想法还是不错的，感觉看得下去完全是因为有些观点引起了共鸣。

《月亮与六便士》

开始时间：2020-02-29
结束时间：2020-03-01
评分：★★★★☆

我看的那个版本似乎特别冷门，感觉之后可以找其他版本来看看。

2020-03

这个月读书比较随意，经常同时读好几本书（后来感觉这样不好就改掉了），没想到这样还是读了10本。同时，因为购入了kpw4，所以有一半的书是在 Kindle 上读完的，而且也开始养成了睡前读书的习惯，10点半洗澡，洗完澡就爬到床上去读一个小时的书。感觉这样的生活还是很惬意的，emmm，虽然4月份就不一定有这种好氛围了，哎，美好的假期似乎要结束了。

《如何高效学习》

开始时间：2020-03-02
结束时间：2020-03-04
评分：★★★★☆

我应该是第二遍读这本书了，看的时候不断地思考之前自己的做法，发现自己有段时间应该是在践行书中的一些观点的，但是后来似乎就没有有意识地去做这件事了。这也导致了自己有段时间也出现了死读书的情况，比如不思考地抄笔记，记录书中的观点什么的。

《动物农场》

开始时间：2020-03-03
结束时间：2020-03-04
评分：★★★★★

“目光从猪移到人，再从人移到猪，又重新从猪移到人，要分清哪张脸是猪的，哪张脸是人的，已经不可能了。”

看这本书最开始是因为想读这本书的原版，然而到现在都没开始（捂脸）。

《掌控习惯》

开始时间：2020-03-04
结束时间：2020-03-15
评分：★★★★☆

虽然看到后半部分就感觉有点无聊了，但是还是讲了许多关于习惯的技巧，比如想，将要养成的习惯挂在已经有的习惯后面等等。

《孤独小说家》

开始时间：2020-03-04
结束时间：2020-03-07
评分：★★★★☆

有点碎碎念的小说，看的时候感觉很平淡，但是莫名其妙看的进去。BTW，你要是说，这本书是耕平写的，我完全相信。

《82年生的金智英》

开始时间：2020-03-08
结束时间：2020-03-09
评分：★★★★☆

一本很快就能看完的书，晚上睡前看了一会，然后早上起来看了一会就看完。虽然写的是韩国的事情，但是把地点改成中国也完全不会有违和感。

《1984》

开始时间：2020-03-18
结束时间：2020-03-30

看完《娱乐至死》就已经决定要看的书了，一开始有点略微无聊，不过看到后面就还好。

《房思琪的初恋乐园》

开始时间：2020-03-09
结束时间：2020-03-13
评分：★★★★★

这个月让我印象最深刻的书，看这本书的这几天几乎陷进去了，那几天心情有点过于低落。这本书给人一种很奇怪的感觉，一开始看的时候会觉得作者的写作风格很奇怪，读到后半段的时候，会有种既厌恶又难以掩饰喜欢的感觉。

《微习惯》

开始时间：2020-03-13
结束时间：2020-03-31
评分：★★★★☆

很短的一本书，有种看博客集合的感觉，不过看完后，我也想试试“一个俯卧撑挑战”，hhh。

《无人生还》

开始时间：2020-03-20
结束时间：2020-03-21
评分：★★★★☆

士兵岛童谣杀人事件，估计是因为之前在其他地方看到过对这本书的模仿，所以看这本书的时候其实挺无感的。

《禅与摩托车维修艺术》

开始时间：2020-03-21
结束时间：2020-03-26
评分：★★★★☆

游记？哲学书？说实话有点没看懂，书中所说的“良质”是指“Good”吗？？

总结 & Flag

2 月份和 3 月份读的书都是和专业无关的，以后可以稍微增加一点专业相关的书籍。

接下来是下个月想读的书：

BTW, 想读 != 一定要读

Gitea + Drone CI/CD

Fri, 27 Mar 2020 20:38:51 GMT

最近想实践一下 DevOps，所以准备搭建一套代码托管和CI/CD 系统。

技术选型

代码托管

代码托管系统的选择其实并不多：

Gitea
Gogs
GitLab

由于 Gitlab 资源占用过大，所以可以直接去除（毕竟这个系统只有我一个人在用，而且只有一台1核2G的服务器）。

Gitea是脱胎于Gogs的，在Gogs上做了较多的扩展，而且迭代的也毕竟快。Gitea对现有的代码托管做了横向对比, 我们可以看出来Gitea几乎是最优选择。

Gitea有一个比较显著的缺点，它没有像Gitlab一样内置了CI/CD，所以我们必须搭另外一套CI/CD系统。

CI/CD

对现有的 CI/CD 进行了一下调研:

Jenkins
- 优点：最为流行，出现坑的容易找到解决方案
- 缺点：用 Java 编写，过于笨重
GitLab CI
- 优点：据说很好用
- 缺点：笨重
Drone
- 优点：轻量级，支持Gitea
- 缺点：生态不够丰富，文档差

在这里我们选择Drone作为CI/CD，主要原因当然是因为只有它轻量级啊。

Gitea

在安装Gitea和Drone时，我们都选择使用docker-compose来管理，因此需要先安装docker和docker-compose。

创建一个gitea文件夹，并在该文件夹下创建docker-compose.yml文件：

version: "2"

networks:
  gitea:
    external: false

services:
  server:
    image: gitea/gitea:1.11
    environment:
      - USER_UID=1000
      - USER_GID=1000
      - RUN_MODE=prod
      - SSH_PORT= 3022 #SSH端口
      - SSH_DOMAIN= #IP地址或URL
      - DISABLE_REGISTRATION=False #取消注册
    restart: always
    networks:
      - gitea
    volumes:
      - ./gitea:/data
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "3000:3000"
      - "3022:3022"

这里面需要注意的是，设置SSH_PORT和SSH_DOMAIN，这样 gitea 生成的 repo SSH 链接才是能直接使用的形式。

填写完后，直接docker-compose up -d开启服务即可，第一次登陆时，会跳出一个安装页面，可以设置所使用的数据库和管理员账号，同时要记得检查一下 SSH 端口和域名是否正确。

Drone

Drone的安装比Gitea复杂的多，同时需要先在Gitea中创建OAuth2应用程序：

打开Gitea的页面 -> 个人信息 -> 应用 -> 管理 OAuth2 应用程序

应用名称填什么都无所谓，但是重定向 URL 比较重要，要填 Drone服务的地址（虽然现在还没启动），比如说，你的 Drone 的 ip 地址为1.2.3.4，Drone端口的为8000，那么就可以填http://1.2.3.4:8000。

创建后会得到一个客户端ID和客户端密钥。这时，Gitea的设置就已经完成了。

为了让Drone Server和Drone Runer能够通过RPC连接，我们需要生成RPC密钥，可以在 shell 中使用该命令来生成随机数，用该随机数作为 RPC 的密钥

$ openssl rand -hex 16

上面的操作中可以得到：

客户端 ID
客户端密钥
RPC 密钥

创建一个drone文件夹并在其中创建一个docker-compose.yml文件：

version: "3.5"

networks:
  drone:
    name: drone_network

services: 
  drone-server:
    image: drone/drone:1
    ports:
      - 8000:80
      - 443:443
    networks:
      - drone
    volumes:
      - ./drone-data:/var/lib/drone
      - /var/run/docker.sock:/var/run/docker.sock
    restart: always
    environment: 
      - DRONE_GITEA_CLIENT_ID= # Gitea 客户端ID
      - DRONE_GITEA_CLIENT_SECRET= # Gitea 客户端密钥
      - DRONE_GITEA_SERVER= # Gitea URL 地址
      - DRONE_GITEA=true
      - DRONE_RPC_SECRET= # Drone RPC 密钥
      - DRONE_SERVER_HOST= # Drone URL,可以填域名或 ip:port
	  - DRONE_SERVER_PROTO=http # Drone 所使用的协议 http 或者 https
	  # 由于我的 Gitea 的设置是只允许登陆用户访问代码的，所以 Git 需要 Auth
      - DRONE_GIT_ALWAYS_AUTH=true
      - DRONE_GIT_USERNAME= # Gitea 用户名
      - DRONE_GIT_PASSWORD= # Gitea 密码
  drone-agent:
    image: drone/drone-runner-docker:1
    restart: always
    depends_on: 
      - drone-server
    networks:
      - drone
    volumes: 
      - /var/run/docker.sock:/var/run/docker.sock
    environment: 
      - DRONE_RPC_SECRET= # 这里的密钥要和 Server 一样
      - DRONE_RPC_PROTO=http
      - DRONE_RPC_HOST= # 和上面的 DRONE_SERVER_HOST

和Gitea同理，我们只需要在docker-compose up -d即可。

第一次打开 Drone 会先跳到 Gitea 进行验证。由于打开 Drone 会验证 Gitea 是否登陆，所以不用担心 Drone 的页面直接暴露到公网。

测试 Drone 和 Gitea

在 Gitea 中创建一个 repo
在 Drone 激活该 repo
创建公钥并加入到 gitea 中（这一步和 Github 类似）
将 repo clone 到本地
创建一个.drone.yml文件：
git commit and push

.drone.yml的样例如下：

kind: pipeline
type: docker
name: default

steps:
- name: greeting
  image: alpine
  commands:
  - echo hello
  - echo world

关于.drone.yml的信息可以查看官方文档。

之后估计也会写一篇 blog 对 Drone 的使用进行下总结。

Flutter 官方文档学习记录

Mon, 10 Feb 2020 19:39:54 GMT

编写第一个 Flutter 应用

Get Start

在 Flutter 中，几乎所有都是 widget，包括对齐 (alignment)、填充 (padding) 和布局 (layout)。
一个 widget 的主要工作是提供一个 build() 方法来描述如何根据其他较低级别的 widgets 来显示自己。
pubspec.yml文件管理 Flutter 应用的资源（assests），如图片或 package。
flutter pub get可以按照pubspec.yml安装包，BTW，在你一保存该文件时，vscode 会自动帮你执行该命令。
每次 MaterialApp（或者说组件）需要渲染时，或者在 Flutter inspector 中切换平台时 build 方法都会执行
Stateless Widgets是不可变的，即所有值都是final的
Stateful widgets 持有的状态可能在 widget 生命周期中发生变化，实现一个 stateful widget 至少需要两个类： 1）一个 StatefulWidget 类；2）一个 State 类，StatefulWidget 类本身是不变的，但是 State 类在 widget 生命周期中始终存在。
在 Dart 语言中使用下划线前缀标识符，会强制其变成私有。

Dart 开发语言概览

https://dart.cn/guides/language/language-tour

所有变量引用都是对象，每个对象都是一个类的实例，包括数字，函数和null。所有类都继承与 Object 类。所有变量的初始值都是null
Dart 是强类型语言，但是支持类型推断，并且可以用dynamic声明不确定的类型。
Dart中用以 _ 开头的标识符来标识私有。
建议通过var来声明局部变量而非指定其类型，如var i = 1;
final关键词修饰变量表示该变量只能被初始化一次，而const关键词修饰变量表示该变量是编译时常量。如果用const修改类中的变量，则必须为其加上static关键字，即static const。
可以将构造函数声明为 const，这种构造函数创建的对象是不可变的。
Dart 内置类型numbers,strings,booleans,lists,sets, maps, runes, symbols。

Flutter 安装记录

Mon, 10 Feb 2020 17:42:33 GMT

起因

最近想开始写日记了，但是找了一圈发现好像好用又安全的App几乎没有，主要是怕不安全。很多App是不支持导出什么的,而且存在别人的服务器上总感觉不好，要是公司倒闭了，我们的日记岂不是全没有，就算有导出功能，要迁移到另一个App上好像也是很麻烦的样子。而那些支持保存到Webdev上基本是不加密的，也很危险啊。Whatever，我现在有点想做一个移动端的东西，也就是日记本。

调研了一圈，移动端基本上有三种选择：

Java + Android
React Native
Flutter

三者之中，Java + Android 应该是最稳的，毕竟有点 Java 基础；React Native 应该是最理想的，因为很容易就迁移到网页上啊；Flutter 应该算是一个比较激进的做法了，比较新技术，有许多坑，不过现在应该还是算挺多人在用了。作为一个有志向的开发者，踩坑才是最好玩的事情啊。whatever，我觉得用 Flutter 来实现这个东西了。BTW，写这篇东西一方面是为了记录安装中遇到的坑，另一方面也是立Flag（捂脸）。

安装 Flutter

我使用的环境是 Manjaro Linux，所以可以不按照官网上的方法下载包然后安装，直接：

sudo pacman -S flutter

安装完后显示下面这个东西，只需要按照他这里说明的进行一些配置即可。有一点要注意的是，这些命令全部都需要 root 权限，即在命令前面加 sudo 即可。

基本上就安装成功了，可以按照flutter.cn中给出的安装教程一步步走即可。

国情带来的坑

在第一次运行flutter doctor之前记得把镜像源配置好，这里可以参考：

export FLUTTER_STORAGE_BASE_URL=https://mirrors.tuna.tsinghua.edu.cn/flutter
export PUB_HOSTED_URL=https://mirrors.tuna.tsinghua.edu.cn/dart-pub

然后Gradle也有一个镜像源需要配置：

一个是项目中android/gradle/build.gradle:

buildscript {
    ext.kotlin_version = '1.3.50'
    repositories {
        // google()
        // jcenter()
        maven { url 'https://maven.aliyun.com/repository/google' }
        maven { url 'https://maven.aliyun.com/repository/jcenter' }
        maven { url 'http://maven.aliyun.com/nexus/content/groups/public' }

    }

    dependencies {
        classpath 'com.android.tools.build:gradle:3.5.0'
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    }
}

allprojects {
    repositories {
        // google()
        // jcenter()
        maven { url 'https://maven.aliyun.com/repository/google' }
        maven { url 'https://maven.aliyun.com/repository/jcenter' }
        maven { url 'http://maven.aliyun.com/nexus/content/groups/public' }
    }
}

还是有/opt/flutter/packags/flutter_tools/gradle/flutter.gradle

buildscript {
    repositories {
        // google()
        // jcenter()
        
        maven { url 'https://plugins.gradle.org/m2/' }
        maven { url 'http://maven.aliyun.com/nexus/content/repositories/google' }
        maven { url 'http://maven.aliyun.com/nexus/content/groups/public/' }
        maven { url 'http://maven.aliyun.com/nexus/content/repositories/jcenter'}
    }

Chromebook 体验

Mon, 07 Oct 2019 19:50:44 GMT

剁手的心路历程

缘起

大概是暑假的时候，刷手机的时候刷到了和Chromebook有点关系的东西吧，好像是在v2ex上看到了FydeOS的软文。随后就去了解了一下这个操作系统，从描述上来看，轻办公的话，好像还是不错的。讲道理，当时就挺心动了，好奇心驱使着我下载了FydeOS的ISO，并在U盘上体验了一番，感觉略卡，顿时就没有了兴趣，而且他们家推的那款电脑好像看起来很廉价，2k的价格为啥我不去买iPad呢？因为当时刚发布没多久好像没看到几个评测，所以慢慢就对其失去了想法，但是关于Chromebook的种子已经埋在了我心里。

重逢

开学没多久就到了中秋，因为是新生，所以入学那几天都是不用上课的，但是也上了一天（刚好周四课贼多），所以感觉在上那些无聊的课程时如果能有个iPad或轻薄本的话应该会挺方便的。

大概是中秋假期的某个晚上，刷手机时又刷到了和Chromebook有关的东西吧，买一台Chromebook的想法又从我心中浮起。当时刚好比较闲，在Chromebook吧上看各位老哥关于Chromebook的分享和评测，并跑去下来一个CloudReady的镜像在虚拟机上玩耍了一下。虽然说是因为比较闲才去干这些的，但是其实当时应该是算在评估Chromebook对自己是否适合了。回想一下当时得出的结果应该是这样的：

Chromebook大多数比较轻薄，续航较好，很适合做二奶机（自己的笔记本太大太重了）
买对的机器的话，可以很方便的开一个Linux的虚拟机（对自己来说有一定的生产力，本人常年使用Linux）
很多情况需要梯子（反正我的梯子也没断过）

从上面来看，这东西应该是挺适合我的。因为贴吧有位老哥对三星那款Chromebook Plus做了评测，而且本人有点颜值党，所以对三星这款还是比较满意的。

剁手

由于Chromebook没有在国内发行，所以淘宝和京东什么的是搜不到什么东西的，想要买Chromebook大概就只有几种途径：

海淘
肉身翻出去买（因为在深圳，所以去香港澳门买东西还是比较方便的）
闲鱼收二手

恩，因为价格的原因，所以我还是选择了最轻松方便的闲鱼。在多次翻阅和比较后，我发现了一个比Chromebook Plus更好的选择，那就是Chromebook Plus v2。之所以说他是更好的选择，最主要是因为当时有位老哥给出来1k4的价格（因为机器A面有个小坑和两条划痕所以才那么低的），而且这款是支持电信LTE的。剁手嘛，总是会有点冲动的，在看到这个价格后没多久，我就和那位老哥联系了一下，并拍下了这款。

Chromebook Plus V2 体验

硬件篇

因为不是特别懂这块的东西，所以就不班门弄斧了，这里之见见主观的想法：

键盘不算好，应该是低于笔记本的平均水平的，但是也不差，起码比MacBook的好（前几天刚好去体检店玩了一下，没有回弹的键盘实在是太难受了），同时键盘和普通的有点区别，首先没有Win键（这可以理解，毕竟本来就不打算让你装window嘛），其次caps lock键被换成了搜索键（搞得我现在用其他笔记本的时候老是按caps lock），最后他的F1-F12全部被替换成了一些功能键（好像问题不大，有些情况下好像还是会映射成对于F键的，比如开启开发者模式后，Ctrl+Shift+F打开另一个tty，这和Linux的传统是一样的）。
触控板挺好用的，用来那么久了，基本没想过要插一个鼠标。
4G内存+32GB SSD实在是有点不够用啊，内存占有常年是满的，32GB装完系统和必要的东西后，基本上10GB都不一定有。
屏幕相当不错，触摸屏也挺好的。
摄像头没怎么体验过，两个摄像头好像都挺烂的，不过一般人也不会在笔记本上用到摄像头。
S Pen配合一些软件用起来相当好，就是笔有点小，拿久了会不舒服。
Chromebook Plus V2相比与Chromebook Plus多了一个LTE版本，亲测，可以插电信卡（应该是只能插电信卡），而且网络效果还行，没事不会断掉（断掉就重启），个人认为对于Chromebook这种上网本来说，随时随地的网络还是比较重要的，这也是我买V2版本的原因。

软件篇

这部分是这篇文章的重点（写这篇文章的主要想法就是想记录下Chromebook上一些好用的应用），主要分为3个部分来展开，这三个部分是分别从Chrome，Linux，Android三个平台来介绍各个软件。

Chrome

Chrome主要是介绍一些插件和应用。

Proxy SwitchyOmega：搭梯子时用到的
Adblock Plus：广告拦截
Evernote Web Clipper: 其实我已经弃用Evernote挺久的了，但是在Chromebook上Evernote的确是一个挺好的选择（主要是他安卓上优化的好，后面会提）
OneTab：一键把所有打开的Tab收起来，在Chromebook这种小内存的机子上，这东西太有用了
Vimium：在浏览器上使用vim快捷键，喜欢vim的和键盘党可以试一下，不适合大部分人
All-in-One Messenger：用来打开网页版的微信还是不错的选择，但在Chromebook上用微信的次数不多，不确定有没有更好的选择
Cog：用来看Chromebook的硬件信息的，感觉还可以，主要是能看到内存和CPU占用（Chromebook自带的任务管理器看不了，不过最近发现Ctrl + Alt + T打开crosh，里面自带了top命令，会用的人可以考虑用top）
Google Keep：ChromeOS自带，和S Pen配合还是挺好用的，但是同步需要梯子。
Minimalist Markdown Editor：很小巧的Markdown编辑器，这篇文章就是在这上面编辑的（当初码字还是很舒服的）
Secure Shell App：SSH Client，大半的生产力在上面，不过对中文的兼容不是很好，主要体现在输入中文时，显示会乱掉（估计是没有实时刷新），但是现在还没有找到更好的选择。同时他还可以安装SFTP到文件管理器上，感觉还算挺好用的
TeamViewer：TeamViewer是我见过全平台做的最好的一款产品了，虽然不常用，但是总是会有需要它的时候。
Text：自带的文本编辑器，编辑一下简单的文本文件（比如V2ray的配置文件）还是挺好用的。
Code Pad Text Editor: 代码编辑器，写这篇文章期间发现的，第一感觉还可以
~~马克飞象：用来做Markdown编辑器还是挺好的，足够好看，而且能够同步到印象笔记中，但是他要收费，所以最后还是弃了~~
Firefox Send：传一些中小文件用的，速度上还不错，但是有点比较麻烦的就是它不是通过特殊的PIN码来分享，而是URL。把一个URL传到另一个机器上和传一个文件到另一个机器上的麻烦程度其实是一样的，个人认为这是它最大的缺点。不过我后面会有解决（妥协）办法。
Pushbullet：一个多平台的App，可以比较方便的传输信息，文件（传文件和图片什么的其实很慢），这就是用来解决Firefox Send需要把URL传到另一个机器上的方法。

Linux

这部分只是简单介绍一下Chromebook上三个不同的Linux环境以及对它们的一些评价吧。

ChromeOS
众所周知，ChromeOS其实是一个Linux的发行版，所以在crosh输入shell其实是可以进入一个Linux环境的，但是ChromeOS的确不像其他常用的Linux发行版，他的终端支持的东西太少了，以至于很多东西想要安装上去其实很困难，例如如果你想要安装v2ray的话，通过go.sh其实是安装不上去的（反正我没成功）。同时，这个环境好像会因为ChromeOS的升级而被破换掉（亲身经历过，但不确定是不是运气刚好比较差）。因此，个人是不建议在这个环境安装太多东西的，不过还是有人弄出来一个ChromeOS的包管理器（chromebrew)，梯子好的话，安装起来并不困难，但是感觉没什么太大用处，我机子上只是用它安装了V2ray而已。
Crostini
这个东西是现在官方在推的，弄起来比较方便，在设置里面开启Linux终端，用起来还是比较方便的。这东西就是在ChromeOS上起了一个Linux的虚拟机，装的是Debian系统（有需要是可以换成其他系统的，在Reddit上有帖子介绍如何在把Debian换成Arch Linux），如果只是想要个命令行来跑一些小程序，用这个还是不错的，debian虽然装东西不如Arch那么方便，但是生态还是不错的，大部分Linux的软件都会有deb包。同时这个东西还有一点比较好的就是在这里面装GUI软件的话，其实可以很方便的在ChromeOS上打开（有点像VirtualBox的无缝模式），不过这样打开的软件是没法使用ChromeOS的输入法的，需要在debian上安装中文环境和输入法（这个网上介绍挺多的，不细讲）。BTW，由于屏幕是高分屏，然后Linux对其支持不太好，所以字体会显示的很小（有低分辨率模式，不过建议不要用，太糊了）

Crouton
没搞懂这东西的原理，简单介绍一下他的效果吧。看起来也像是开了一个Linux虚拟机的样子，安装时可以选择不同的发行版（不过选择不多，基本都是debian系的，比如Ubuntu，Kail），同时可以选择安装不同的桌面（比如Unity，xfce，KDE）。一般情况下打开后切换到装好的Linux系统的桌面上，然后你就可以使用这个Linux啦，就像在虚拟机里面开全屏模式一样，可以用Ctrl + Alt + ->和Ctrl + Alt + <-在ChromeOS和Linux之间切换。这东西和Crostini一样也需要自己安装中文环境和输入法。要切来切去肯定比较麻烦，但是它还有个叫xiwi的东西可以实现在ChromeOS上打开LinuxGUI应用，不过体验没有Crostini好，也一样会有高分屏的问题。还有一点比较重要的就是，Crouton安装起来比较麻烦，大部分包可以用镜像很快的下载下来，但是有个包没办法。个人的解决方法就是先直接用镜像安装，失败后再加http代理。

说实话，ChromeOS对Linux的支持是我最不满意的一部分，无论那种方式都有很多坑，而且有些好像没法解决（起码我现在还没有解决办法）。我现在的情况是，在ChromeOS上只使用Chromebrew安装v2ray，然后开发用Crostini。对于Crouton，我是直接弃掉了。不过Crostini中文上的确支持不好，他的终端App和Secure Shell App采用的估计是同一套代码，所以中文输入时一样会乱掉。不知道什么原因，在Crostini上使用vscode实在是太卡了，卡成PPT的那种。

Android

个人觉得，ChromeOS蹭Android的应用的确满足了一部分人的刚需，Android上的一部分应用在Chromebook表现的非常好，当然也有坑点，但是相对于Linux那部分，个人还是比较满意Android的表现的。

MS Office 三件套：Word和ppt应该对大部分人来说是无法避免的东西。不过有点不好的就是，这个东西如果没有Office 365账号的话，是只能看，不能修改的。（hhh，我有学生账号）如果不想订阅Office 365的话，可以考虑下WPS，但是我感觉没有微软出的好用。BTW，大部分Android应用在用键盘输入的时候，输入法的提示栏会跑到左上方去，所以会很难受。
OneDrive：同步神器（才不是因为有1TB容量我才用它的呢）
Squid：手写神器，试了很多款，就这个好用点，做做简单的笔记，免费版其实已经够用了。其实收费版好像也就导入PDF有点吸引力，不过这东西不支持PDF的书签，能导入PDF好像也没太大作用
Xodo：PDF神器，手写支持的很好（就是有时候有点卡）
Evernote：点名表扬一下，这个可能是对Chromebook支持最好的了，他会把输入法的提示栏拉到当前输入的位置（虽然会闪一下，但是相比其他的好很多了）

总结

总的来说，Chromebook作为一个二奶机，还是很不错的选择，不贵的价格（特指二手的），足够好的屏幕和续航。虽然软件应用上还做的不够，但是这在一些轻办公环境下已经相当不错了。

Use Travis CI

Tue, 20 Aug 2019 00:30:27 GMT

今天简单使用了一下Travis CI。

起因

因为搭建Django-blog时，每次更新一次代码，就需要手动登陆到服务器上进行一系列操作来重启服务，感觉过于麻烦且容易出错，因此想使用 CI/CD 工具来自动化这一过程。

所以这里就简单了解了一下 CI/CD，并尝试使用 Travis CI 来实现 Hexo 的自动化部署。

但考虑到 Travis CI 是一个 SaaS 服务，需要开发服务器的权限来完成部署，所以后面应该会先将Django-blog的部署方式转换成Docker的方式，然后在搭建Drone或Jenkins来完成 CI/CD

CI/CD

CI(Continuous Integration)即持续集成，个人理解是在提交代码后进行一些了测试来确保代码的正确性，保证每个开发者每次提交都会进行测试。
CD(Continuous Deploy)即自动部署，个人理解是在完成了测试后将代码自动化的部署到服务器上，这样就不需要开发者或运维来手动进行代码拉取，设置配置，重启服务等操作了，而是将其自动化。这个东西其实就是我想要的

Travis CI

要使用Travis CI来完成自动化部署hexo可以分为以下几个步骤：

在Travis CI网站上将 repo 加入构建
在Github生成Github Access Token并将其加入到Travis CI的环境变量中，这里使用的变量名是GITHUB_TOKEN
在repo上添加一个Travis CI的配置文件：

下面是.travis.yml配置文件

langaue: node_js
node_js: stable

branches:
    only:
        - save

before_install:
    - npm install -g hexo-cli
    - git clone https://github.com/smduan/next.git themes/next

install:
    - npm install
    - npm install hexo-deployer-git --save
    
script:
    - mv _next_config.yml themes/next/_config.yml
    - hexo clean
    - hexo generate

after_script:
    - git config user.name "wuxiaobai24"
    - git config user.email "wuxiaobai24@foxmail.com"
    - sed -i "s/GITHUB_TOKEN/${GITHUB_TOKEN}/g" ./_config.yml
    - hexo deploy

记一次Hexo迁移

Thu, 14 Feb 2019 09:08:44 GMT

很久没有写过Blog了, 而且也把系统换成了Manjaro, 所以又要再配置一次Hexo的环境等等, 为了下次迁移的时候, 能更快的搞定, 所以记录一下这次迁移的过程.

获取源文件

Hexo如果需要迁移的话, 只需要保留以下几个文件即可:

_config.yml
theme/
source/
scaffold/
package.json
.gitignore

因为之前已经迁移过一次了, 所以我的源文件都已经保存在github上了, 在wuxiaobai24.github.io起了一个save分支来保存文件.

所以获取源文件, 我只需要:

$ git clone git@github.com:wuxiaobai24/wuxiaobai24.github.io.git

安装Hexo

这一步网上大多教程都写的很清楚了, 这里简略提一下, 主要是以下几个步骤:

安装npm
用npm安装hexo
hexo init blog
把上面提到的源文件全部拷贝到blog文件夹中

注意:这里的blog文件最好放在wuxiaobai24.github.io目录下, 这样利用backups.sh可以很快的把源文件拷贝到blog文件夹中, 但是记得把backups.sh里面最后三行关于git的删去或注释掉

安装依赖

首先先把主题安装下来先, 之前因为忘记了这个, 导致hexo generate失败
```
$ git clone git@github.com:litten/hexo-theme-yilia.git themes/yilia
```
npm install
检测是否成功
```
$ hexo g
$ hexo s
```

构建快速的写作环境

将blog移到任何你想要放的位置, 然后把之前的wuxiaobai24.github.io文件夹删去
在blog目录下, git clone git@github.com:wuxiaobai24/wuxiaobai24.github.io.git
在vscode中安装vscode-hexo插件

主要的工作流为:

vscode中> hexo new生成新的文章
写文章, 并> hexo generate
vscode中> hexo deplot部署
最后在命令行下切换到blog/wuxiaobai24.github.io中, 执行backups.sh备份源文件.

PS: 个人建议把主题的config.yml也备份一下.

k近邻算法

Tue, 13 Feb 2018 22:21:27 GMT

刚看了有关kNN的东西，总结一下：

kNN算法（k-近邻算法）是一种可用于分类和回归的非参数统计方法。

分类算法：最近的k个邻居进行投票得到类别
回归算法：最近的k个邻居的平均数

这里只讨论分类算法。

先给个直观的理解，比如现在我们要判断一个人是男生还是女生，我们只考虑身高、体重这两个特征。显然如何两个人的身高体重越相近，那么他们的性别就越相近。kNN就是基于这个直观的想法来做的，如果我们要判断x是什么类别，我们就在train data中找出与x最相邻的k个数据，然后通过投票机制来觉得最后的分类。

这里我们就需要定义距离了：

简单的就用欧几里得距离（即L2距离） $\sqrt((x_1 - y_1)^2 + ... + (x_2 - y_2)^2)$

给出demo代码（参考机器学习实战）：

def classify0(inX, dataSet, labels, k):
    dataSetSize = dataSet.shape[0]
    # 欧式距离计算
    diffMat = np.tile(inX, (dataSetSize,1)) - dataSet
    sqDiffMat = diffMat**2
    sqDistance = sqDiffMat.sum(axis=1)
    distances = sqDistance**0.5
    #找出前k个距离最小的sample
    sortedDistIndicies = distances.argsort() # 这里返回的是indicies
    classCount = {}
    for i in range(k):
        voteIlabel = labels[sortedDistIndicies[i]]
        classCount[voteIlabel] = classCount.get(voteIlabel, 0) + 1
    sortedClassCount = sorted(classCount.items(), 
                              key=operator.itemgetter(1), reverse=True)
    return sortedClassCount[0][0]

杂记-2017-11-26

Sun, 26 Nov 2017 14:40:57 GMT

2017-11-26

悠闲的下午（其实只是不想写作业，不想背单词）我觉得写一篇blog来总结一下，毕竟已经过去了大半个学期。

这学期课很多，收获也很多。

从9月份的某一天开始，每天刷LeetCode,每天写Blog,每天背单词。

说实话，习惯的力量真的很强大，其实每天刷道题这种想法早在上学期就有了，但是没错做几天就放弃了，最可怕的是一放弃，再次拿起来的时候就是下一次开始了。

不知道是不是因为这次每天都会写blog来记录刷题的过程，所以一直有个激励，虽然说有时候会因为做题而花很多时间（而且我的课又多），有时候也会因为没有时间而不得不找一道水题来做，不过即使是水题，换成暑假的我估计也做不出来，而且像dp的问题，之前是怎么都想不出来的，现在也慢慢的有了思路。

这种解决问题能力的提升算得上是这学期最大的收获了吧！

还有一些其他的，比如说上了一门大四的课（虽然个人感觉难度并没有大三的某些课难），进入冯老师的实验室做ML,虽然我什么都不会，恩，一点一点的学吧。

说了那么多好的事情，总要反省一下：

至今没有养成好好看书的好习惯（好像这学期忙到课本都没好好看了）
Machine Learning 还菜的要死，虽然现在师兄师姐们不嫌弃（不知道是不是真的不嫌弃），但是还是要好好赶上去啊
一直没能好好锻炼身体，希望身体不要虚下去（这种时候一生病就惨咯）

恩，以后每天晚上都要去自习室学习Machine Learning的东西，每天都要把学到的东西总结一下。（等下就总结之前学的东西）

恍恍惚惚的好像大三又过去了一半，虽然已经决定读研了，但是感觉还是看不清未来的样子，也不知道之后会遇到什么，成为什么，whaterver,慢慢的走下去吧。

VBO_and_VAO.md

Sun, 01 Oct 2017 16:37:52 GMT

最近在写计算机图形学的期中作业，写一个简易的俄罗斯方块。在写的过程中感觉好像之前暑假看的OpenGL的东西都忘光光了，所以还是及时的写写笔记吧！

顶点数组对象： Vertex Array Object,vao
顶点缓冲对象：Vertex Buffer Object,vbo

在敲代码的时候就觉得老是会搞混这两个概念，所以今天就总结一下。

先来段代码：

void init() {
    const int VERTICES_NUM = 3;
    vec3 vertices[VERTICES_NUM] = {
        {1.0,1.0,1.0},
        {0.0,1.0,0.0},
        {0.0,0.0,1.0}
    }

    GLuint vao[1];
    glGenVertexArrays(1,vao);
    glBindVertexArray(vao[0]);

    GLuint buffer;
    glGenBuffers(1,&buffer);
    glBindBuffer(GL_ARRAY_BUFFER, buffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices),vertices,CL_STATIC_DRAW);

    GLuint program = InitShader("vshader.glsl","fshader.glsl");
    glUseProgram(program);

    GLuint location = glGetAttribLocation(program,"vPosition");
    glEnableVertexAttribArray(location);
    glVertexAttribPointer(location,3,GL_FLOAT,GL_FALSE,0,BUFFER_OFFSET(0));

    glClearColor(1.0,1.0,1.0,1.0);
}

OpenGL里的对象都是通过id来管理的,有的地方叫做名字，或者说标识符，whatever,我们在这里统一用id。我们需要用glGen*模式的函数来获取未使用的id，这里的id可以想成是指针。

GLuint vao[1];                  //用来存放id的数组
glGenVertexArrays(1,vao);       //获取id，第一个参数是想要获取的个数
                                //第二个参数是存放这些id的数组

现在我们有了顶点数组对象的id了（换句话说，我们有了一个可以存放地址的指针），我们就需要真正的new一个对象出来。

glBindVertexArray(vao);

如果vao非0，并且是glGenVertexArrays()返回的，那么它创建一个新的顶点数组，并且==并且与其名称向关联==
如果vao已经被绑定到一个顶点数组对象中，那么这个函数的作用就是激活这个顶点数组。
如果为0，那么OpenGL将不再使用程序所分配的顶点数组对象，并且OpenGL状态将重设为顶点数组的默认状态。

第一个很好理解就是等价于new,第二个作用可以理解为根据id获取对象（对指针解引用），第三个作用是在每次对某个顶点数组对象操作完后对当前顶点数组对象进行解绑。

有new就会有delete

//void glDeleteVertexArray(GLsizei n,GLuint *arrays);
glDeleteVertexArray(1,vao);

我们还可以判断一个id是否是一个用glGenVertexArray()创建并且没有被删除的顶点数组对象的id:

GLboolean glIsVertexArray(GLuint array);

现在我们已经有一个vao了，但是我们好像还不知道vao有什么用，要回答这个问题，我们还需要一些其他的背景知识，所以这个问题放到后面再回答。

我们之所以需要VAO与VBO是因为我们想要把某些顶点数组发送给图像渲染pipeline，而pipleline需要接受一些Vertex Data,然后再进行一些变换或修改并渲染。

我们在定义了顶点数据之后，我们需要把他发送给顶点着色器，我们的顶点数据通常是放在GPU的内存中的，我们利用顶点缓冲对象(vertext buffer objects,vbo)进行管理

vbo也有相应的函数进行申请id，绑定等等，与vao类似：

void glGenBuffers(GLsizei n,GLuint *buffers);
void glBindBuffers(GLenum traget,GLuint buffer);
//target 的值可以为：
//      GL_ARRAY_BUFFER
//      GL_ELEMENT_ARRAY_BUFFER
//      ...
void glDeleteBuffers(GLsizei n,const GLuint *buffers);
GLboolean glIsBuffers(GLuint buffer);

在申请完id并绑定后，我们可以想GPU的内存发送数组:

void glBufferData(GLenum target,GLsizeiptr size,cons GLvoid *data,GLenum usage);
//target 与上面glBindBuffers的类似，
//usage 是设置读取和写入的方式
//      GL_STREAM_DRAM
//      GL_DYNAMICDRAM
//      ...

在我们向GPU内存中发送完数据后，我们可能需要告诉OpenGL如何解释我们的数据:

GLuint location = glGetAttribLocation(program,"vPosition");
glEnableVertexAttribArray(location);
glVertexAttribPointer(location,3,GL_FLOAT,GL_FALSE,0,BUFFER_OFFSET(0));

我们先要向着色器程序获取顶点属性的位置值，即GLuint location = glGetAttribLocation(program,"vPosition");我们应该可以在vshader.glsl中看到这样一句话in vec3 vPosition,他表示的是我们会给他一个类型为vec3的输入值，而glGetAttribLocation可以获取这个输入值的位置，这样我们才可以把我们的数据和这里的vPosition绑定起来。

glEnableVertexAttribArray(location)启用顶点属性（默认是禁用的)

而glVertexAttribPointer(location,3,GL_FLOAT,GL_FALSE,0,BUFFER_OFFSET(0));才是真正告诉OpenGL如何解释的函数。

他的参数解释分别为：

顶点属性的位置值
顶点属性大小，因为我们传入的是vec3,所以是3
数组类型
是否归一化
两个元素之间的偏移值
起始位置地址

有了这些东西，我们就可以绘制某个物体了，但是如果我们需要绘制多个物体呢，这时VAO的作用就出来了。

如果我们只使用VBO，我们可能需要重复的调用glVertexAttribPointer等。

我们可以通过VAO来管理这些琐碎的设置，一个VAO会存储以下内容：

glEnableVertexAttribArray和glDisableVertexAttribArray的调用。
通过glVertexAttribPointer设置的顶点属性配置。
通过glVertexAttribPointer调用与顶点属性关联的顶点缓冲对象。

有了vao后，我们只需要在每次绘制前glBindVertexArray(vao)即可。

约瑟夫环

Thu, 28 Sep 2017 19:12:00 GMT

今天上数据结构实验课，有道题是约瑟夫环，感觉挺好玩的，就拿出来总结一下（今天的LeetCode那道题真的是太Easy了）。

约瑟夫环是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。

这里是用双向循环链表实现的：

先是类的申明：

class JCircle;

class ListNode{
	int val;
	ListNode *next,*prior;
public:
	ListNode(int v,ListNode *n = NULL,ListNode *p = NULL)
		:val(v),next(n),prior(p){}
	friend class JCircle;
	int getVal(){ return val; }
	ListNode *getNext() { return next; }
	ListNode *getPrior() { return prior; }
};

class JCircle{
	ListNode *head;
	int size; 
public:
	JCircle(int n);
	~JCircle();
	void move(int k);	//向前移动k步 
	int del();			//删除head所指向的ListNode并返回其 val 
	int count(int k);	//报数 
	friend ostream &operator<<(ostream& out,JCircle &jc);
	bool empty() { return size == 0; }
};

类的实现：

JCircle::JCircle(int n)
	:head(NULL),size(0){
	if (n <= 0) return;
	size = n;
	head = new ListNode(1,NULL,NULL);
	head->next = head;
	head->prior = head;
	ListNode *p = head;
	for(int i = 2;i <= n;i++) {
		p->next = new ListNode(i,p->next);
		p->next->prior = p;
		p = p->next;
	}
	head->prior = p;
}

JCircle::~JCircle(){
	ListNode *p;
	while(size--){
		p = head;
		head = head->next;
		delete p;
	}
}

void JCircle::move(int k){
//	cout << "move";
	for(int i = 1;i < k;i++)
		head = head->next;
//	cout << " over\n";
}

int JCircle::del(){
	if (size == 2){
		ListNode *p = head;
		int ret = p->val;
		head = head->next;
		delete p;
		head->next = head->prior = head;
		size--; 
		return ret;
	}
	size--;
	head->next->prior = head->prior;
	head->prior->next = head->next;
	ListNode *p = head;
	int t = p->val;
	head = head->next;
	delete p;
	return t;
} 

int JCircle::count(int k){
	move(k);
//	cout << "count";
	return del();
}

ostream &operator<<(ostream& out,JCircle &jc){
	ListNode *p = jc.head;
	int n = jc.size;
	while(n--){
		out << p->getVal() << " ";
		p = p->getNext();
	}
	//out << "asdsad\n";
	return out;
}

测试：


int main() {
	
	//test
	//人数  开始位置  报数 
	int  n,  k,       m;
	while(cin >> n >> k >> m){
		JCircle jc(n);
		jc.move(k);
		//cout << jc << endl; 
		while(!jc.empty())
			cout << jc.count(m) << " ";
		cout << endl;
	}
	return 0;
}

想写这个的原因是，我写了很久，事实上回到宿舍写多一遍的时候，我也写了很久（现在是20:16:00），写了一个多小时了，感觉自己还不怎么熟悉一些的基本数据结构（虽然已经在之前的学院上过一次了，恩，相当水的一门课）。

重写一遍的感觉是，该掉的坑，我还是掉下去了，之前写了的一遍的效果就是，我能比较快的爬出来，而且不会纠结于选择双向链表还是单向链表。

写的过程中，也体会了一下双向链表的坑点：

size==2时，不能用常规方法delete掉自己。
加入size会减少一些常见的错误，一些实现敲起来也会简单点（唯一一个一开始就选择正确的点）。

感觉以后要多总结一些一些基本的数据结构，不然做算法题的时候，会很难找到适合的数据结构。

链表排序

Tue, 19 Sep 2017 13:45:00 GMT

今天中午在Lintcode上刷了一道题——链表排序

题目很短：

在 O(n log n) 时间复杂度和常数级的空间复杂度下给链表排序。

最近几天也在做排序算法的实验，所以看到这道题想刷一下。

从题目的要求我们可以大概的想出几种能达到要求的排序：

快速排序
归并排序

这里是归并排序的实现：

归并排序的大概思路是：

在待排序列中找到中间元素，将待排序列分成两个待排序列，分别对这两个待排序列递归地调用归并排序，当待排序列中元素只剩一个时，序列显然有序。

现在只需要将两个有序序列合并成一个有序序列。

实现：

class ListNode {
public:
  int val;
  ListNode* next;
  ListNode(int v):val(v),next(nullptr){}
}

ListNode * sortList(ListNode * head) {
  // write your code here
  if (!head || !head->next) return head;

  
  ListNode *fast,*slow;
  fast = slow = head;
  while(fast->next != nullptr && fast->next->next != nullptr) {
    fast = fast->next->next;
    slow = slow->next;
  }
  fast = slow;
  slow = slow->next;
  fast->next = nullptr;
  fast = sortList(head);
  slow = sortList(slow);
  return mergeList(fast,slow);

}

ListNode *mergeList(ListNode *l1,ListNode *l2){
  if (!l1) return l2;
  else if (!l2) return l1;

  ListNode* ret = new ListNode(0);
  ListNode*p = ret;
  while(l1 && l2) {
    if (l1->val > l2->val) {
      ret->next = l2;
      ret = ret->next;
      l2 = l2->next;
    } else {
      ret->next = l1;
      ret = ret->next;
      l1 = l1->next;
    }
  }
  ret->next = (l1)?l1:l2;
  ret = p->next;
  delete p;
  return ret;
}

这里的难点就是找出中间元素，将一个序列分成两个序列，这里的实现是快慢指针来实现的，即：

ListNode *fast,*slow;
fast = slow = head;
while(fast->next != nullptr && fast->next->next != nullptr) {
  fast = fast->next->next;
  slow = slow->next;
}

关于Blog

Mon, 18 Sep 2017 08:45:00 GMT

早在很久之前就想弄个Blog了，先后试过博客园，CSDN，简书这些现有的博客网站，恩，但是都没写几篇就把他忘记了。后来也想自己写一个，github中flask-study就是这样来的，然而死在了前端上。。。

昨天可能考完CCF CSP有点懵，就开始想搞个blog，一开始也想着继续学学前端，自己搭一个出来，后来想着这学期课有点多，不知道要多久才能搭完，就先用github pages＋hexo 搭一个用用先。

说到CCF CSP就有点心塞，连续两年都是没做完第三题（搞得我会第四题一样），最烦的是每年第三天都是写一个Parser。今年是json,去年是Markdown。每次都做得很蹦，希望能混到几十分吧。

说到底，还是自己太渣了，每次写一些复杂的逻辑的时候，感觉大脑就不够用了，一旦程序达到300行，就开始有点接受不了了。这次考试暴露自己挺多不足的地方：

数据结构的底子还不够扎实。
一遇到图就直接崩，遇到适合树结构的也不敢用。
不会写注释
从这次做题的时候就可以感觉出来，如果一开始敲的时候加一些注释，后面就不会看自己代码都需要想好久，而且最近在写的sort算法，也不会记一些注释，写的时候老是觉得很简单，自己可以很容易记住，然而每次都打自己的脸。
遇事没有韧性
总感觉自己老是会放弃，做题时也是这样，做第三题时老是想着“要不不写了，直接走吧”，好在忍了下来，不然估计连几十分都不敢奢望。
对STL根本不熟悉
即使翻着书也不写不好，总是会忘记一下东西，最后还是用c那一套写了一堆。
不会组织程序结构
总是会写出一个很长的函数，明明很多时候是可以把一些实现分成函数，然后分别测试的。在想要实现一个东西的时候，首先做得是打开编辑器开写，而不是思考怎么做。

总结的有点心塞。。。

一点一点的改变吧。

把树和图的一些基本算法实现出来（开一个repositories来放一些算法）
写好注释（起码能让自己几天后一看就知道自己当时想的是什么）
坚持写blog，起码每周更新一次
尝试着研究一下STL（如果有时间的话，捂脸）

路还远着呢！

RSS Feed

2020 年终总结

2020 的碎碎念

疫情在家的无聊/有聊时光

回到学校后瞬息万变的生活

技术与三分钟热度

关于 2021

6.S081 lab2 system calls

system call

trace

sysinfo

freemem

nproc

copyout

6.S081 laba1 util

sleep

pingpong

primes

find

ls 的实现

find 实现

xargs

xargs 基本使用

xargs

uptime

grep with regular expressions

sh

not print $ when processing shell command from a file

ST-MVL: Filling Missing Values in Geo-sensory Time Series Data

Introduction

为什么需要Filling Missing Values

Challenge

Contribution

Overview

Problem Definition

Multi View

Framework

ST-MLV

Global Spatial View - IDW

Global Temporal View - SES

Local View

Local Spatial View - UCF

Local Temporal View - ICF

Multi-View Learning

Experiment

Dataset

Metric

Result

Conclusion

Reference

Docker Quick Start

基础概念

Cheat Sheet

Image

列出本地镜像

拉取镜像

删除镜像

构造镜像

Container

启动容器

列出镜像

停止/删除容器

Others

查看 Docker 相关信息：

将用户加入到本地 Docker 组中

查看 Image 信息

用自动机实现一个简易的正则表达式引擎

起因

理论

实现

2020 02 & 03 Reading

2020-02

《人生海海》

《牛奶可乐经济学》

《白夜行》

《精进》

《娱乐至死》

《美丽新世界》

《呼吸》

《练习的心态》

为什么需要`Filling Missing Values`