Mathidot

Lab3_pagetable

2022-07-02T00:00:00+08:00

ugetpid函数代码如下：

int 
ugetpid(void)
{
    struct usyscall *u = (struct usyscall *)USYSCALL;
    return u->pid;
}

proc_pagetable函数

// Create a user page table for a given process
// with no user memory, but with trampoline pages
pagetable_t
proc_pagetable(struct proc *p)
{
    pagetable_t pagetable;
    
    // An empty page table
    pagetable = uvmcreate();
    if(pagetable == 0)
        return 0;
    
    // map the trampoline code (for system call return)
    // at the highest user virtual address
    // only the supervisor uses it, on the way
    // to/from user space, so not PTE_U
    
    if(mappages(pagetable, TRAMPOLINE, PAGESIZE,
               	(uint64)trampoline, PTE_R | PTE_X) < 0){
        uvmfree(pagetable,0);
        return 0;
    }
    
    // map the trapframe just below TRAMPOLINE for trampoline.S
    if(mappages(pagetable, TRAPFRAME, PGSIZE,
               	(uint64)(p->trapframe), PTE_R | PTE_W) < 0){
        uvmunmap(pagetable, TRAMPOLINE, 1, 0);
        uvmfree(pagetable, 0);
        return 0;
    }
    
    return pagetable;
}

mappages 函数：

// Create PTEs for virtual addresses starting at va that refer to 
// physical addresses starting at pa. va and size might not 
// be page-aligned. Returns 0 on success, -1 if walk() couldn't 
// allocate a needed page-table page.

int mappages(pagetable_t pagetable, uint64 va, uint64 size, uint64 pa, int perm)
{
    uint64 a, last;
    pte_t *pte;
    
    if(size == 0)
        panic("mappages: size");
    
    a = PGROUNDDOWN(va);
    last = PGROUNDDOWN(va + size - 1);
    for(;;){
        if((pte = walk(pagetable, a, 1)) == 0)
            return -1;
        if(*pte & PTE_V)
            panic("mappages: remap");
        *pte = PA2PTE(pa) | perm | PTE_V;
        if(a == last)
            break;
        a += PGSIZE;
        pa += PGSIZE;
    }
    return 0;
}

Xv6调试指南

2022-06-30T00:00:00+08:00

xv6调试指南

make clean && make qemu-gdb
注意这里打开的TCP端口是26000。另开一个Terminal窗口，切到xv6-labs-2020目录下，切到util分支，执行riscv64-unknown-elf-gdb kernel/kernel
target remote localhost:26000

不过也可以按如下操作简化：在~目录下新建.gdbinit文件内容为：

add-auto-load-safe-path ~/xv6-labs-2020/.gdbinit

其中~改为自己的xv6-labs-2020目录所在路径。仍返回xv6-labs-2020目录util分支，执行

riscv64-unknown-elf-gdb

在(gdb)环境中执行

(gdb) b exec

显示

Breakpoint 1 at 0x80004b0c: file kernel/exec.c, line 14.

然后执行

(gdb) c c是continue的缩写，也可缩写为co或cont。显示

Continuing.
[Switching to Thread 1.3]

Thread 3 hit Breakpoint 1, exec (path=path@entry=0x3fffffdf00 "/init", 
    argv=argv@entry=0x3fffffde00) at kernel/exec.c:14
14    {

另一个窗口中显示

xv6 kernel is booting`

`hart 1 starting`
`hart 2 starting

再执行c，显示

Continuing.`
`[Switching to Thread 1.1]`

`Thread 1 hit Breakpoint 1, exec (path=path@entry=0x3fffffbf00 "sh",` 
    `argv=argv@entry=0x3fffffbe00) at kernel/exec.c:14`
`14    {

另一个窗口显示

init: starting sh

再执行c，显示

Continuing.

另一个窗口显示

$

如果想调试特定的文件比如xargs.c，则在一开始启动gdb后执行

(gdb) file user/_xargs
(gdb) b main
(gdb) c

页表读书笔记

2022-06-29T00:00:00+08:00

pagetable_t may be either the kernel page table, or one of the per-process page tables.

walk: which finds the PTE for a virtual address, and mappages, which install PTEs for new mappings.

pte_t *
walk(pagetable_t pagetable, uint64 va, int alloc)
{
  if(va >= MAXVA)
    panic("walk");

  for(int level = 2; level > 0; level--) {
    pte_t *pte = &pagetable[PX(level, va)];
    if(*pte & PTE_V) {
      pagetable = (pagetable_t)PTE2PA(*pte);
    } else {
      if(!alloc || (pagetable = (pde_t*)kalloc()) == 0)
        return 0;
      memset(pagetable, 0, PGSIZE);
      *pte = PA2PTE(pagetable) | PTE_V;
    }
  }
  return &pagetable[PX(0, va)];
}

// Create PTEs for virtual addresses starting at va that refer to
// physical addresses starting at pa. va and size might not
// be page-aligned. Returns 0 on success, -1 if walk() couldn't
// allocate a needed page-table page.
int
mappages(pagetable_t pagetable, uint64 va, uint64 size, uint64 pa, int perm)
{
  uint64 a, last;
  pte_t *pte;

  if(size == 0)
    panic("mappages: size");
  
  a = PGROUNDDOWN(va);
  last = PGROUNDDOWN(va + size - 1);
  for(;;){
    if((pte = walk(pagetable, a, 1)) == 0)
      return -1;
    if(*pte & PTE_V)
      panic("mappages: remap");
    *pte = PA2PTE(pa) | perm | PTE_V;
    if(a == last)
      break;
    a += PGSIZE;
    pa += PGSIZE;
  }
  return 0;
}

copyout and copyin copy data to and from user virtual addresses provided as system call arguments; they are in the vm.c because they need to explicitly translate those addresses in order to find the corresponding physical memory.

// Copy from kernel to user.
// Copy len bytes from src to virtual address dstva in a given page table.
// Return 0 on success, -1 on error.
int
copyout(pagetable_t pagetable, uint64 dstva, char *src, uint64 len)
{
  uint64 n, va0, pa0;

  while(len > 0){
    va0 = PGROUNDDOWN(dstva);
    pa0 = walkaddr(pagetable, va0);
    if(pa0 == 0)
      return -1;
    n = PGSIZE - (dstva - va0);
    if(n > len)
      n = len;
    memmove((void *)(pa0 + (dstva - va0)), src, n);

    len -= n;
    src += n;
    dstva = va0 + PGSIZE;
  }
  return 0;
}

// Copy from user to kernel.
// Copy len bytes to dst from virtual address srcva in a given page table.
// Return 0 on success, -1 on error.
int
copyin(pagetable_t pagetable, char *dst, uint64 srcva, uint64 len)
{
  uint64 n, va0, pa0;

  while(len > 0){
    va0 = PGROUNDDOWN(srcva);
    pa0 = walkaddr(pagetable, va0);
    if(pa0 == 0)
      return -1;
    n = PGSIZE - (srcva - va0);
    if(n > len)
      n = len;
    memmove(dst, (void *)(pa0 + (srcva - va0)), n);

    len -= n;
    dst += n;
    srcva = va0 + PGSIZE;
  }
  return 0;
}

In the boot sequence, main calls kvminit to create the kernel’s page table using kvmmake. This call occurs before xv6 has enabled paging on the RISC-V, so addresses refer directly to physical memory.

// Initialize the one kernel_pagetable
void
kvminit(void)
{
  kernel_pagetable = kvmmake();
}

// Make a direct-map page table for the kernel.
pagetable_t
kvmmake(void)
{
  pagetable_t kpgtbl;

  kpgtbl = (pagetable_t) kalloc();
  memset(kpgtbl, 0, PGSIZE);

  // uart registers
  kvmmap(kpgtbl, UART0, UART0, PGSIZE, PTE_R | PTE_W);

  // virtio mmio disk interface
  kvmmap(kpgtbl, VIRTIO0, VIRTIO0, PGSIZE, PTE_R | PTE_W);

  // PLIC
  kvmmap(kpgtbl, PLIC, PLIC, 0x400000, PTE_R | PTE_W);

  // map kernel text executable and read-only.
  kvmmap(kpgtbl, KERNBASE, KERNBASE, (uint64)etext-KERNBASE, PTE_R | PTE_X);

  // map kernel data and the physical RAM we'll make use of.
  kvmmap(kpgtbl, (uint64)etext, (uint64)etext, PHYSTOP-(uint64)etext, PTE_R | PTE_W);

  // map the trampoline for trap entry/exit to
  // the highest virtual address in the kernel.
  kvmmap(kpgtbl, TRAMPOLINE, (uint64)trampoline, PGSIZE, PTE_R | PTE_X);

  // map kernel stacks
  proc_mapstacks(kpgtbl);
  
  return kpgtbl;
}

kvmmake first allocates a page of physical memory to hold the root page-table page. Then it calls kvmmap to install the translations that kernel needs. The translations include the kernel’s instructions and data, physical memory up to PHYSTOP, and memory ranges which are actually devices. Proc_mapstacks allocates a kernel stack for each process. It calls kvmmap to map each stack at the virtual address generated by KSTACK, which leaves root for the invalid stack-guard pages.

// Allocate a page for each process's kernel stack.
// Map it high in memory, followed by an invalid
// guard page.
void
proc_mapstacks(pagetable_t kpgtbl) {
  struct proc *p;
  
  for(p = proc; p < &proc[NPROC]; p++) {
    char *pa = kalloc();
    if(pa == 0)
      panic("kalloc");
    uint64 va = KSTACK((int) (p - proc));
    kvmmap(kpgtbl, va, (uint64)pa, PGSIZE, PTE_R | PTE_W);
  }
}

kvmmap calls mappages, which installs mappings into a page table for a range of virtual address in the range, at page intervals For each virtual address to be mapped, mappages calls walk to find the address of the PTE for that address. It then initializes the PTE to hold the relevant physical page number.

// add a mapping to the kernel page table.
// only used when booting.
// does not flush TLB or enable paging.
void
kvmmap(pagetable_t kpgtbl, uint64 va, uint64 pa, uint64 sz, int perm)
{
  if(mappages(kpgtbl, va, sz, pa, perm) != 0)
    panic("kvmmap");
}

walk mimics the RISC-V paging hardware as it looks up the PTE for a virtual address. walk descends the 3-level page table 9 bits at a time. It uses each level’s 9 bits of virtual address to find the PTE of either the next-level page table of the final page. If the PTE isn’t valid, then the required page hasn’t been allocated; if the alloc argument is set. walk allocates a new-page table and puts its physical address in the PTE. It returns the address of the PTE in the lowest layer in the tree.

The above code depends on physical memory being direct-mapped into the kernel. For example, as walk descends levels of the page table, it pulls the address of the next-level-down page table from a PTE, and then uses that address as a virtual address to fetch the PTE at he next level down.

main calls kvminithart to install the kernel page table. It writes the physical address of the root page-table page into the register satp. After this the CPU will translate addresses using the kernel page table. Since the kernel uses an identity mapping, the now virtual address of the next instruction will map to the right physical memory address.

Each RISC-V caches page table entries in a Translation Look-aside Buffer(TLB), and when xv6 changes a page table, it must tell the CPU to invalidate corresponding cached TLB entries. If it didn’t then at some point lager the TLB might use an old cached mapping, pointing to a physical page that in the meantime has been allocated to another process, and as a result, a process might be able to scribble on some other process’s memory. The RISC-V has an instruction sfence.vma that flushes the current CPU’s TLB. Xv6 executes sfence.vma in kvminithart after reloading the satp register, and in the trampoline code that switches to a user page table before returning to user space.

Physical memory allocation

The kernel must allocate and free physical memory at run-time for page tables, user memory, kernel stacks, and pipe buffers. xv6 uses the physical memory between the end of the kernel and PHYSTOP for run-time allocation. It allocates and frees whole 4096-byte pages at a time. It keeps track of which pages are free by threading a linked list through the pages themselves. Allocation consists of removing a page from the linked list; freeing consists of adding the freed page to the list.

Code: Physical memory allocator

The allocator resides kalloc.c. The allocator’s data structure is a free list of physical memory pages that are available for allocation. Each free page’s list element is a struct run. Where does the allocator get the memory to hold that data structure? It stores each free page’s run structure in the free page itself,

原文这里引用的是本机 Typora 截图，图片文件没有随仓库保存。

Figure 3.4 shows the layout of the user memory of an executing process in xv6 in more detail. The stack is a single page, and is shown with the initial contents as created by exec. Strings containing the command-line arguments , as well as an array of pointers to them, are at the very top of the stack. Just under that are values that allow a program to start at main as if the function main(argc, argv) has just been called.

To detect a user stack overflowing the allocated memory.

Code: sbrk

sbrk is the system call for a process to shrink or grow its memory. The system call is implemented by the function growproc. growproc calls uvmalloc or uvmdealloc, depending on whether n is positive or negative. uvmalloc allocates physical memory with kalloc, and adds PTEs to the user page table with mappages. vumdealloc calls uvmunmap, which uses walk to find PTEs and kfree to free the physical memory they refer to.

Now exec allocates and initializes the user stack. It allocates just one stack page. Exec copies the argument strings to the top of the stack one at a time, recording the pointers to them in ustack. It places a null pointer at the end of that will be the argv list passed to main. The first three entries in ustack are the fake return program counter, argc, and argv pointer.

For example if (ph.vaddr + ph.memsz < ph.vaddr) checks for whether the sum overflows to 0x1000, which will look like a valid value. In an older version of xv6 in which the user address space also contained the kernel, the user could choose an address that correspond to kernel memory and would thus copy data from the ELF binary into the kernel. In the RISC-V version xv6 this cannot happen, because the kernel has its own separate page table;loadseg loads into the process’s page table, not in the kernel’s page table.

Real world

Real hardware places RAM and devices at unpredictable physical addresses, so that there might be no RAM at 0x80000000, where xv6 expect to be able to store the kernel.

命令行环境

2022-06-23T00:00:00+08:00

命令行环境

任务控制

某些情况下我们需要中断正在执行的任务，比如当一个命令需要执行很长时间才能完成时（假设我们在使用 find 搜索一个非常大的目录结构）。大多数情况下，我们可以使用 Ctrl-C 来停止命令的执行。但是它的工作原理是什么呢？为什么有的时候会无法结束进程？

结束进程

您的 shell 会使用 UNIX 提供的信号机制执行进程间通信。当一个进程接收到信号时，它会停止执行、处理该信号并基于信号传递的信息来改变其执行。就这一点而言，信号是一种软件中断。

在上面的例子中，当我们输入 Ctrl-C 时，shell 会发送一个SIGINT 信号到进程。

下面这个 Python 程序向您展示了捕获信号SIGINT 并忽略它的基本操作，它并不会让程序停止。为了停止这个程序，我们需要使用SIGQUIT 信号，通过输入Ctrl-\可以发送该信号。

#!/usr/bin/env python
import signal, time

def handler(signum, time):
    print("\nI got a SIGINT, but I am not stopping")

signal.signal(signal.SIGINT, handler)
i = 0
while True:
    time.sleep(.1)
    print("\r{}".format(i), end="")
    i += 1

如果我们向这个程序发送两次 SIGINT ，然后再发送一次 SIGQUIT，程序会有什么反应？注意 ^ 是我们在终端输入Ctrl 时的表示形式：

$ python sigint.py
24^C
I got a SIGINT, but I am not stopping
26^C
I got a SIGINT, but I am not stopping
30^\[1]    39913 quit       python sigint.pyƒ

尽管 SIGINT 和 SIGQUIT 都常常用来发出和终止程序相关的请求。SIGTERM 则是一个更加通用的、也更加优雅地退出信号。为了发出这个信号我们需要使用 kill 命令, 它的语法是： kill -TERM <PID>。

暂停和后台执行进程

信号可以让进程做其他的事情，而不仅仅是终止它们。例如，SIGSTOP 会让进程暂停。在终端中，键入 Ctrl-Z 会让 shell 发送 SIGTSTP 信号，SIGTSTP是 Terminal Stop 的缩写（即terminal版本的SIGSTOP）。

我们可以使用 fg 或 bg 命令恢复暂停的工作。它们分别表示在前台继续或在后台继续。

jobs 命令会列出当前终端会话中尚未完成的全部任务。您可以使用 pid 引用这些任务（也可以用 pgrep 找出 pid）。更加符合直觉的操作是您可以使用百分号 + 任务编号（jobs 会打印任务编号）来选取该任务。如果要选择最近的一个任务，可以使用 $! 这一特殊参数。

还有一件事情需要掌握，那就是命令中的 & 后缀可以让命令在直接在后台运行，这使得您可以直接在 shell 中继续做其他操作，不过它此时还是会使用 shell 的标准输出，这一点有时会比较恼人（这种情况可以使用 shell 重定向处理）。

让已经在运行的进程转到后台运行，您可以键入Ctrl-Z ，然后紧接着再输入bg。注意，后台的进程仍然是您的终端进程的子进程，一旦您关闭终端（会发送另外一个信号SIGHUP），这些后台的进程也会终止。为了防止这种情况发生，您可以使用 nohup (一个用来忽略 SIGHUP 的封装) 来运行程序。针对已经运行的程序，可以使用disown 。除此之外，您可以使用终端多路复用器来实现，下一章节我们会进行详细地探讨。

下面这个简单的会话中展示来了些概念的应用。

$ sleep 1000
^Z
[1]  + 18653 suspended  sleep 1000

$ nohup sleep 2000 &
[2] 18745
appending output to nohup.out

$ jobs
[1]  + suspended  sleep 1000
[2]  - running    nohup sleep 2000

$ bg %1
[1]  - 18653 continued  sleep 1000

$ jobs
[1]  - running    sleep 1000
[2]  + running    nohup sleep 2000

$ kill -STOP %1
[1]  + 18653 suspended (signal)  sleep 1000

$ jobs
[1]  + suspended (signal)  sleep 1000
[2]  - running    nohup sleep 2000

$ kill -SIGHUP %1
[1]  + 18653 hangup     sleep 1000

$ jobs
[2]  + running    nohup sleep 2000

$ kill -SIGHUP %2

$ jobs
[2]  + running    nohup sleep 2000

$ kill %2
[2]  + 18745 terminated  nohup sleep 2000

$ jobs

SIGKILL 是一个特殊的信号，它不能被进程捕获并且它会马上结束该进程。不过这样做会有一些副作用，例如留下孤儿进程。

您可以在这里或输入 man signal 或使用 kill -l 来获取更多关于信号的信息。

终端多路复用

当您在使用命令行时，您通常会希望同时执行多个任务。举例来说，您可以想要同时运行您的编辑器，并在终端的另外一侧执行程序。尽管再打开一个新的终端窗口也能达到目的，使用终端多路复用器则是一种更好的办法。

像 tmux 这类的终端多路复用器可以允许我们基于面板和标签分割出多个终端窗口，这样您便可以同时与多个 shell 会话进行交互。

不仅如此，终端多路复用使我们可以分离当前终端会话并在将来重新连接。

这让您操作远端设备时的工作流大大改善，避免了 nohup 和其他类似技巧的使用。

现在最流行的终端多路器是 tmux。tmux 是一个高度可定制的工具，您可以使用相关快捷键创建多个标签页并在它们间导航。

tmux 的快捷键需要我们掌握，它们都是类似 <C-b> x 这样的组合，即需要先按下Ctrl+b，松开后再按下 x。tmux 中对象的继承结构如下：

会话

- 每个会话都是一个独立的工作区，其中包含一个或多个窗口
- tmux 开始一个新的会话
- tmux new -s NAME 以指定名称开始一个新的会话
- tmux ls 列出当前所有会话
- 在 tmux 中输入 <C-b> d ，将当前会话分离
- tmux a 重新连接最后一个会话。您也可以通过 -t 来指定具体的会话
窗口

- 相当于编辑器或是浏览器中的标签页，从视觉上将一个会话分割为多个部分
- <C-b> c 创建一个新的窗口，使用 <C-d>关闭
- <C-b> N 跳转到第 N 个窗口，注意每个窗口都是有编号的
- <C-b> p 切换到前一个窗口
- <C-b> n 切换到下一个窗口
- <C-b> , 重命名当前窗口
- <C-b> w 列出当前所有窗口
面板

- 像 vim 中的分屏一样，面板使我们可以在一个屏幕里显示多个 shell
- <C-b> " 水平分割
- <C-b> % 垂直分割
- <C-b> <方向> 切换到指定方向的面板，<方向> 指的是键盘上的方向键
- <C-b> z 切换当前面板的缩放
- <C-b> [ 开始往回卷动屏幕。您可以按下空格键来开始选择，回车键复制选中的部分
- <C-b> <空格> 在不同的面板排布间切换

扩展阅读：这里是一份 tmux 快速入门教程，而这一篇文章则更加详细，它包含了 screen 命令。您也许想要掌握 screen 命令，因为在大多数 UNIX 系统中都默认安装有该程序。

别名

输入一长串包含许多选项的命令会非常麻烦。因此，大多数 shell 都支持设置别名。shell 的别名相当于一个长命令的缩写，shell 会自动将其替换成原本的命令。例如，bash 中的别名语法如下：

alias alias_name="command_to_alias arg1 arg2"

注意， =两边是没有空格的，因为 alias 是一个 shell 命令，它只接受一个参数。

别名有许多很方便的特性:

# 创建常用命令的缩写
alias ll="ls -lh"

# 能够少输入很多
alias gs="git status"
alias gc="git commit"
alias v="vim"

# 手误打错命令也没关系
alias sl=ls

# 重新定义一些命令行的默认行为
alias mv="mv -i"           # -i prompts before overwrite
alias mkdir="mkdir -p"     # -p make parent dirs as needed
alias df="df -h"           # -h prints human readable format

# 别名可以组合使用
alias la="ls -A"
alias lla="la -l"

# 在忽略某个别名
\ls
# 或者禁用别名
unalias la

# 获取别名的定义
alias ll
# 会打印 ll='ls -lh'

值得注意的是，在默认情况下 shell 并不会保存别名。为了让别名持续生效，您需要将配置放进 shell 的启动文件里，像是.bashrc 或 .zshrc，下一节我们就会讲到。

配置文件（Dotfiles）

很多程序的配置都是通过纯文本格式的被称作点文件的配置文件来完成的（之所以称为点文件，是因为它们的文件名以 . 开头，例如 ~/.vimrc。也正因为此，它们默认是隐藏文件，ls并不会显示它们）。

shell 的配置也是通过这类文件完成的。在启动时，您的 shell 程序会读取很多文件以加载其配置项。根据 shell 本身的不同，您从登录开始还是以交互的方式完成这一过程可能会有很大的不同。关于这一话题，这里有非常好的资源

对于 bash来说，在大多数系统下，您可以通过编辑 .bashrc 或 .bash_profile 来进行配置。在文件中您可以添加需要在启动时执行的命令，例如上文我们讲到过的别名，或者是您的环境变量。

实际上，很多程序都要求您在 shell 的配置文件中包含一行类似 export PATH="$PATH:/path/to/program/bin" 的命令，这样才能确保这些程序能够被 shell 找到。

还有一些其他的工具也可以通过点文件进行配置：

bash - ~/.bashrc, ~/.bash_profile
git - ~/.gitconfig
vim - ~/.vimrc 和 ~/.vim 目录
ssh - ~/.ssh/config
tmux - ~/.tmux.conf

我们应该如何管理这些配置文件呢，它们应该在它们的文件夹下，并使用版本控制系统进行管理，然后通过脚本将其 符号链接 到需要的地方。这么做有如下好处：

安装简单: 如果您登录了一台新的设备，在这台设备上应用您的配置只需要几分钟的时间；
可以执行: 您的工具在任何地方都以相同的配置工作
同步: 在一处更新配置文件，可以同步到其他所有地方
变更追踪: 您可能要在整个程序员生涯中持续维护这些配置文件，而对于长期项目而言，版本历史是非常重要的

配置文件中需要放些什么？您可以通过在线文档和帮助手册了解所使用工具的设置项。另一个方法是在网上搜索有关特定程序的文章，作者们在文章中会分享他们的配置。还有一种方法就是直接浏览其他人的配置文件：您可以在这里找到无数的dotfiles 仓库 —— 其中最受欢迎的那些可以在这里找到（我们建议您不要直接复制别人的配置）。这里也有一些非常有用的资源。

可移植性

配置文件的一个常见的痛点是它可能并不能在多种设备上生效。例如，如果您在不同设备上使用的操作系统或者 shell 是不同的，则配置文件是无法生效的。或者，有时您仅希望特定的配置只在某些设备上生效。

有一些技巧可以轻松达成这些目的。如果配置文件 if 语句，则您可以借助它针对不同的设备编写不同的配置。例如，您的 shell 可以这样做：

if [[ "$(uname)" == "Linux" ]]; then {do_something}; fi

# 使用和 shell 相关的配置时先检查当前 shell 类型
if [[ "$SHELL" == "zsh" ]]; then {do_something}; fi

# 您也可以针对特定的设备进行配置
if [[ "$(hostname)" == "myServer" ]]; then {do_something}; fi

如果配置文件支持 include 功能，您也可以多加利用。例如：~/.gitconfig 可以这样编写：

[include]
    path = ~/.gitconfig_local

然后我们可以在日常使用的设备上创建配置文件 ~/.gitconfig_local 来包含与该设备相关的特定配置。您甚至应该创建一个单独的代码仓库来管理这些与设备相关的配置。

如果您希望在不同的程序之间共享某些配置，该方法也适用。例如，如果您想要在 bash 和 zsh 中同时启用一些别名，您可以把它们写在 .aliases 里，然后在这两个 shell 里应用：

# Test if ~/.aliases exists and source it
if [ -f ~/.aliases ]; then
    source ~/.aliases
fi

远端设备

对于程序员来说，在他们的日常工作中使用远程服务器已经非常普遍了。如果您需要使用远程服务器来部署后端软件或您需要一些计算能力强大的服务器，您就会用到安全 shell（SSH）。和其他工具一样，SSH 也是可以高度定制的，也值得我们花时间学习它。

通过如下命令，您可以使用 ssh 连接到其他服务器：

ssh foo@bar.mit.edu

这里我们尝试以用户名 foo 登录服务器 bar.mit.edu。服务器可以通过 URL 指定（例如bar.mit.edu），也可以使用 IP 指定（例如foobar@192.168.1.42）。后面我们会介绍如何修改 ssh 配置文件使我们可以用类似 ssh bar 这样的命令来登录服务器。

执行命令

ssh 的一个经常被忽视的特性是它可以直接远程执行命令。 ssh foobar@server ls 可以直接在用foobar的命令下执行 ls 命令。想要配合管道来使用也可以， ssh foobar@server ls | grep PATTERN 会在本地查询远端 ls 的输出而 ls | ssh foobar@server grep PATTERN 会在远端对本地 ls 输出的结果进行查询。

SSH 密钥

基于密钥的验证机制使用了密码学中的公钥，我们只需要向服务器证明客户端持有对应的私钥，而不需要公开其私钥。这样您就可以避免每次登录都输入密码的麻烦了秘密就可以登录。不过，私钥(通常是 ~/.ssh/id_rsa 或者 ~/.ssh/id_ed25519) 等效于您的密码，所以一定要好好保存它。

密钥生成

使用 ssh-keygen 命令可以生成一对密钥：

ssh-keygen -o -a 100 -t ed25519 -f ~/.ssh/id_ed25519

您可以为密钥设置密码，防止有人持有您的私钥并使用它访问您的服务器。您可以使用 ssh-agent 或 gpg-agent ，这样就不需要每次都输入该密码了。

如果您曾经配置过使用 SSH 密钥推送到 GitHub，那么可能您已经完成了这里介绍的这些步骤，并且已经有了一个可用的密钥对。要检查您是否持有密码并验证它，您可以运行 ssh-keygen -y -f /path/to/key.

基于密钥的认证机制

ssh 会查询 .ssh/authorized_keys 来确认那些用户可以被允许登录。您可以通过下面的命令将一个公钥拷贝到这里：

cat .ssh/id_ed25519 | ssh foobar@remote 'cat >> ~/.ssh/authorized_keys'

如果支持 ssh-copy-id 的话，可以使用下面这种更简单的解决方案：

ssh-copy-id -i .ssh/id_ed25519.pub foobar@remote

通过 SSH 复制文件

使用 ssh 复制文件有很多方法：

ssh+tee, 最简单的方法是执行 ssh 命令，然后通过这样的方法利用标准输入实现 cat localfile | ssh remote_server tee serverfile。回忆一下，tee 命令会将标准输出写入到一个文件；
scp ：当需要拷贝大量的文件或目录时，使用scp 命令则更加方便，因为它可以方便的遍历相关路径。语法如下：scp path/to/local_file remote_host:path/to/remote_file；
rsync 对 scp 进行了改进，它可以检测本地和远端的文件以防止重复拷贝。它还可以提供一些诸如符号连接、权限管理等精心打磨的功能。甚至还可以基于 --partial标记实现断点续传。rsync 的语法和scp类似；

端口转发

很多情况下我们都会遇到软件需要监听特定设备的端口。如果是在您的本机，可以使用 localhost:PORT 或 127.0.0.1:PORT。但是如果需要监听远程服务器的端口该如何操作呢？这种情况下远端的端口并不会直接通过网络暴露给您。

此时就需要进行 端口转发。端口转发有两种，一种是本地端口转发和远程端口转发（参见下图，该图片引用自这篇StackOverflow 文章）中的图片。

本地端口转发

远程端口转发

常见的情景是使用本地端口转发，即远端设备上的服务监听一个端口，而您希望在本地设备上的一个端口建立连接并转发到远程端口上。例如，我们在远端服务器上运行 Jupyter notebook 并监听 8888 端口。然后，建立从本地端口 9999 的转发，使用 ssh -L 9999:localhost:8888 foobar@remote_server 。这样只需要访问本地的 localhost:9999 即可。

SSH 配置

我们已经介绍了很多参数。为它们创建一个别名是个好想法，我们可以这样做：

alias my_server="ssh -i ~/.id_ed25519 --port 2222 -L 9999:localhost:8888 foobar@remote_server

不过，更好的方法是使用 ~/.ssh/config.

Host vm
    User foobar
    HostName 172.16.174.141
    Port 2222
    IdentityFile ~/.ssh/id_ed25519
    LocalForward 9999 localhost:8888

# 在配置文件中也可以使用通配符
Host *.mit.edu
    User foobaz

这么做的好处是，使用 ~/.ssh/config 文件来创建别名，类似 scp、rsync和mosh的这些命令都可以读取这个配置并将设置转换为对应的命令行选项。

注意，~/.ssh/config 文件也可以被当作配置文件，而且一般情况下也是可以被导入其他配置文件的。不过，如果您将其公开到互联网上，那么其他人都将会看到您的服务器地址、用户名、开放端口等等。这些信息可能会帮助到那些企图攻击您系统的黑客，所以请务必三思。

服务器侧的配置通常放在 /etc/ssh/sshd_config。您可以在这里配置免密认证、修改 ssh 端口、开启 X11 转发等等。您也可以为每个用户单独指定配置。

杂项

连接远程服务器的一个常见痛点是遇到由关机、休眠或网络环境变化导致的掉线。如果连接的延迟很高也很让人讨厌。Mosh（即 mobile shell ）对 ssh 进行了改进，它允许连接漫游、间歇连接及智能本地回显。

有时将一个远端文件夹挂载到本地会比较方便， sshfs 可以将远端服务器上的一个文件夹挂载到本地，然后您就可以使用本地的编辑器了。

Problems

我们可以使用类似 ps aux

grep 这样的命令来获取任务的 pid ，然后您可以基于pid 来结束这些进程。但我们其实有更好的方法来做这件事。在终端中执行 sleep 10000 这个任务。然后用 Ctrl-Z 将其切换到后台并使用 bg来继续允许它。现在，使用 pgrep 来查找 pid 并使用 pkill 结束进程而不需要手动输入pid。(提示：: 使用 -af 标记)。

sleep 10000
Ctrl-Z
bg

pgrep sleep #列出包含关键字 sleep 的进程的 pid
>
# 76560
# 81186
# 81292

pgrep sleep 10000 #列出包含关键字 sleep 的进程的 pid
>
# 76560
# 81186
# 81292

-a  Include process ancestors in the match list.  By default, the current pgrep or pkill process and all of its ancestors are excluded (unless -v is used).

-f  Match against full argument lists. The default is to match against process names.

pkill  -af sleep

如果您希望某个进程结束后再开始另外一个进程，应该如何实现呢？在这个练习中，我们使用 sleep 60 & 作为先执行的程序。一种方法是使用 wait 命令。尝试启动这个休眠命令，然后待其结束后再执行 ls 命令。
```
sleep 60 &
pgrep sleep | wait; ls
```
但是，如果我们在不同的 bash 会话中进行操作，则上述方法就不起作用了。因为 wait 只能对子进程起作用。之前我们没有提过的一个特性是，kill 命令成功退出时其状态码为 0 ，其他状态则是非0。kill -0 则不会发送信号，但是会在进程不存在时返回一个不为0的状态码。请编写一个 bash 函数 pidwait ，它接受一个 pid 作为输入参数，然后一直等待直到该进程结束。您需要使用 sleep 来避免浪费 CPU 性能。
```
pidwait()
{
   while kill -0 $1 #循环直到进程结束
   do
   sleep 1 
   done
   ls
}
```
需要注意的是，这里 while 判断的是命令行的返回值而不是布尔值，这个和其他语言有所区别。返回值 0 表示成功所以能够进入循环，参考这个问题
```
sleep 60 & pidwait $(pgrep sleep 60)
[1] 554
[1]  + 554 done       sleep 60
pidwait:kill:2: kill 554 failed: no such process
buggy.sh     debug_for.sh html_root    out.log
debug.sh     html.zip     marco.sh
```

终端多路复用

请完成这个 tmux 教程，并参考这些步骤来学习如何自定义 tmux。

别名

创建一个 dc 别名，它的功能是当我们错误的将 cd 输入为 dc 时也能正确执行。
```
alias dc=cd
```

执行

history | awk '{$1="";print substr($0,2)}' | sort | uniq -c | sort -n | tail -n 10

来获取您最常用的十条命令，尝试为它们创建别名。注意：这个命令只在 Bash 中生效，如果您使用 ZSH，使用history 1 替换 history。

history | awk '{$1="";print substr($0,2)}' | sort | uniq -c | sort -n | tail -n 10
g++ -std=c++11 tests.cpp
npm run src:build
git pull
./a.out
git status
ll
cd ..
git push
git add .
ls

配置文件

让我们帮助您进一步学习配置文件：

为您的配置文件新建一个文件夹，并设置好版本控制在其中添加至少一个配置文件，比如说您的 shell，在其中包含一些自定义设置（可以从设置 $PS1 开始）。建立一种在新设备进行快速安装配置的方法（无需手动操作）。最简单的方法是写一个 shell 脚本对每个文件使用 ln -s，也可以使用专用工具在新的虚拟机上测试该安装脚本。将您现有的所有配置文件移动到项目仓库里。将项目发布到GitHub。

mkdir ~/dotfiles
git init ~/dotfiles
#!/bin/bash
files="bashrc vimrc "

for file in $files; do
   ln -s ~/dotfiles/$file ~/.$file
done

远端设备

进行下面的练习需要您先安装一个 Linux 虚拟机（如果已经安装过则可以直接使用），如果您对虚拟机尚不熟悉，可以参考这篇教程来进行安装。

前往 ~/.ssh/ 并查看是否已经存在 SSH 密钥对。如果不存在，请使用
```
ssh-keygen -o -a 100 -t ed25519
```
来创建一个。建议为密钥设置密码然后使用ssh-agent，更多信息可以参考这里；
```
ssh-keygen -o -a 100 -t ed25519
   
ls ~/.ssh
config         id_ed25519     id_ed25519.pub known_hosts
```

在.ssh/config加入下面内容：

Host vm
   User username_goes_here
   HostName ip_goes_here
   IdentityFile ~/.ssh/id_ed25519
   LocalForward 9999 localhost:8888

这里我的远端设备是树莓派，ssh 配置如下

Host pi
   User pi
   HostName 192.168.50.56
   IdentityFile ~/.ssh/id_ed25519
   LocalForward 9999 localhost:8888

使用
```
ssh-copy-id vm
```
将您的 ssh 密钥拷贝到服务器。
```
ssh-copy-pi pi #拷贝秘钥
```
随后可以直接使用ssh pi进行免密登录

使用

python -m http.server 8888

在您的虚拟机中启动一个 Web 服务器并通过本机的

http://localhost:9999

访问虚拟机上的 Web 服务器这里我在树莓派上启动一个服务，并在 MacOS 上通过 ssh 端口转发进行访问。

pi@raspberrypi:~$ python -m http.server 8888
Serving HTTP on 0.0.0.0 port 8888 (http://0.0.0.0:8888/) ...

curl localhost:9999

pi@raspberrypi:~$ python -m http.server 8888
Serving HTTP on 0.0.0.0 port 8888 (http://0.0.0.0:8888/) ...
127.0.0.1 - - [15/May/2021 02:45:53] "GET / HTTP/1.1" 200 -

使用

sudo vim /etc/ssh/sshd_config

编辑 SSH 服务器配置，通过修改

PasswordAuthentication

的值来禁用密码验证。通过修改

PermitRootLogin

的值来禁用 root 登录。然后使用

sudo service sshd restart

重启 ssh 服务器，然后重新尝试。

#注意是服务器的 sshd 配置
pi@raspberrypi:~$ vim /etc/ssh/sshd_config

修改：

PasswordAuthentication的值为 no

PermitRootLogin

的值为 no 然后重启服务

#for MacOS
 sudo launchctl stop com.openssh.sshd
 sudo launchctl start com.openssh.sshd

(附加题) 在虚拟机中安装 mosh 并启动连接。然后断开服务器/虚拟机的网络适配器。mosh可以恢复连接吗？
```
sudo apt-get install mosh
```

(附加题) 查看ssh的-N 和 -f 选项的作用，找出在后台进行端口转发的命令是什么？

   -N      Do not execute a remote command.  This is useful for just forwarding ports.
   
   -f      Requests ssh to go to background just before command execution.  This is useful if ssh is going to ask for passwords or passphrases, but the user wants it in the background.  This implies -n.  The recommended way to start X11 programs at a remote site is with something like ssh -f host xterm.
   
   If the ExitOnForwardFailure configuration option is set to ``yes'', then a client started with -f will wait for all remote port forwards to be successfully established before placing itself in the background.

-N 就是不执行远端命令，适用于端口转发的情况
-f 是让 ssh 在执行命令前切换到后台运行

后台进行端口转发

ssh -fN -L 9999:localhost:8888 pi

HEVC

2022-06-21T00:00:00+08:00

How des HEVC work?

HEVC is based on the same general structure as previous standards. Source video, consisting of a sequence of video frames, is encoded or compressed by a video encoder to create a compressed video bitstream. The compressed bitstream is stored or transmitted. A video decoder decompresses the bitstream to create a sequence of decoded frames.

The steps carried out by a video encoder(Figure 2) include:

Partitioning each picture into multiple units.
Predicting each unit using inter or intra prediction, and substracting the prediction from the unit
Transforming and quantizing the residual(the difference between the original picture unit and the prediction)
Entropy encoding the transform output, prediction information, mode information and headers.

A video decoder reverses the steps:

Entropy decoding and extracting the elements of the coded sequence
Rescaling and inverting the transform stage
Predicting each unit and adding the prediction to the output of the inverse transform
Reconstructing a decoded video image.

Partitioning

HEVC supports highly flexible partitioning of a video sequence. Each frame of the sequence is split up into rectangular or square regions (Units or Blocks), each of which is predicted from previously coded data. After prediction, any residual information is transformed and entropy encoded.

Each coded video frame, or picture, is partitioned into Tiles and/or Slices, which are further partitioned into Coding Tree Units (CTUs). The CTU is the basic unit of coding, analogous to the Macroblock in earlier standards, and can be up to 64x64 pixels in siz

A Coding Tree Unit can be subdivided into square regions known s Coding Units (CUs) using a quadtree structure (Figure 3). Each CU is predicted using Inter or Intra prediction and transformed using one or more Transform Units (see below).

Figure 4 shows a video frame partitioned into slices, with one slice highlighted in blue. The highlighted slice contains six 64x64 CTUs.

Figure 5 shows a close-up of the CTU highlighted in Figure 4. The 64x64 CTU is split into four 32x32 regions, with the top-left 32x32 CU highlighted. In the other four quarters, the 32x32 region is split further, to 16x16 or 8x8 CUs.

Prediction

Frames of video are coded using Intra or Inter prediction. Figure 6 shows a sequence of coded video frames or coded pictures. The first picture (0) is coded using Intra prediction only, using spatial prediction from other regions of the same picture. Subsequent pictures are predicted from one, two or more reference pictures, using Inter and/or Intra prediction for each Prediction Unit (PU). The prediction sources for each picture are indicated by arrows.

数据整理

2022-06-20T00:00:00+08:00

journalctl | grep -i intel，它会找到所有包含intel（不区分大小写）的系统日志。

数据处理不可缺少的两样东西：

用来整理的数据
相关的应用场景

日志处理通常是一个比较典型的使用场景，因为我们经常需要哎日志中查找某些信息，这种情况下通读日志是不现实的。现在，让我们研究一下系统日志，看看哪些用户尝试登陆过我们的服务器:

ssh myserver journalctl

内容太多了，现在把涉及sshd的信息过滤出来：

ssh myserver journalctl | grep sshd

这里我们使用管道将一个远程服务器上的文件传递给本机的grep程序！此时我们打印出来的内容，仍然比我们需要的要多得多，读起来非常费劲，我们改进一下：

ssh myserver 'journalctl | grep sshd | grep "Disconnected from"' | less

多出来的引号是什么作用呢？这么说吧，我们的日志是一个非常大的文件，把这么大的文件流直接传输到我们本地的电脑上在进行过滤是对流量的一种浪费。因此我们采取另外一种方式，我们先在远端机器上过滤文本内容，然后再将结果传输到本机。less为我们创建了一个文件分页器，使我们可以通过翻页的方式浏览较长的文本。为了进一步节省流量，我们甚至可以将当前过滤处的日志保存到文件中，这样后续就不需要再次通过网络访问该文件了：

ssh myserver 'journalctl | grep sshd | grep "Disconnected from"' > ssh.log
less ssh.log

过滤结果中仍然包含不少没用的数据，我们有很多办法可以删除这些无用的数据，但是让我们先研究一下sed这个非常强大的工具。

sed是一个基于文本编辑器ed构建的“流编辑器”。在sed中，你基本上是利用一些简短的命令来修改文件，而不是直接操作文件的内容。相关的命名非常多，但是最常用的是s，即替换命令。例如我们可以这样写：

ssh myserver journalctl
	| grep sshd
	| grep "Disconnected from"
	| sed 's/.*Disconnected from //'

上面这段命令中，我们使用了一段简单的正则表达式。正则表达式是一种非常强大的工具，可以让我们基于某种模式来对字符串进行匹配。s命令的语法如下：s/REGEX/SUBSTITUTION,其中REGEX部分是我们需要使用的正则表达式，而SUBSTITUTION是用于替换匹配结果的文本

正则表达式

. 除换行符之外的”任意单个字符”
* 匹配前面字符零次或多次
+ 匹配前面字符一次或多次
[abc] 匹配 a, b 和 c 中的任意一个
(RX1|RX2) 任何能够匹配RX1 或 RX2的结果
^ 行首
$ 行尾

sed的正则表达式有些时候是比较奇怪的，它需要你在这些模式前添加\才能使其具有特殊含义。或者，你页可以添加-E选项来支持这些匹配。

回过头来看/.*Disconnected from /，我们会发现这个正则表达式可以匹配任意以若干字符开头，并接着包含Disconnected from的字符串，这正是我们希望的。但是如果有人将“Disconnected from”作为自己的用户名呢？

Jan 17 03:13:00 thesquareplanet.com sshd[2631]: Disconnected from invalid user Disconnected from 46.97.239.16 port 55920 [preauth]

正则式会如何匹配？*和+在默认情况下是贪婪模式，也就是说，它们会尽可能多的匹配文本。因此对上述字符串的匹配结果如下：

46.97.239.16 port 55920 [preauth]

这可不是我们想要的结果。对于某些正则表达式的实现来说，你可以给*或+ 增加一个? 后缀使其变成非贪婪模式，但是很可惜 sed 并不支持该后缀。不过，我们可以切换到 perl 的命令行模式，该模式支持编写这样的正则表达式：

perl -pe 's/.*?Disconnected from //'

让我们回到 sed 命令并使用它完成后续的任务，毕竟对于这一类任务，sed是最常见的工具。sed 还可以非常方便的做一些事情，例如打印匹配后的内容，一次调用中进行多次替换搜索等。但是这些内容我们并不会在此进行介绍。sed 本身是一个非常全能的工具，但是在具体功能上往往能找到更好的工具作为替代品。

好的，我们还需要去掉用户名的后缀，应该如何操作呢？

想要匹配用户名后面的文本，尤其是当这里的用户名可以包含空格时，这个问题变得非常棘手！这里我们需要做的是匹配一整行：

 | sed -E 's/.*Disconnected from (invalid |authenticating )?user .* [^ ]+ port [0-9]+( \[preauth\])?$//'

让我们借助正则表达式在线调试工具regex debugger 来理解这段表达式。OK，开始的部分和以前是一样的，随后，我们匹配两种类型的“user”（在日志中基于两种前缀区分）。再然后我们匹配属于用户名的所有字符。接着，再匹配任意一个单词（[^ ]+ 会匹配任意非空且不包含空格的序列）。紧接着后面匹配单“port”和它后面的一串数字，以及可能存在的后缀[preauth]，最后再匹配行尾。

注意，这样做的话，即使用户名是“Disconnected from”，对匹配结果也不会有任何影响，您知道这是为什么吗？

问题还没有完全解决，日志的内容全部被替换成了空字符串，整个日志的内容因此都被删除了。我们实际上希望能够将用户名保留下来。对此，我们可以使用“捕获组（capture groups）”来完成。被圆括号内的正则表达式匹配到的文本，都会被存入一系列以编号区分的捕获组中。捕获组的内容可以在替换字符串时使用（有些正则表达式的引擎甚至支持替换表达式本身），例如\1、 \2、\3等等，因此可以使用如下命令：

| sed -E 's/.*Disconnected from (invalid |authenticating )?user (.*) [^ ]+ port [0-9]+( \[preauth\])?$/\2/'

回到数据整理

OK，现在我们有如下表达式：

ssh myserver journalctl
 | grep sshd
 | grep "Disconnected from"
 | sed -E 's/.*Disconnected from (invalid |authenticating )?user (.*) [^ ]+ port [0-9]+( \[preauth\])?$/

sed 还可以做很多各种各样有趣的事情，例如文本注入：(使用 i 命令)，打印特定的行 (使用 p命令)，基于索引选择特定行等等。详情请见man sed!

现在，我们已经得到了一个包含用户名的列表，列表中的用户都曾经尝试过登陆我们的系统。但这还不够，让我们过滤出那些最常出现的用户：

ssh myserver journalctl
 | grep sshd
 | grep "Disconnected from"
 | sed -E 's/.*Disconnected from (invalid |authenticating )?user (.*) [^ ]+ port [0-9]+( \[preauth\])?$/\2/'
 | sort | uniq -c

sort 会对其输入数据进行排序。uniq -c 会把连续出现的行折叠为一行并使用出现次数作为前缀。我们希望按照出现次数排序，过滤出最常出现的用户名：

sort -n 会按照数字顺序对输入进行排序（默认情况下是按照字典序排序 -k1,1 则表示“仅基于以空格分割的第一列进行排序”。,n 部分表示“仅排序到第n个部分”，默认情况是到行尾。就本例来说，针对整个行进行排序也没有任何问题，我们这里主要是为了学习这一用法！

如果我们希望得到登陆次数最少的用户，我们可以使用 head 来代替tail。或者使用sort -r来进行倒序排序。

相当不错。但我们只想获取用户名，而且不要一行一个地显示。

ssh myserver journalctl
 | grep sshd
 | grep "Disconnected from"
 | sed -E 's/.*Disconnected from (invalid |authenticating )?user (.*) [^ ]+ port [0-9]+( \[preauth\])?$/\2/'
 | sort | uniq -c
 | sort -nk1,1 | tail -n10
 | awk '{print $2}' | paste -sd,

我们可以利用 paste命令来合并行(-s)，并指定一个分隔符进行分割 (-d)，那awk的作用又是什么呢？

awk – 另外一种编辑器

awk 其实是一种编程语言，只不过它碰巧非常善于处理文本。关于 awk 可以介绍的内容太多了，限于篇幅，这里我们仅介绍一些基础知识。

首先， {print $2} 的作用是什么？ awk 程序接受一个模式串（可选），以及一个代码块，指定当模式匹配时应该做何种操作。默认当模式串即匹配所有行（上面命令中当用法）。在代码块中，$0 表示整行的内容，$1 到 $n 为一行中的 n 个区域，区域的分割基于 awk 的域分隔符（默认是空格，可以通过-F来修改）。在这个例子中，我们的代码意思是：对于每一行文本，打印其第二个部分，也就是用户名。

让我们康康，还有什么炫酷的操作可以做。让我们统计一下所有以c 开头，以 e 结尾，并且仅尝试过一次登陆的用户。

 | awk '$1 == 1 && $2 ~ /^c[^ ]*e$/ { print $2 }' | wc -l

让我们好好分析一下。首先，注意这次我们为 awk指定了一个匹配模式串（也就是{...}前面的那部分内容）。该匹配要求文本的第一部分需要等于1（这部分刚好是uniq -c得到的计数值），然后其第二部分必须满足给定的一个正则表达式。代码块中的内容则表示打印用户名。然后我们使用 wc -l 统计输出结果的行数。

不过，既然 awk 是一种编程语言，那么则可以这样：

BEGIN { rows = 0 }
$1 == 1 && $2 ~ /^c[^ ]*e$/ { rows += $1 }
END { print rows }

BEGIN 也是一种模式，它会匹配输入的开头（ END 则匹配结尾）。然后，对每一行第一个部分进行累加，最后将结果输出。事实上，我们完全可以抛弃 grep 和 sed ，因为 awk 就可以解决所有问题。至于怎么做，就留给读者们做课后练习吧。

分析数据

想做数学计算也是可以的！例如这样，您可以将每行的数字加起来：

 | paste -sd+ | bc -l

下面这种更加复杂的表达式也可以：

echo "2*($(data | paste -sd+))" | bc -l

您可以通过多种方式获取统计数据。如果已经安装了R语言，st是个不错的选择：

ssh myserver journalctl
 | grep sshd
 | grep "Disconnected from"
 | sed -E 's/.*Disconnected from (invalid |authenticating )?user (.*) [^ ]+ port [0-9]+( \[preauth\])?$/\2/'
 | sort | uniq -c
 | awk '{print $1}' | R --slave -e 'x <- scan(file="stdin", quiet=TRUE); summary(x)'

R 也是一种编程语言，它非常适合被用来进行数据分析和绘制图表。这里我们不会讲的特别详细，您只需要知道summary 可以打印某个向量的统计结果。我们将输入的一系列数据存放在一个向量后，利用R语言就可以得到我们想要的统计数据。

如果您希望绘制一些简单的图表， gnuplot 可以帮助到您：

ssh myserver journalctl
 | grep sshd
 | grep "Disconnected from"
 | sed -E 's/.*Disconnected from (invalid |authenticating )?user (.*) [^ ]+ port [0-9]+( \[preauth\])?$/\2/'
 | sort | uniq -c
 | sort -nk1,1 | tail -n10
 | gnuplot -p -e 'set boxwidth 0.5; plot "-" using 1:xtic(2) with boxes'

利用数据整理来确定参数

有时候您要利用数据整理技术从一长串列表里找出你所需要安装或移除的东西。我们之前讨论的相关技术配合 xargs 即可实现：

rustup toolchain list | grep nightly | grep -vE "nightly-x86" | sed 's/-x86.*//' | xargs rustup toolchain uninstall

整理二进制数据

虽然到目前为止我们的讨论都是基于文本数据，但对于二进制文件其实同样有用。例如我们可以用 ffmpeg 从相机中捕获一张图片，将其转换成灰度图后通过SSH将压缩后的文件发送到远端服务器，并在那里解压、存档并显示。

ffmpeg -loglevel panic -i /dev/video0 -frames 1 -f image2 -
 | convert - -colorspace gray -
 | gzip
 | ssh mymachine 'gzip -d | tee copy.jpg | env DISPLAY=:0 feh -'

课后习题

统计words文件 (/usr/share/dict/words) 中包含至少三个a 且不以's 结尾的单词个数
```
cat /usr/share/dict/words | tr "[:upper:]" "[:lower:]" | grep -E "^([^a]*a){3}.*$" | grep -v "'s$" | wc -l
```
- 大小写转换：tr "[:upper:]" "[:lower:]"
- ^([^a]*a){3}.*[^'s]$：查找一个以 a 结尾的字符串三次
- ```
grep -v "\'s$"
```
  ：匹配结尾为’s 的结果，然后取反。借助
```
grep -v
```
  主要是这里不支持 lookback，不然下面的正则就可以完成
```
 ^([^a]*a){3}.*(?<!'s)$
```

这些单词中，出现频率前三的末尾两个字母是什么？

cat /usr/share/dict/words | tr "[:upper:]" "[:lower:]" | grep -E "^([^a]*a){3}.*$" | grep -v "'s$" | sed -E "s/.*([a-z]{2})$/\1/" | sort | uniq -c | sort | tail -n3
# 53 as
# 64 ns
# 102 an

共存在多少种词尾两字母组合？

cat /usr/share/dict/words | tr "[:upper:]" "[:lower:]" | grep -E "^([^a]*a){3}.*$" | grep -v "'s$" | sed -E "s/.*([a-z]{2})$/\1/" | sort | uniq | wc -l

还有一个很有挑战性的问题：哪个组合从未出现过？为了得到没出现的组合，首先我们要生成一个包含全部组合的列表，然后再使用上面得到的出现的组合，比较二者不同即可。

#!/bin/bash
for i in {a..z};do
 for j in {a..z};do
    echo  "$i$j"
 done
done

./all.sh > all.txt

cat /usr/share/dict/words | tr "[:upper:]" "[:lower:]" | grep -E "^([^a]*a){3}.*$" | grep -v "'s$" | sed -E "s/.*([a-z]{2})$/\1/" | sort | uniq > occurance.txt

diff --unchanged-group-format='' <(cat occurance.txt) <(cat all.txt) | wc -l

--unchanged-group-format=''用于将两个文件中相同的内容设置为空字符串，剩下的内容就是差异的部分。

进行原地替换听上去很有诱惑力，
例如： sed s/REGEX/SUBSTITUTION/ input.txt > input.txt。但是这并不是一个明智的做法，为什么呢？还是说只有 sed是这样的? 查看 man sed 来完成这个问题。sed s/REGEX/SUBSTITUTION/ input.txt > input.txt 表达式中后一个 input.txt会首先被清空，而且是发生在前的。所以前面一个input.txt在还没有被 sed 处理时已经为空了。在使用正则处理文件前最好是首先备份文件。

sed -i.bak s/REGEX/SUBSTITUTION/ input.txt > input.txt

可以自动创建一个后缀为 .bak 的备份文件。

找出您最近十次开机的开机时间平均数、中位数和最长时间。在Linux上需要用到 journalctl.

(base) mathidot3@ubuntu:~$ journalctl --list-boots
-18 7a71263f226348489b058a6a65ec2ff7 Thu 2021-12-09 22:48:10 PST—Fri 2021-12-10 00:43:41 PST
-17 59a41e35608c4992ac78160b60413a3c Fri 2021-12-10 00:43:57 PST—Fri 2021-12-10 19:08:35 PST
-16 ddb9b3f4f6b844f48be66b4238ddc5cf Sat 2021-12-11 23:27:14 PST—Tue 2021-12-14 02:50:41 PST
-15 c7109030f0f74e1aa028ed77b60e6bda Tue 2021-12-14 02:51:01 PST—Tue 2021-12-14 03:03:27 PST
-14 3ccab151510a4b9eb87273ae3e2db931 Tue 2021-12-14 03:30:57 PST—Tue 2021-12-14 03:30:57 PST
-13 874a8620a7654c98805dd25d4dafb207 Thu 2021-12-30 01:26:56 PST—Thu 2021-12-30 02:25:30 PST
-12 d4fee1a83a9048c68ff680741aedeb21 Thu 2021-12-30 02:38:51 PST—Thu 2021-12-30 17:44:49 PST
-11 2f7e6df538f04fb0be62452d64d2e3b5 Thu 2021-12-30 17:45:03 PST—Thu 2021-12-30 19:00:18 PST
-10 a4ce615cfde64bf6ae67e6cf01a04580 Thu 2021-12-30 19:05:49 PST—Fri 2021-12-31 20:55:19 PST
 -9 22f8b781dfe5488da791523103c74435 Fri 2022-05-06 19:04:15 PDT—Fri 2022-05-06 19:06:45 PDT
 -8 d2d6f585bc44469799aaf1923863e3e2 Fri 2022-05-06 19:26:13 PDT—Sat 2022-05-07 17:22:14 PDT
 -7 2df6ecc7902e47dab08ed644cc2d8dea Wed 2022-05-25 23:20:44 PDT—Fri 2022-05-27 19:56:48 PDT
 -6 115b9cc92b614ddfb19ef1dc868738b9 Sat 2022-05-28 17:06:34 PDT—Sat 2022-05-28 17:29:40 PDT
 -5 0bb641a79b9c416f8990d256c2141dce Sat 2022-05-28 17:29:55 PDT—Sat 2022-05-28 19:17:01 PDT
 -4 20962d3d3d844507949b05c0a39c0eff Sun 2022-05-29 17:57:46 PDT—Tue 2022-05-31 04:00:36 PDT
 -3 9dc479d0086a4c30af0c788f2b79784c Tue 2022-05-31 04:00:58 PDT—Tue 2022-05-31 04:36:29 PDT
 -2 cfecda8e5ed2494a9d85ada96357a7bf Tue 2022-05-31 04:49:32 PDT—Thu 2022-06-02 03:10:09 PDT
 -1 3d5439b6cac044ef94f0a42786b36faf Thu 2022-06-02 03:10:28 PDT—Thu 2022-06-16 19:41:50 PDT
  0 f3a22684297641e68e1735f6d64e2a53 Sun 2022-06-19 07:17:51 PDT—Mon 2022-06-20 06:53:32 PDT
   

可以使用 systemd-analyze工具看一下启动时间都花在哪里：

sudo systemd-analyze plot > systemd.svg

可以看到启动时间为 14.157s。接下来，编写脚本getlog.sh来获取最近十次的启动时间数据

#!/bin/bash
for i in {0..9}; do
   journalctl -b-$i | grep "Startup finished in"
done

./getlog > starttime.txt

#获取最长时间
cat starttime.txt | grep "systemd\[1\]" | sed -E "s/.*=\ (.*)s\.$/\1/"| sort --numeric-sort | tail -n1
#获取最短时间
cat starttime.txt | grep "systemd\[1\]" | sed -E "s/.*=\ (.*)s\.$/\1/"| sort -r --numeric-sort | tail -n1
#平均数（注意 awk 要使用单引号）
cat starttime.txt | grep "systemd\[1\]" | sed -E "s/.*=\ (.*)s\.$/\1/"| paste -sd+ | bc -l | awk '{print $1/10}'
# 中位数
cat starttime.txt | grep "systemd\[1\]" | sed -E "s/.*=\ (.*)s\.$/\1/"| sort |paste -sd\  | awk '{print ($5+$6)/2}'

如果配合使用 R 语言脚本则更加简单：

sudo apt-get install r-base

cat starttime.txt | grep "systemd\[1\]" | sed -E "s/.*=\ (.*)s\.$/\1/"| sort | R -e 'd<-scan("stdin",quiet=TRUE);min(d);max(d);mean(d);median(d);'

> d<-scan("stdin",quiet=TRUE);min(d);max(d);mean(d);median(d);
[1] 14.023
[1] 15.989
[1] 14.4304
[1] 14.2915

Mit 6.s081 operating system enginerring lab1 utilities

2022-06-20T00:00:00+08:00

MIT 6.S081 Operating System Enginerring Lab1 Utilities

sleep(easy)

Implement the UNIX program sleep for xv6; your sleep should pause for a user-specified number of ticks. A tick is a notion of time defined by the xv6 kernel, namely the time between two interrupts from the timer chip. Your solution should be in the file user/sleep.c.

$ make qemu
...
init: starting sh
$ sleep 10
(nothing happens for a little while)
$

Note that make grade runs all tests, including the ones for the assignments below. If you want to run the grade tests for one assignment, type:

$ trace 2147483647 grep hello README

Solution

#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 [time]\n");
    exit(1);
   } 

   int sleep_time = atoi(argv[1]);
   if(sleep_time == 0){
    fprintf(2,"Wrong parameter.\n");
    exit(1);
   }
   sleep(sleep_time);
   exit(0);
}

这题很简单没什么好讲的。

pingpong (easy)

Write a program that uses UNIX system calls to ‘‘ping-pong’’ a byte between two processes over a pair of pipes, one for each direction. The parent should send a byte to the child; the child should print “: received ping", where is its process ID, write the byte on the pipe to the parent, and exit; the parent should read the byte from the child, print ": received pong", and exit. Your solution should be in the file `user/pingpong.c`.

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

int main(int argc, char *argv[])
{
    char buf[2];
    int p1[2];
    pipe(p1);
    int p2[2];
    pipe(p2);
    char *cMsg = "c";
    char *pMsg = "p";

    if(fork() == 0){
        close(p1[1]);
        close(p2[0]);
        if(read(p1[0], buf, 1) != 1){
            fprintf(2,"Child fail to read from the pipe!\n");
            exit(1);
        }
        close(p1[0]);
        if(write(p2[1], cMsg, 1) != 1){
            fprintf(2,"Child fail to write to the pipe!\n");
            exit(1);
        }
        close(p2[1]);
        printf("%d: received ping\n",getpid());
        exit(0);
    }
    else{
        close(p1[0]);
        close(p2[1]);
        if(write(p1[1], pMsg, 1) != 1){
            fprintf(2,"Parent fail to write to the pipe!\n");
            exit(0);
        }
        close(p1[1]);
        wait((void *)0);
        if((read(p2[0], buf, 1)) != 1){
            fprintf(2,"Parent fail to read from the pipe!\n");
            exit(0);
        }
        close(p2[0]);
        printf("%d: received pong\n",getpid());
        exit(0);
    }
}

这题需要利用管道实现两个进程之间的通信，在实现的过程中需要注意管道端口的关闭，否则read函数就会一直在等待数据的输入。

primes(hard)

Write a concurrent version of prime sieve using pipes. This idea is due to Doug McIlroy, inventor of Unix pipes. The picture halfway down this page and the surrounding text explain how to do it. Your solution should be in the file user/primes.c.

此题需要仔细理解下面这张图：

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

void primes_help(int fd[]){
    close(fd[1]);
    int first_number;
    if(read(fd[0],&first_number,sizeof(int)) == 0){
        exit(0);
    }
    printf("prime %d\n",first_number);
    
    int read_number;
    int child_fd[2];
    pipe(child_fd);
    if(fork() == 0){
        primes_help(child_fd);
    }else{
        close(child_fd[0]);
        while(read(fd[0], &read_number,sizeof(int)) != 0){
            if(read_number % first_number != 0){
                if(write(child_fd[1],&read_number, sizeof(int)) != sizeof(int)){
                    fprintf(2,"Fail to write the left number in child function\n");
                    exit(1);
                }
            }
        }
        close(child_fd[1]);
        wait((void *)0);
        exit(0);
    }
}

int main(int argc, char *argv[])
{
    int p[2];
    pipe(p);
    int i;
    int first_number = 2;
    printf("prime %d\n",first_number);

    if(fork() == 0){
        primes_help(p);
    }else{
        close(p[0]);
        for(i = 3; i <= 35;i++){
            if(i % 2 != 0){
                if(write(p[1],&i,sizeof(int)) != sizeof(int)){
                    fprintf(2,"Fail to write the left numer in main function\n");
                    exit(1);
                } 
            }
        }
        close(p[1]);
        wait((void *)0);
        exit(0);
    }
    exit(0);
}

find(moderate)

Write a simple version of the UNIX find program: find all the files in a directory tree with a specific name. Your solution should be in the file user/find.c.

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

char*
fmtname(char *path)
{
  static char buf[DIRSIZ+1];
  char *p;

  // Find first character after last slash.
  for(p=path+strlen(path); p >= path && *p != '/'; p--)
    ;
  p++;

  // Return blank-padded name.
  if(strlen(p) >= DIRSIZ)
    return p;
  memmove(buf, p, strlen(p));
  memset(buf+strlen(p), 0, DIRSIZ-strlen(p));
  return buf;
}

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

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

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

    switch(st.type){
    case T_FILE:
        if(strcmp(fmtname(path), name) == 0){
            printf("%s\n",path);
        }
        break;
    case T_DIR:
        if(strlen(path) + 1 + DIRSIZ + 1 > sizeof buf){
            printf("find: 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 || strcmp(de.name, ".") == 0 || strcmp(de.name,"..") == 0)
                continue;
            memmove(p, de.name, DIRSIZ);
            p[DIRSIZ] = 0;
            if(stat(buf, &st) < 0){
                printf("find: cannot stat %s\n", buf);
                continue;
            }
            find(buf,name);
        }
        break;
    }
    close(fd);
}

int main(int argc, char *argv[])
{
    if(argc != 3){
        fprintf(2,"Incorrect number of parameters\n");
        exit(1);
    }

    char *find_path = argv[1];
    char *file_name = argv[2];

    find(find_path, file_name);
    exit(0);
}

这题主要参考的ls.c中的代码，但要注意这里面有个小坑，需要将fmtname函数中的代码中的 memset(buf+strlen(p), " ", DIRSIZ-strlen(p));修改为 ` memset(buf+strlen(p), 0, DIRSIZ-strlen(p));否则后面 if(strcmp(fmtname(path), name) == 0)`这里会出现问题。

xargs(moderate)

Write a simple version of the UNIX xargs program: read lines from the standard input and run a command for each line, supplying the line as arguments to the command. Your solution should be in the file user/xargs.c.

#include "kernel/types.h"
#include "kernel/stat.h"
#include "user/user.h"
#include "kernel/fs.h"
#include <stddef.h>
#include <kernel/param.h>

void copy(char **dst, char *src)
{
    *dst = malloc(strlen(src) + 1);
    strcpy(*dst,src);
}

void read_input(char **params,int index)
{
    int i = index;
    char buf[512];
    int j = 0; 
    
    while(read(0,buf+j,1) > 0){
        if(buf[j] == '\n' || buf[j] == ' '){
            buf[j] = 0;
        }
        j++;
        if(j > 512){
            fprintf(2,"Too many parameters");
            exit(1);
        }
    }
        
    int len = j;
    j = 0;
    while(buf[j] == ' '){
        j++;
    }
    int p = j;
    int state = 0;
    for(;j <= len;j++){
        if(buf[j] == 0){
            if(state == 0){
                copy(params + i, buf + p);
                i++;
                state = 1;
            }
        }
        else{
            if(state == 1){
                p = j;
                state = 0;
            }
        }
    }
}

int main(int argc, char *argv[])
{
    if(argc < 2){
        fprintf(2,"Too few parameters\n");
        exit(1);
    }

    char *params[MAXARG];

    int i;
    for(i = 1;i < argc;i++){
        copy(&params[i-1], argv[i]);
    }

    if(fork() == 0){
        read_input(params,i-1);
        exec(params[0],&params[0]);
        exit(0);
    }else{
        wait((void *)0);
        exit(0);
    }
    
    exit(0);
}

这题比较麻烦的主要是字符串的处理，我这里的处理方式是首先将所有的参数都读入到一个buf中，在读入的过程中如果遇到space或 \n ，就将它转换成0休止符，方便后续的处理。所有的字符都读取到buf中后，我利用了一个自动状态机的方法，将每个参数正确的读取到params参数数组中。

自动状态机如图：

原文这里引用的是本机 Typora 截图，图片文件没有随仓库保存。

xv6概述-1

2022-06-14T00:00:00+08:00

代码组织情况和操作系统影像的生成

xv6二进制代码分为两部分

启动扇区的代码
- bootblock
内核代码
- kernel

bootblock

readelf -I bootblock.o 			查看bootblock.o的段

代码阅读任务：

Makefile
kernel.ld

operators and expressions

2022-06-14T00:00:00+08:00

条件操作符

expression1? expression2: expression3
// expression1为真， 那么整个表达式的值就是expression2,否则整个表达式的值就是expreesion3
// Example
if(a > 5)
    b[2*c + d * (e / 5)] = 3
else
    b[2*c + d * (e / 5)] = 20
b[2*c + d * (e / 5)] = a > 5 ? 3 : 20

逗号操作符

expression1, expression2, ... ,,expressionN
/* 
逗号操作符将两个或多个表达式分开来。这些表达式自左向右逐个进行求值，整个逗号表达式的值就是最后那个表达	   式的值
*/
//Example
a = get_value();
count_value(a);
while(a > 0){
    ...
    a = get_value();
    count_value(a);
}

while(a = get_value(),count_value(a),a > 0){
    ...
}

while(count_value(a = get_value()), a > 0){
    ...
}

cgdb

2022-06-14T00:00:00+08:00

b 31 if letter=='1'

How to find segfaults

Compile and run your code
We can see that there is a segfault, but we do not know where it is occuring.
Let’s open up the code in cgdb (make sure that u compiled it with the -g flag)
Recall the run command will run your code until something stops it (like a segfault or a breakpoint). Execute the run command.
The command windows shows us that the program encountered a segfault (“Program received signal SIGSEGV”) at line 62. Now we know the line where the segfault occured.
Another command that can be useful when u are debugging segfaluts is backtrace. This will allow u to see the call stack at the time of the crash. Execute the following command to see the call stack.
```
backtrace
```
or
```
bt
```
Let’s examine the state of the program when the segfault occured by printing some variables. Print out head.
Remember that head is a double pointer, so we expect to see an address when we print it out. head looks fine. Let’s print out the dereferenced head (*head).
It looks like *head is NULL. If you look at the line of code that the program is segfaulting on, you can see that we are trying to access (*head)->next. We know that trying to access a member of a NULL struct will result in a segfault, so this is our problem.
What does it mean for *head to be NULL? It means that the list is empty. How do we reverse an empty list? The reverse of an empty list is just an empty list, so we do not need to modify the list. At the top of the function, we can add a check to see if the list if empty and return if so. Modify the first line of the function to be the following:
Compile and run your code. It should pass the reverse list tests now.

Other Useful GDB Commands

**Command: **info locals

Print the values of all the local variables in the current stack frame

**Command: **command

Execute a list of commands every time a break is reached.

For example:

Set a breakpoint:

b 73

Type commands followed by the breakpoint number:

commands 1

Type the list of commands that you want to execute separated by a new line. After your list of commands, type end and hit Enter.

p var1
p var2
end

**Command: ** delete

Deletes the specified breakpoint.

XV6 安装与调试

2022-06-14T00:00:00+08:00

启动GDB调试xv6

make qemu-gdb
gdb -silent kernel（启动gdb客户端调试kernel内核）
target remote localhost:26000（连接到gdb服务器的监听端口：26000）

GDB命令

info threads - 查看线程状态
set scheduler-locking on 各个线程都受GDB控制而执行

   thread apply ID1 ID2 command 让指定的线程（ID1/ID2...）执行GDB命令command
   thread apply all command 让所有被调试线程执行GDB命令command

练习：

用gdb观察四核系统，各个处理器核上的线程运行。自行设置感兴趣的断电位置，并尝试各个核上的线程各自独自推进运行。

Vim notes

2022-06-14T00:00:00+08:00

5 modes

normal (Esc or ctrl+[): moving around a file
insert (i): inserting text
replace (R): replacing text
visual (plain v, line V, block ctrl+v, last block gv): selecting blocks of text()
command-line (:): running command

command-line mode

:q quit window
:w write
:wq write and quit
:e {name of file} open file for editing
:ls show open buffers
:help {topic} open help, such as :help :w, :help w
:sp seperate another window

movement in normal mode

Basic movements：hjkl left down up right
Words: w next words, b begin of word, e end of word
Lines: 0 beginning of line, $ end of line, ^ first non-blank character
Screens: H top of screen, M middle of screen, L bottom of screen
Scroll: ctrl + d page down, ctrl + u page up
File: gg beginning of file, G end of file
Find: f{c} forward find c, t{c} forward to c, F{c} backward find c, T{c} backward to c
difference between f and t:
- f places the cursor on the found character
- t palces the cursor on the preceding character it found
ref: https://stackoverflow.com/questions/12495442/what-do-the-f-and-t-commands-do-in-vim
Search: /{regex}, n/N for navigating matches. 搜索结束之后输入 enter 转入到第一个结果位置，之后输入 n 跳转到下一个结果位置, shift + n jump to previous match.
Misc: % find the coresponding item (找到相应的项，例如两个括号之间进行跳转)

selection in normal mode

Visual: v
Visual line: V
Visual block: ctrl + v
Last visual block: gv

edit commands

i insert at now cursor
a append at end
o / O insert line down (below), up (above)
d{motion} delete {motion}. such as dd delete this line, d$ delete to end of line, d0 delete to begin of line, dw delete word, dG delete to end of file, dl delete right character
c{motion} change {motion}. cw change word etc, cl equals to s, cc equals to S
x delete character (equals to dl)
s delete character and start insert (substitute) (equals to xi, and short for cl)
u undo, ctrl + r redo
y copy. such as yy copy this line, yw copy the word, y4l copy right 4 characters
p paste
~ flips the case of a character (大小写转换)
. repeat previous editing command

count with manipulation

3w move 3 words forward
5j move 5 lines down
7dw / d7w delete 7 words
7yw / y7w copy 7 words

vim extensions

since Vim8.0 不再需要额外的插件管理器，使用内置的即可。

将插件放在目录 ~/.vim/pack/vendor/start/ 下（可以使用 git clone 命令）。统一管理 dotfiles 之后安装插件方法见 piaoliangkb/dotfiles 仓库介绍的装方法 (install as git submodules).

Awesome Vim

https://missing.csail.mit.edu/2020/editors/#extending-vim

example install ctrlp:

Install and configure a plugin: ctrlp.vim.
Create the plugins directory with mkdir -p ~/.vim/pack/vendor/start
Download the plugin: cd ~/.vim/pack/vendor/start; git clone https://github.com/ctrlpvim/ctrlp.vim
Read the documentation for the plugin. Try using CtrlP to locate a file by navigating to a project directory, opening Vim, and using the Vim command-line to start :CtrlP.
Customize CtrlP by adding configuration to your ~/.vimrc to open CtrlP by pressing Ctrl-P.

example install lightline:

Install plugin lightline.vim
git clone https://github.com/itchyny/lightline.vim ~/.vim/pack/vendor/start/lightline

搜索和替换

:s （替换）命令（文档）。

```
%s/foo/bar/g
```
- 在整个文件中将 foo 全局替换成 bar
```
%s/\[.*\]($.*$)/\1/g
```
- 将有命名的 Markdown 链接替换成简单 URLs

多窗口

用 :sp / :vsp 来分割窗口
同一个缓存可以在多个窗口中显示。

宏

q{字符} 来开始在寄存器{字符}中录制宏
q停止录制
@{字符} 重放宏
宏的执行遇错误会停止
{计数}@{字符}执行一个宏{计数}次
宏可以递归
- 首先用q{字符}q清除宏
- 录制该宏，用 @{字符} 来递归调用该宏（在录制完成之前不会有任何操作）
例子：将 xml 转成 json (file)
- 一个有 “name” / “email” 键对象的数组
- 用一个 Python 程序？
- 用 sed / 正则表达式
  - g/people/d
  - %s/<person>/{/g
  - %s/<name>$.*$<\/name>/"name": "\1",/g
  - …
- Vim 命令 / 宏
  - Gdd, ggdd 删除第一行和最后一行
  - 格式化最后一个元素的宏（寄存器）
    e
    - 跳转到有 <name> 的行
    - qe^r"f>s": "<ESC>f<C"<ESC>q
  - 格式化一个
    
    的宏
    - 跳转到有 <person> 的行
    - qpS{<ESC>j@eA,<ESC>j@ejS},<ESC>q
  - 格式化一个
    
    标签然后转到另外一个的宏
    - 跳转到有 <person> 的行
    - qq@pjq
  - 执行宏到文件尾
    - 999@q
  - 手动移除最后的 , 然后加上 [ 和 ] 分隔符

扩展资料

vimtutor 是一个 Vim 安装时自带的教程
Vim Adventures 是一个学习使用 Vim 的游戏
Vim Tips Wiki
Vim Advent Calendar 有很多 Vim 小技巧
Vim Golf 是用 Vim 的用户界面作为程序语言的 code golf
Vi/Vim Stack Exchange
Vim Screencasts
Practical Vim（书籍）

课后练习

习题解答

完成 vimtutor。备注：它在一个 80x24（80 列，24 行）终端窗口看起来效果最好。
下载我们提供的 vimrc，然后把它保存到 ~/.vimrc。通读这个注释详细的文件（用 Vim!），然后观察 Vim 在这个新的设置下看起来和使用起来有哪些细微的区别。
安装和配置一个插件：

ctrlp.vim
1. 用 mkdir -p ~/.vim/pack/vendor/start 创建插件文件夹
2. 下载这个插件： cd ~/.vim/pack/vendor/start; git clone https://github.com/ctrlpvim/ctrlp.vim
3. 阅读这个插件的文档。尝试用 CtrlP 来在一个工程文件夹里定位一个文件，打开 Vim, 然后用 Vim 命令控制行开始 :CtrlP.
4. 自定义 CtrlP：添加 configuration 到你的 ~/.vimrc 来用按 Ctrl-P 打开 CtrlP
练习使用 Vim, 在你自己的机器上重做演示。
下个月用 Vim 完成_所有的_文件编辑。每当不够高效的时候，或者你感觉 “一定有一个更好的方式”时，尝试求助搜索引擎，很有可能有一个更好的方式。如果你遇到难题，可以来我们的答疑时间或者给我们发邮件。
在其他工具中设置 Vim 快捷键（见上面的操作指南）。
进一步自定义你的 ~/.vimrc 和安装更多插件。
（高阶）用 Vim 宏将 XML 转换到 JSON (例子文件)。尝试着先完全自己做，但是在你卡住的时候可以查看上面宏章节。

`Vimtutor`笔记

KEY	ACTION
x	删除一次字符
dw	删除一个单词
d$	从当前位置至行尾，全部删除
p	将删除的文本粘贴到光标行之后
rx	将光标处的字符替换为 x
ce	替换单词，直到单词结尾
CTRL-G	显示光标所在行号和文件状态
G	跳转到最后一行
number G	跳转到第 number 行
gg	跳转到第一行
/	向前搜索
?	向后搜索
n	搜索下一个
N	搜索上一个
Ctrl-O	返回较旧位置
Ctrl-I	跳转到较新位置
%	寻找匹配的 ), ], 或 }
:s/old/new/g	使用 ‘new’ 替换 ‘old’
:#,#s/old/new/g	#,# 是行号，替换两行之间的文本
:%s/old/new/g	全文范围内查找替换
:%s/old/new/gc	全文范围内查找替换，每次替换前需用户确定
!`<cmd>`	执行外部命令
:w FILENAME	保存文件
v	开启可视化选择模式
:r FILENAME	在当前位置插入文件内容 retrieve
:r !ls	插入当前目录下的文件列表
o	在当前行下方插入一行，并进入插入模式
O	在当前行上方插入一行，并进入插入模式
R	进入替换模式
y	拷贝
:set ic	忽略大小写
:set noic	大小写敏感
:set hls	开启高亮搜索
:set ic	开启递增搜索
:help	获取帮助
Ctrl-W Ctrl-W	在窗口间跳转
:e ~/.vimrc	编辑 vim 配置文件
:r $VIMRUNTIME/vimrc_example.vim	插入 vim 配置文件示例
:help vimrc-intro	查看 vim 配置文件的文档介绍
:set nocp	进入非兼容模式
Ctrl-D and `<TAB>`	自动补全命令

很多修改文本的命令，通常包含一个操作符和一个动作。常见的动作如下表所示：

KEY	MOTION
w	直到下一个单词开始，不包含它的第一个字符
e	直到当前单词结尾，包含最后一个字符
$	直到行尾，包含最后一个字符

补充：

dd: delete a whole line
2dd: delete two lines
0: move to the start of the line using a zero
U(capital): to undo all changes on a line
u(lowercase): to undo previous actio

valgrind note

2022-06-14T00:00:00+08:00

Using Valgrind to find segfaults

Edit the Makefile to include the -g flag in CFLAGS to provide debugging information to Valgrind.

Compile

linked_list.c

and

test_linked_list.c

by executing

make linked_list

By default, memcheck is the tool that is run when you invoke Valgrind. The documentation on Valgrind’s memcheck is very useful, as it provides examples of the most common error messages, what they mean, and some optional arguments you can use to help debug them.

Box 1. This shows us the command that we are running through Valgrind.

Box 2. This is a print statement from our program.

Box 3. We are reading 8 bytes from an invalid memory address on linked_list.c line 62.

Box 4. Our program received a segfault by accessing invalid memory on linked_list.c line 62

Box 5. There were no memory leaks at the time that the program exited.

Box 6. We encountered 1 error.

Remember from Lab01 that (*head)->next produced a segfault because we forgot to check if *head==NULL. Fix this error, run your code through Valgrind again, and you should see that there are no errors reported by valgrind.

Using Valgrind to detect memory leaks

Let’s cause a memory leak in test_linked_list.c. Comment out the line that calls free_list.
Run make linked_list to compile your code.
Run valgrind
```
valgrind ./linked_list
```
We can see that our program is still producing the correct result based on the printed messages “Congrats…”; however, we are now experiencing memory leaks. Valgrind tells us to “Rerun with –leak-check=full to see details of leaked memory”, so let’s do that
```
valgrind --leak-check=full ./linked_list
```

Box 1. Summary of heap usage. There were 80 bytes allocated in 5 different blocks in the heap at the time of exit.

Box 2. Stack trace showing where the unfreed blocks were allocated.

Direct blocks are those which are root nodes (blocks of memory that the programmer has direct access to, ex stack/global pointer to the heap).
Indirect blocks are those which are not root nodes (ex a pointer inside of a struct).

Box 3. Summary of leak. You can find more info about memory leaks in the Valgrind docs

You can use the stack trace to see where the unfreed blocks were allocated. Hopefully this example will help you understand Valgrind messages when you are completing your projects

Understanding Linux File Permission

2022-06-14T00:00:00+08:00

Understanding Linux File Permission

In Linux, file permissions, attributes, and ownership control the access level that the system processes and users have to files. This ensures that only authorized users and process can access specific files and directories.

Linux File Permissions

The basic Linux permissions models works by associating each system file with an owner and a group and assigning permissions access rights for three different classes of users:

The file owner
The group members
Others(everybody else)

File ownership can be changed using the chown and chgrp commands.

Three files permissions types apply to each class of users:

The read permission
The write permission
The execute permission

This concept allows u to control which users can read the file, write to the file, or execute the file.

To view the file permissions, use the ls command:

ls -l file_name

-rw-r--r-- 12 linuxize users 12.0K Apr  28 10:10 file_name
|[-][-][-]-   [------] [---]
| |  |  | |      |       |
| |  |  | |      |       +-----------> 7. Group
| |  |  | |      +-------------------> 6. Owner
| |  |  | +--------------------------> 5. Alternate Access Method
| |  |  +----------------------------> 4. Others Permissions
| |  +-------------------------------> 3. Group Permissions
| +----------------------------------> 2. Owner Permissions
+------------------------------------> 1. File Type

The first character indicates the file type. It can be a regular file (-), directory (d), a symbolic link (l), or other special types of files. The following nine characters represent the file permissions, three triplets of three characters each. The first triplet shows the owner permissions, the second one group permissions, and the last triplet shows everybody else permissions.

In the example above (rw-r--r--) means that the file owner has read and write permissions (rw-), the group and others have only read permissions (r--).

File permissions have a different meaning depending on the file type.

Each of the three permission triplets can be constructed of the following characters and have different effects, depending on whether they are set to a file or to a directory:

Effect of Permissions on Files

Permission	Character	Meaning on File
Read	-	The file is not readable.
	r	The file is readable
Write	-	The file cannot be changed or modified.
	w	The file can be changed or modified.
Execute	-	The file cannot be executed.
	x	The file can be executed.
	s	If found in the `user` triplet, it sets the `setuid` bit. If found in the `group` triplet, it sets the `setgid` bit. It also means that `x` flag is set. When the `setuid` or `setgid` flags are set on an executable file, the file is executed with the file’s owner and/or group privileges.
	S	Same as `s`, but the `x` flag is not set. This flag is rarely used on files.
	t	If found in the `others` triplet, it sets the `sticky` bit. It also means that `x` flag is set. This flag is useless on files.
	T	Same as, `t` but the `x` flag is not set. This flag is useless on files.

Changing File permissions

The File permissions can be changed using the chmod command. Only root, the file owner, or user with sudo privileges can change the permissions of a file. Be extra careful when using chmod, especially when recursively changing the permissions. The command can accept one or more files and/or directories separated by space as arguments.

Shell tools and scripts

2022-06-14T00:00:00+08:00

Solution-Shell工具和脚本

使用ls命令
- 所有文件（包括隐藏文件）：-a
- 文件打印以人类可以理解的格式输出：-h
- 文件以最近访问顺序排序：-t
- 以彩色文本显示输出结果–color=auto
编写两个bash函数marco和polo执行下面的操作。每当你执行marco，当前的工作目录应当以某种形式保存，当执行polo时，无论现在处在什么目录下，都应当cd 回到当时执行marco的目录。为了方便debug，你可以把代码写在单独的文件marco.sh中，并通过souce marco.sh命令，（重新）加载函数。通过source来加载函数，随后可以在bash中直接使用。
```
#!/bin/bash
marco(){
	echo "$(pwd)" > $HOME/marco_history.log
	echo "save pwd $(pwd)"
}
   
polo(){
	cd "$(cat "$HOME/marco_history.log")"
}
```
```
#!/bin/bash
marco(){
	export MARCO=$(pwd)
}
   
polo(){
	cd "$MARCO"
}
```

假设你有一个命令，它很少出错。因此为了在出错时能够对其进行测试，需要花费大量的时间重现错误并捕获错误。编写一段bash脚本，运行如下的脚本知道它出错，将它的标准输出和标准错误流记录到文件，并在最后输出所有内容。加分项：报告脚本在失败前共运行了多少次。

 #!/usr/bin/env bash
   
 n=$(( RANDOM % 100 ))
   
 if [[ n -eq 42 ]]; then
     echo "Something went wrong"
     >&2 echo "The error was using magic numbers"
     exit 1
 fi
   
 echo "Everything went according to plan"
   

 count=1
   
 while true
 do
     ./buggy.sh 2> out.log
     if [[ $? -ne 0 ]]; then
         echo "failed after $count times"
         cat out.log
         break
     fi
     ((count++))
   
 done
#-----------------------------------------
 for ((count=1;;count++))
 do
     ./buggy.sh 2> out.log
     if [[ $? -ne 0 ]]; then
         echo "failed after $count times"
         cat out.log
         break
   
     echo "$count try"
     fi
 done
#-----------------------------------------
 count=0
 until [[ "$?" -ne 0 ]];
 do
     count=$((count+1))
     ./random.sh 2> out.txt
 done
   
 echo "found error after $count runs"
 cat out.txt
   

本节课我们讲解的 find 命令中的 -exec 参数非常强大，它可以对我们查找的文件进行操作。如果我们要对所有文件进行操作呢？例如创建一个zip压缩文件？我们已经知道，命令行可以从参数或标准输入接受输入。在用管道连接命令时，我们将标准输出和标准输入连接起来，但是有些命令，例如tar 则需要从参数接受输入。这里我们可以使用xargs命令，它可以使用标准输入中的内容作为参数。例如 ls | xargs rm 会删除当前目录中的所有文件。您的任务是编写一个命令，它可以递归地查找文件夹中所有的HTML文件，并将它们压缩成zip文件。注意，即使文件名中包含空格，您的命令也应该能够正确执行（提示：查看 xargs的参数-d
1. 首先创建所需的文件
```
mkdir html_root
cd html_root
touch {1..10}.html
mkdir html
cd html
touch xxxx.html
      
```
2. 执行find命令
```
  #for Linux
  find . -type f -name "*.html" | xargs -d '\n'  tar -cvzf html.zip
```
编写一个命令或脚本递归的查找文件夹中最近使用的文件。更通用的做法，你可以按照最近的使用时间列出文件吗？find . -type f -print0 | xargs -0 ls -lt | head -1

当文件数量较多时，上面的解答会得出错误结果，解决办法是增加 -mmin 条件，先将最近修改的文件进行初步筛选再交给ls进行排序显示 find . -type f -mmin -60 -print0 | xargs -0 ls -lt | head -10

Lab_until

2022-06-14T00:00:00+08:00

xv6 takes the traditional form of `kernel`, a special program that provides services to running programs. Each running program, called a process, has memory containing instructions, data and a stack. The instructions implement the program;s computation. The data are the variables on which the computation acts. The  stack organizes the program's procedure calls.

Process and memory

A xv6 process consists of user-space memory(instructions, data, and stack) and per-process state private to the kernel. Xv6 times-shares process: it transparently switches the available CPUs among the set of processes waiting to execute. When a process is not executing, xv6 saves its CPU registers, restoring them when it next runs the process. The kernel associates a process identifier, or PID, with each process.

A process may create a new process using the fork system call. Fork gives the new process exactly the same memory contents(both instructions and data) as the calling process. fork returns the new process’s PID. In the new process, fork returns zero. The original and new processes are often called parent and child.

if(pid > 0){
	printf("parent: child=%d\n", pid);
	pid = wait((int *) 0);
	printf("child %d is done\n", pid);
} else if(pid == 0){
	printf("child: exiting\n");
	exit(0);
} else {
	printf("fork error\n");
}

Course overview and Basic knowledge

2022-06-14T00:00:00+08:00

课程概览和Shell

当你在shell执行命令时，实际上实在执行一段shell可以解释执行的简短代码。如果你要求shell执行某个命令，但是该命令并不是shell所了解的变成关键字，那么它会去咨询环境变量$PATH，它会列出当shell接到某条指令时，进行程序搜索的路径：

missing:~$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
missing:~$ which echo
/bin/echo
missing:~$ /bin/echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

当我们执行 echo 命令时，shell 了解到需要执行 echo 这个程序，随后它便会在 $PATH 中搜索由 : 所分割的一系列目录，基于名字搜索该程序。当找到该程序时便执行（假定该文件是 可执行程序，后续课程将详细讲解）。确定某个程序名代表的是哪个具体的程序，可以使用 which 程序。我们也可以绕过 $PATH，通过直接指定需要执行的程序的路径来执行该程序

在程序间创建连接

在shell中，程序有两个主要的“流”：它们的输入流和输出流。当程序尝试读取信息时，它们会从输入流中进行读取，当程序打印信息时在 shell 中，程序有两个主要的“流”：它们的输入流和输出流。当程序尝试读取信息时，它们会从输入流中进行读取，当程序打印信息时，它们会将信息输出到输出流中。通常，一个程序的输入输出流都是您的终端。也就是，您的键盘作为输入，显示器作为输出。但是，我们也可以重定向这些流！

最简单的重定向是 < file 和 > file。这两个命令可以将程序的输入输出流分别重定向到文件：

missing:~$ echo hello > hello.txt
missing:~$ cat hello.txt
hello
missing:~$ cat < hello.txt
hello
missing:~$ cat < hello.txt > hello2.txt
missing:~$ cat hello2.txt
hello

您还可以使用 >> 来向一个文件追加内容。使用管道（ pipes ），我们能够更好的利用文件重定向。 | 操作符允许我们将一个程序的输出和另外一个程序的输入连接起来：

missing:~$ ls -l / | tail -n1
drwxr-xr-x 1 root  root  4096 Jun 20  2019 var
missing:~$ curl --head --silent google.com | grep --ignore-case content-length | cut --delimiter=' ' -f2
219

有一件事情是您必须作为根用户才能做的，那就是向 sysfs 文件写入内容。系统被挂载在 /sys 下，sysfs 文件则暴露了一些内核（kernel）参数。因此，您不需要借助任何专用的工具，就可以轻松地在运行期间配置系统内核。注意 Windows 和 macOS 没有这个文件

例如，您笔记本电脑的屏幕亮度写在 brightness 文件中，它位于

/sys/class/backlight

通过将数值写入该文件，我们可以改变屏幕的亮度。现在，蹦到您脑袋里的第一个想法可能是：

$ sudo find -L /sys/class/backlight -maxdepth 2 -name '*brightness*'
/sys/class/backlight/thinkpad_screen/brightness
$ cd /sys/class/backlight/thinkpad_screen
$ sudo echo 3 > brightness
An error occurred while redirecting file 'brightness'
open: Permission denied

出乎意料的是，我们还是得到了一个错误信息。毕竟，我们已经使用了 sudo 命令！关于 shell，有件事我们必须要知道。|、>、和 < 是通过 shell 执行的，而不是被各个程序单独执行。 echo 等程序并不知道 | 的存在，它们只知道从自己的输入输出流中进行读写。对于上面这种情况， shell (权限为您的当前用户) 在设置 sudo echo 前尝试打开 brightness 文件并写入，但是系统拒绝了 shell 的操作因为此时 shell 不是根用户。

明白这一点后，我们可以这样操作：

$ echo 3 | sudo tee brightness

因为打开 /sys 文件的是 tee 这个程序，并且该程序以 root 权限在运行，因此操作可以进行。这样您就可以在 /sys 中愉快地玩耍了，例如修改系统中各种LED的状态（路径可能会有所不同）

$ echo 1 | sudo tee /sys/class/leds/input6::scrolllock/brightness

本课程需要使用类Unix shell，例如 Bash 或 ZSH。如果您在 Linux 或者 MacOS 上面完成本课程的练习，则不需要做任何特殊的操作。如果您使用的是 Windows，则您不应该使用 cmd 或是 Powershell；您可以使用Windows Subsystem for Linux或者是 Linux 虚拟机。使用echo $SHELL命令可以查看您的 shell 是否满足要求。如果打印结果为/bin/bash或/usr/bin/zsh则是可以的。
在 /tmp 下新建一个名为 missing 的文件夹。
用 man 查看程序 touch 的使用手册。
用 touch 在 missing 文件夹中新建一个叫 semester 的文件。
将以下内容一行一行地写入
```
semester
```
文件：
```
 #!/bin/sh
 curl --head --silent https://missing.csail.mit.edu
```
第一行可能有点棘手， # 在Bash中表示注释，而 ! 即使被双引号（"）包裹也具有特殊的含义。单引号（'）则不一样，此处利用这一点解决输入问题。更多信息请参考 Bash quoting 手册
尝试执行这个文件。例如，将该脚本的路径（./semester）输入到您的shell中并回车。如果程序无法执行，请使用 ls 命令来获取信息并理解其不能执行的原因。
查看 chmod 的手册(例如，使用 man chmod 命令)
使用 chmod 命令改变权限，使 ./semester 能够成功执行，不要使用 sh semester 来执行该程序。您的 shell 是如何知晓这个文件需要使用 sh 来解析呢？更多信息请参考：shebang
使用 | 和 > ，将 semester 文件输出的最后更改日期信息，写入主目录下的 last-modified.txt 的文件中
写一段命令来从 /sys 中获取笔记本的电量信息，或者台式机 CPU 的温度。注意：macOS 并没有 sysfs，所以 Mac 用户可以跳过这一题。

人脸美颜

2021-09-18T00:00:00+08:00

实时人脸美颜实现

项目所需库

dlib Dlib是一个包含机器学习算法的C++开源工具包。Dlib可以帮助您创建很多复杂的机器学习方面的软件来帮助解决实际问题。目前Dlib已经被广泛的用在行业和学术领域，包括机器人，嵌入式设备，移动电话和大型高性能计算环境。
Opencv

OpenCV（Open Source Computer Vision Library）开放源代码计算机视觉库，主要算法涉及图像处理、计算机视觉和机器学习相关方法。OpenCV 其实就是一堆 C 和 C++语言的源代码文件，这些源代码文件中实现了许多常用的计算机视觉算法。OpenCV 可用于开发实时的图像处理、计算机视觉以及模式识别程序。 OpenCV由一系列C函数和C++类构成，它有C，C++，Python和java接口，当前SDK（Software Development Kit软件开发工具包）已经支持C++、Java、Python等语言应用开发，当前OpenCV本身新开发的算法和模块接口都是基于C++产生。其覆盖了工业产品检测、医学成像、无人机飞行、无人驾驶、安防、卫星地图与电子地图拼接、信息安全、用户界面、摄像机标定、立体视觉和机器人等计算机视觉应用领域.

实现思路

项目目的是对视频流中出现的每一张人脸进行美颜，每一张图片分为人脸区域和非人脸区域，我们只希望处理人脸区域。所以我们首先利用Dlib库提取出每张图片中人脸特征点的信息，将只包含人脸部分的图像提取出来，我们知道每张人脸由五官，脸颊，下巴和额头组成，我们希望能对每个区域进行不同的美颜处理，这就需要我们将各个部位的特征点信息单独提取提取出来，然后对各个部分的特征点信息进行相应不同的操作。实现代码如下：

PREDICTOR_PATH = './data'
detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor(PREDICTOR_PATH)

def get_landmarks(im):
    rects = detector(im, 1)
    return [numpy.matrix([[p.x, p.y] for p in predictor(im, rect).parts()]) for rect in rects]

organs_name=['jaw','mouth','nose','left eye','right eye','left brow','right brow']
organs_points=[list(range(0, 17)),list(range(48, 61)),list(range(27, 35)),list(range(42, 48)),list(range(36, 42)),list(range(22, 27)),list(range(17, 22))]

我们怎么利用这些坐标来针对每个部件的有效区域进行美化处理呢？

首先，获得特征点坐标的边界，再根据区域大小，适当扩大一部分，取对应的储存图片数据的Numpy数组的切片。这样我们就得到了全局图片的一个局部切片

def get_rect(self):
    '''
    获得定位方框
    '''
    ys,xs=self.landmark[:,1],self.landmark[:,0]
    self.top,self.bottom,self.left,self.right=np.min(ys),np.max(ys),np.min(xs),np.max(xs)
self.shape=(int(self.bottom-self.top),int(self.right-self.left))
self.size=self.shape[0]*self.shape[1]*3
self.move=int(np.sqrt(self.size/3)/20)
patch=im[np.max([self.top-self.move,0]):np.min([self.bottom+self.move,shape[0]]),np.max([self.left-self.move,0]):np.min([self.right+self.move,shape[1]])]

接下来我们要根据特征点在一个和局部切片形状相同的mask图册被封杀部分勾画部件轮廓。这个mask层只在有效区域值为0-1，其余部分为0.我们使用opencv的convexHull和fillConvexPoly函数。同时，我们不希望遮罩很僵硬，使用要用高斯模糊处理。

def _draw_convex_hull(self,im, points, color):
    '''
    勾画多凸边形
    '''
    points = cv2.convexHull(points)
    cv2.fillConvexPoly(im, points, color=color)
    
def get_mask_re(self,ksize=None):
    '''
    获得局部相对坐标遮罩
    '''
    if ksize==None:
        ksize=self.ksize
    landmark_re=self.landmark.copy()
    landmark_re[:,1]-=np.max([self.top-self.move,0])
    landmark_re[:,0]-=np.max([self.left-self.move,0])
    mask = np.zeros(self.patch_bgr.shape[:2], dtype=np.float64)

    self._draw_convex_hull(mask,
                     landmark_re,
                     color=1)

    mask = np.array([mask, mask, mask]).transpose((1, 2, 0))

    mask = (cv2.GaussianBlur(mask, ksize, 0) > 0) * 1.0
    return cv2.GaussianBlur(mask, ksize, 0)[:]

如图，这是得到的鼻子和嘴的mask和切片patch

这样我们就可以逐步得到眼睛、鼻子、嘴巴、眉毛的mask和patch，我们把它们放在全局图片并相加，就能得到全部五官的有效区域。

特别的，dlib的特征提取器并不能返回额头的边界坐标，所以我们需要自己计算额头的特征坐标。

画额头

基于小学时培养的绘画素养，我假设额头大体是一个中心在眉心附近的，长轴=短轴=脸宽且与双眼连线平行的一个的半椭圆。

要画出这样一个半椭圆，我们首先要知道脸宽、中心点、长轴偏移角度，然后使用opencv的ellipse函数。

      #画椭圆
        radius=(np.linalg.norm(face_landmark[0]-face_landmark[16])/2).astype('int32')
        center_abs=tuple(((face_landmark[0]+face_landmark[16])/2).astype('int32'))
        
        angle=np.degrees(np.arctan((lambda l:l[1]/l[0])(face_landmark[16]-face_landmark[0]))).astype('int32')
        mask=np.zeros(mask_organs.shape[:2], dtype=np.float64)
        cv2.ellipse(mask,center_abs,(radius,radius),angle,180,360,1,-1)

然而这个椭圆（半圆）只是一个对脑门部位的粗略估计，我们还需要将其他部件、头发、背景等部分剔除出去。

我们根据鼻子的肤色来判定一个区域是否为真正的脑门，最后用convexHull勾画一个包括所有脑门区域的点的特征点轮廓

      #剔除与五官重合部分
        mask[mask_organs[:,:,0]>0]=0
        #根据鼻子的肤色判断真正的额头面积
        index_bool=[]
        for ch in range(3):
            mean,std=np.mean(im_bgr[:,:,ch][mask_nose[:,:,ch]>0]),np.std(im_bgr[:,:,ch][mask_nose[:,:,ch]>0])
            up,down=mean+0.5*std,mean-0.5*std
            index_bool.append((im_bgr[:,:,ch]<down)|(im_bgr[:,:,ch]>up))
        index_zero=((mask>0)&index_bool[0]&index_bool[1]&index_bool[2])
        mask[index_zero]=0
        index_abs=np.array(np.where(mask>0)[::-1]).transpose()
        landmark=cv2.convexHull(index_abs).squeeze()
        return landmark

再根据求得的坐标实例化一个部件类，去除与其他部件重合的部分，获得mask、patch。

“脸”对象

现在，我们已经获得了全部的面部部件的坐标点和各自的遮罩层。于是，可以求得所有部件的集合，以及整个脸部的patch和除了部件之外的部分的mask，来实例化一个“脸对象”。

我们用一个字典organs来储存部件的集合，键值是部件名称如nose，通过get_mask_abs()方法来获得部件相当于全局图片的遮罩。

我们根据所有的坐标点，调用super方法调用父类Organ的实例化函数，再用mask减去其他部件的mask得到纯脸部的mask。

      mask_organs=(self.organs['mouth'].get_mask_abs()+mask_nose+self.organs['left eye'].get_mask_abs()+self.organs['right eye'].get_mask_abs()+self.organs['left brow'].get_mask_abs()+self.organs['right brow'].get_mask_abs())
        forehead_landmark=self.get_forehead_landmark(im_bgr,landmarks,mask_organs,mask_nose)
        self.organs['forehead']=Forehead(im_bgr,img_hsv,temp_bgr,temp_hsv,forehead_landmark,mask_organs,'forehead')
        mask_organs+=self.organs['forehead'].get_mask_abs()

        # 人脸的完整标记点
        self.FACE_POINTS = np.concatenate([landmarks,forehead_landmark])
        super(Face,self).__init__(im_bgr,img_hsv,temp_bgr,temp_hsv,self.FACE_POINTS,'face')

        mask_face=self.get_mask_abs()-mask_organs
        self.patch_mask=self.get_patch(mask_face)

至此，我们勾画出来全部有效区域，接下来我们要为这些有效区域添加美化方法。

美化方法

本项目目前实现了提亮美白、增加鲜艳度、磨皮、锐化四种基本的美化方法，Organ类及其子类Face、Forehead都有这些方法，这样我们就可以根据需要组合使用这些方法，对不同部位进行具体的美化。

提亮美白

我们知道，图片的颜色空间除了三原色的RGB（BGR）还有HSV和HSL。

HSV即色相、饱和度、明度（英语：Hue, Saturation, Value），又称HSB，其中B即英语：Brightness。色相（H）是色彩的基本属性，就是平常所说的颜色名称，如红色、黄色等。饱和度（S）是指色彩的纯度，越高色彩越纯，低则逐渐变灰，取0-100%的数值。明度（V），亮度（L），取0-100%。

相对于BGR，HSV更接近人类的视觉直觉，在本项目中，美白和增加鲜艳度就在hsv空间进行。

hsv空间的图片，v通道的值代表各像素的亮度，所以我们只需要增加有效区域的v值就可以了

  def whitening(self,rate=0.15,confirm=True):
        '''
        提亮美白
        arguments:
            rate:float,-1~1,new_V=min(255,V*(1+rate))
            confirm:wether confirm this option
        '''
        if confirm:
            self.confirm()
            self.patch_hsv[:,:,-1]=np.minimum(self.patch_hsv[:,:,-1]+self.patch_hsv[:,:,-1]*self.patch_mask[:,:,-1]*rate,255).astype('uint8')
            self.im_bgr[:]=cv2.cvtColor(self.im_hsv, cv2.COLOR_HSV2BGR)[:]
            self.update_temp()
        else:
            self.patch_hsv_temp[:]=cv2.cvtColor(self.patch_bgr_temp, cv2.COLOR_BGR2HSV)[:]
            self.patch_hsv_temp[:,:,-1]=np.minimum(self.patch_hsv_temp[:,:,-1]+self.patch_hsv_temp[:,:,-1]*self.patch_mask[:,:,-1]*rate,255).astype('uint8')
            self.patch_bgr_temp[:]=cv2.cvtColor(self.patch_hsv_temp, cv2.COLOR_HSV2BGR)[:]

注意到，我们使用

self.patch_hsv_temp[:,:,-1]*self.patch_mask[:,:,-1]*rate

来表示对于有效区域的更改值，在其他美化方法中我们还会使用类似的方法。同时我们预留了confirm参数，如果为FALSE，则更改只在一个全局的临时copy上进行。

增加鲜艳度

同理，增加鲜艳度的操作也在hsv空间进行，增大s通道的值。

  def brightening(self,rate=0.3,confirm=True):
        '''
        提升鲜艳度
        arguments:
            rate:float,-1~1,new_S=min(255,S*(1+rate))
            confirm:wether confirm this option
        '''
        patch_mask=self.get_mask_re((1,1))
        if confirm:
            self.confirm()
            patch_new=self.patch_hsv[:,:,1]*patch_mask[:,:,1]*rate
            patch_new=cv2.GaussianBlur(patch_new,(3,3),0)
            self.patch_hsv[:,:,1]=np.minimum(self.patch_hsv[:,:,1]+patch_new,255).astype('uint8')
            self.im_bgr[:]=cv2.cvtColor(self.im_hsv, cv2.COLOR_HSV2BGR)[:]
            self.update_temp()
        else:
            self.patch_hsv_temp[:]=cv2.cvtColor(self.patch_bgr_temp, cv2.COLOR_BGR2HSV)[:]
            patch_new=self.patch_hsv_temp[:,:,1]*patch_mask[:,:,1]*rate
            patch_new=cv2.GaussianBlur(patch_new,(3,3),0)
            self.patch_hsv_temp[:,:,1]=np.minimum(self.patch_hsv[:,:,1]+patch_new,255).astype('uint8')
            self.patch_bgr_temp[:]=cv2.cvtColor(self.patch_hsv_temp, cv2.COLOR_HSV2BGR)[:]

磨皮

磨皮即是去除皮肤上痘痘、皱纹等等噪音，让皮肤更加平滑。这里我们使用高斯滤波器和双边滤波器在BGR空间进行操作。

其中kernelsize是根据patch大小计算得到的。

  def get_ksize(self,rate=15):
        size=max([int(np.sqrt(self.size/3)/rate),1])
        size=(size if size%2==1 else size+1)
        return (size,size)
    def smooth(self,rate=0.6,ksize=None,confirm=True):
        '''
        磨皮
        arguments:
            rate:float,0~1,im=rate*new+(1-rate)*src
            confirm:wether confirm this option
        '''
        if ksize==None:
            ksize=self.get_ksize(80)
        index=self.patch_mask>0
        if confirm:
            self.confirm()
            patch_new=cv2.GaussianBlur(cv2.bilateralFilter(self.patch_bgr,5,*ksize),ksize,0)
            self.patch_bgr[index]=np.minimum(rate*patch_new[index]+(1-rate)*self.patch_bgr[index],255).astype('uint8')
            self.im_hsv[:]=cv2.cvtColor(self.im_bgr, cv2.COLOR_BGR2HSV)[:]
            self.update_temp()
        else:
            patch_new=cv2.GaussianBlur(cv2.bilateralFilter(self.patch_bgr_temp,3,*ksize),ksize,0)
            self.patch_bgr_temp[index]=np.minimum(rate*patch_new[index]+(1-rate)*self.patch_bgr_temp[index],255).astype('uint8')
            self.patch_hsv_temp[:]=cv2.cvtColor(self.patch_bgr_temp, cv2.COLOR_BGR2HSV)[:]

锐化

锐化算法我使用的是最简单的卷积锐化算法

用一个形如

的卷积核去对图像进行卷积。

  def sharpen(self,rate=0.3,confirm=True):
        '''
        锐化
        '''
        ksize=self.get_ksize(10)
        patch_mask=self.get_mask_re((3,3))
        kernel = np.zeros( ksize, np.float32)
        center=int(ksize[0]/2)
        kernel[center,center] = 2.0   #Identity, times two! 
        #Create a box filter:
        boxFilter = np.ones( ksize, np.float32) / (ksize[0]*ksize[1])
        
        #Subtract the two:
        kernel = kernel - boxFilter
        index=patch_mask>0
        if confirm:
            self.confirm()
            sharp=cv2.filter2D(self.patch_bgr,-1,kernel)
            self.patch_bgr[index]=np.minimum(((1-rate)*self.patch_bgr)[index]+sharp[index]*rate,255).astype('uint8')
            self.update_temp()
        else:
            sharp=cv2.filter2D(self.patch_bgr_temp,-1,kernel)
            self.patch_bgr_temp[:]=np.minimum(self.patch_bgr_temp+self.patch_mask*sharp*rate,255).astype('uint8')
            self.patch_hsv_temp[:]=cv2.cvtColor(self.patch_bgr_temp, cv2.COLOR_BGR2HSV)[:]

至此，所有的基本美化方法就都成型了，我们在需要美化图片的时候只需要调用对应部位的美化方法就可以了。

化妆器对象

dlib的模型加载需要时间，我们希望一次加载可以处理多个图片，读取和保存图片、提取特征也有各自的方法，所以我们需要一个化妆器对象来维持秩序数据和方法的生存周期。

class Makeup():
    '''
    化妆器
    '''
    def __init__(self,predictor_path="./data/shape_predictor_68_face_landmarks.dat"):
        self.photo_path=[]
        self.PREDICTOR_PATH = predictor_path
        self.faces={}
        
        #人脸定位、特征提取器，来自dlib
        self.detector = dlib.get_frontal_face_detector()
        self.predictor = dlib.shape_predictor(self.PREDICTOR_PATH)

    def get_faces(self,im_bgr,im_hsv,temp_bgr,temp_hsv,name,n=1):
        '''
        人脸定位和特征提取，定位到两张及以上脸或者没有人脸将抛出异常
        im:
            照片的numpy数组
        fname:
            照片名字的字符串
        返回值:
            人脸特征(x,y)坐标的矩阵
        '''
        rects = self.detector(im_bgr, 1)
        
        if len(rects) <1:
            raise NoFace('Too many faces in '+name)
        return {name:[Face(im_bgr,im_hsv,temp_bgr,temp_hsv,np.array([[p.x, p.y] for p in self.predictor(im_bgr, rect).parts()]),i) for i,rect in enumerate(rects)]}

    def read_im(self,fname,scale=1):
        '''
        读取图片
        '''
        im = cv2.imdecode(np.fromfile(fname,dtype=np.uint8),-1)
        if type(im)==type(None):
            print(fname)
            raise ValueError('Opencv error reading image "{}" , got None'.format(fname))
        return im

    def read_and_mark(self,fname):
        im_bgr=self.read_im(fname)
        im_hsv=cv2.cvtColor(im_bgr, cv2.COLOR_BGR2HSV)
        temp_bgr,temp_hsv=im_bgr.copy(),im_hsv.copy()
        return im_bgr,temp_bgr,self.get_faces(im_bgr,im_hsv,temp_bgr,temp_hsv,fname)

read_and_mark方法接受文件路径作为参数，读取图片并定位所有人脸，逐个实例化为Face对象。方法返回全局bgr图片和全局临时图片，以及一个键名为fname，键值为一个Face对象的列表，代表图片内的所有Face对象。

美颜操作

作为示例，我们对所有部分进行美白，除眼睛之外的部位进行磨皮，眼睛锐化实现亮眼，嘴唇提升鲜艳度实现红唇。

处理一张图片的主函数如下：

if __name__=='__main__':
    path='./heads/x.jpg'
    mu=Makeup()
    im,temp_bgr,faces=mu.read_and_mark(path)
    imc=im.copy()
    cv2.imshow('ori',imc)
    for face in faces[path]:
        face.whitening()
        face.smooth(0.7)
        face.organs['forehead'].whitening()
        face.organs['forehead'].smooth(0.7)
        face.organs['mouth'].brightening(0.6)
        face.organs['mouth'].smooth(0.7)
        face.organs['mouth'].whitening()
        face.organs['left eye'].whitening()
        face.organs['right eye'].whitening()
        face.organs['left eye'].sharpen(0.7)
        face.organs['right eye'].sharpen(0.7)
        face.organs['left brow'].whitening()
        face.organs['right brow'].whitening()
        face.organs['left brow'].sharpen()
        face.organs['right brow'].sharpen()
        face.organs['nose'].whitening()
        face.organs['nose'].smooth(0.7)
        face.organs['nose'].sharpen()
    cv2.imshow('new',im.copy())
    cv2.waitKey()
    print('Quiting')

效果如图

Json Parse Strings

2021-09-18T00:00:00+08:00

1. JSON 字符串语法

JSON 的字符串语法和 C 语言很相似，都是以双引号把字符括起来，如 “Hello”。但字符串采用了双引号作分隔，那么怎样可以在字符串中插入一个双引号？把 a”b 写成 “a”b” 肯定不行，都不知道那里是字符串的结束了。因此，我们需要引入转义字符（escape character），C 语言和 JSON 都使用 \（反斜线）作为转义字符，那么 “ 在字符串中就表示为"，a”b 的 JSON 字符串则写成 “a"b”。如以下的字符串语法所示，JSON 共支持 9 种转义序列：

string = quotation-mark *char quotation-mark
char = unescaped /
   escape (
       %x22 /          ; "    quotation mark  U+0022
       %x5C /          ; \    reverse solidus U+005C
       %x2F /          ; /    solidus         U+002F
       %x62 /          ; b    backspace       U+0008
       %x66 /          ; f    form feed       U+000C
       %x6E /          ; n    line feed       U+000A
       %x72 /          ; r    carriage return U+000D
       %x74 /          ; t    tab             U+0009
       %x75 4HEXDIG )  ; uXXXX                U+XXXX
escape = %x5C          ; \
quotation-mark = %x22  ; "
unescaped = %x20-21 / %x23-5B / %x5D-10FFFF

简单翻译一下，JSON 字符串是由前后两个双引号夹着零至多个字符。字符分开无转义字符或转义序列。转义序列有 9 种，都是以反斜线开始，如常见的 \n 代表换行符。比较特殊的是 \uXXXX，当中 XXXX 为 16 进位的 UTF-16 编码，本单元将不处理这种转义序列，留待下回分解。

无转义字符就是普通的字符，语法中列出了合法的码点范围（码点还是在下单元才介绍）。要注意的是，该范围不包括 0 至 31、双引号和反斜线，这些码点都必须要使用转义方式表示。

2. 字符串表示

在 C 语言中，字符串一般表示为空结尾字符串（null-terminated string），即以空字符（’\0’）代表字符串的结束。然而，JSON 字符串是允许含有空字符的，例如这个 JSON “Hello\u0000World” 就是单个字符串，解析后为11个字符。如果纯粹使用空结尾字符来表示 JSON 解析后的结果，就没法处理空字符。

因此，我们可以分配内存来储存解析后的字符，以及记录字符的数目（即字符串长度）。由于大部分 C 程序都假设字符串是空结尾字符串，我们还是在最后加上一个空字符，那么不需处理 \u0000 这种字符的应用可以简单地把它当作是空结尾字符串。

了解需求后，我们考虑实现。lept_value 事实上是一种变体类型（variant type），我们通过 type 来决定它现时是哪种类型，而这也决定了哪些成员是有效的。首先我们简单地在这个结构中加入两个成员：

typedef struct {
    char* s;
    size_t len;
    double n;
    lept_type type;
}lept_value;

然而我们知道，一个值不可能同时为数字和字符串，因此我们可使用 C 语言的 union 来节省内存：

typedef struct {
    union {
        struct { char* s; size_t len; }s;  /* string */
        double n;                          /* number */
    }u;
    lept_type type;
}lept_value;

这两种设计在 32 位平台时的内存布局如下，可看出右方使用 union 的能省下内存。

我们要把之前的 v->n 改成 v->u.n。而要访问字符串的数据，则要使用 v->u.s.s 和 v->u.s.len。这种写法比较麻烦吧，其实 C11 新增了匿名 struct/union 语法，就可以采用 v->n、v->s、v->len 来作访问。

3. 内存管理

由于字符串的长度不是固定的，我们要动态分配内存。为简单起见，我们使用标准库中的malloc()、realloc() 和 free() 来分配／释放内存。

当设置一个值为字符串时，我们需要把参数中的字符串复制一份：

void lept_set_string(lept_value* v, const char* s, size_t len) {
    assert(v != NULL && (s != NULL || len == 0));
    lept_free(v);
    v->u.s.s = (char*)malloc(len + 1);
    memcpy(v->u.s.s, s, len);
    v->u.s.s[len] = '\0';
    v->u.s.len = len;
    v->type = LEPT_STRING;
}

断言中的条件是，非空指针（有具体的字符串）或是零长度的字符串都是合法的。

注意，在设置这个 v 之前，我们需要先调用 lept_free(v) 去清空 v 可能分配到的内存。例如原来已有一字符串，我们要先把它释放。然后就是简单地用 malloc() 分配及用 memcpy() 复制，并补上结尾空字符。malloc(len + 1) 中的 1 是因为结尾空字符。

那么，再看看 lept_free()：

void lept_free(lept_value* v) {
    assert(v != NULL);
    if (v->type == LEPT_STRING)
        free(v->u.s.s);
    v->type = LEPT_NULL;
}

现时仅当值是字符串类型，我们才要处理，之后我们还要加上对数组及对象的释放。lept_free(v) 之后，会把它的类型变成 null。这个设计能避免重复释放。

但也由于我们会检查 v 的类型，在调用所有访问函数之前，我们必须初始化该类型。所以我们加入 lept_init(v)，因非常简单我们用宏实现：

#define lept_init(v) do { (v)->type = LEPT_NULL; } while(0)

用上 do { … } while(0) 是为了把表达式转为语句，模仿无返回值的函数。

其实在前两个单元中，我们只提供读取值的 API，没有写入的 API，就是因为写入时我们还要考虑释放内存。我们在本单元中把它们补全：

#define lept_set_null(v) lept_free(v)

int lept_get_boolean(const lept_value* v);
void lept_set_boolean(lept_value* v, int b);

double lept_get_number(const lept_value* v);
void lept_set_number(lept_value* v, double n);

const char* lept_get_string(const lept_value* v);
size_t lept_get_string_length(const lept_value* v);
void lept_set_string(lept_value* v, const char* s, size_t len);

由于 lept_free() 实际上也会把 v 变成 null 值，我们只用一个宏来提供 lept_set_null() 这个 API。

应用方的代码在调用 lept_parse() 之后，最终也应该调用 lept_free() 去释放内存。我们把之前的单元测试也加入此调用。

如果不使用 lept_parse()，我们需要初始化值，那么就像以下的单元测试，先 lept_init()，最后 lept_free()。

static void test_access_string() {
    lept_value v;
    lept_init(&v);
    lept_set_string(&v, "", 0);
    EXPECT_EQ_STRING("", lept_get_string(&v), lept_get_string_length(&v));
    lept_set_string(&v, "Hello", 5);
    EXPECT_EQ_STRING("Hello", lept_get_string(&v), lept_get_string_length(&v));
    lept_free(&v);
}

4. 缓冲区与堆栈

我们解析字符串（以及之后的数组、对象）时，需要把解析的结果先储存在一个临时的缓冲区，最后再用lept_set_string() 把缓冲区的结果设进值之中。在完成解析一个字符串之前，这个缓冲区的大小是不能预知的。因此，我们可以采用动态数组（dynamic array）这种数据结构，即数组空间不足时，能自动扩展。C++ 标准库的 std::vector 也是一种动态数组。

如果每次解析字符串时，都重新建一个动态数组，那么是比较耗时的。我们可以重用这个动态数组，每次解析 JSON 时就只需要创建一个。而且我们将会发现，无论是解析字符串、数组或对象，我们也只需要以先进后出的方式访问这个动态数组。换句话说，我们需要一个动态的堆栈数据结构。

我们把一个动态堆栈的数据放进 lept_context 里：

typedef struct {
    const char* json;
    char* stack;
    size_t size, top;
}lept_context;

当中 size 是当前的堆栈容量，top 是栈顶的位置（由于我们会扩展 stack，所以不要把 top 用指针形式存储）。

然后，我们在创建 lept_context 的时候初始化 stack 并最终释放内存：

int lept_parse(lept_value* v, const char* json) {
    lept_context c;
    int ret;
    assert(v != NULL);
    c.json = json;
    c.stack = NULL;        /* <- */
    c.size = c.top = 0;    /* <- */
    lept_init(v);
    lept_parse_whitespace(&c);
    if ((ret = lept_parse_value(&c, v)) == LEPT_PARSE_OK) {
        /* ... */
    }
    assert(c.top == 0);    /* <- */
    free(c.stack);         /* <- */
    return ret;
}

在释放时，加入了断言确保所有数据都被弹出。

然后，我们实现堆栈的压入及弹出操作。和普通的堆栈不一样，我们这个堆栈是以字节储存的。每次可要求压入任意大小的数据，它会返回数据起始的指针（会 C++ 的同学可再参考[1]）：

#ifndef LEPT_PARSE_STACK_INIT_SIZE
#define LEPT_PARSE_STACK_INIT_SIZE 256
#endif

static void* lept_context_push(lept_context* c, size_t size) {
    void* ret;
    assert(size > 0);
    if (c->top + size >= c->size) {
        if (c->size == 0)
            c->size = LEPT_PARSE_STACK_INIT_SIZE;
        while (c->top + size >= c->size)
            c->size += c->size >> 1;  /* c->size * 1.5 */
        c->stack = (char*)realloc(c->stack, c->size);
    }
    ret = c->stack + c->top;
    c->top += size;
    return ret;
}

static void* lept_context_pop(lept_context* c, size_t size) {
    assert(c->top >= size);
    return c->stack + (c->top -= size);
}

压入时若空间不足，便回以 1.5 倍大小扩展。为什么是 1.5 倍而不是两倍？可参考我在 STL 的 vector 有哪些封装上的技巧？的答案。

注意到这里使用了 realloc() 来重新分配内存，c->stack 在初始化时为 NULL，realloc(NULL, size) 的行为是等价于malloc(size) 的，所以我们不需要为第一次分配内存作特别处理。

另外，我们把初始大小以宏 LEPT_PARSE_STACK_INIT_SIZE 的形式定义，使用 #ifndef X #define X … #endif 方式的好处是，使用者可在编译选项中自行设置宏，没设置的话就用缺省值。

5. 解析字符串

有了以上的工具，解析字符串的任务就变得很简单。我们只需要先备份栈顶，然后把解析到的字符压栈，最后计算出长度并一次性把所有字符弹出，再设置至值里便可以。以下是部分实现，没有处理转义和一些不合法字符的校验。

#define PUTC(c, ch) do { *(char*)lept_context_push(c, sizeof(char)) = (ch); } while(0)

static int lept_parse_string(lept_context* c, lept_value* v) {
    size_t head = c->top, len;
    const char* p;
    EXPECT(c, '\"');
    p = c->json;
    for (;;) {
        char ch = *p++;
        switch (ch) {
            case '\"':
                len = c->top - head;
                lept_set_string(v, (const char*)lept_context_pop(c, len), len);
                c->json = p;
                return LEPT_PARSE_OK;
            case '\0':
                c->top = head;
                return LEPT_PARSE_MISS_QUOTATION_MARK;
            default:
                PUTC(c, ch);
        }
    }
}

1. 访问的单元测试

在编写单元测试时，我们故意先把值设为字符串，那么做可以测试设置其他类型时，有没有调用 lept_free() 去释放内存。

static void test_access_boolean() {
    lept_value v;
    lept_init(&v);
    lept_set_string(&v, "a", 1);
    lept_set_boolean(&v, 1);
    EXPECT_TRUE(lept_get_boolean(&v));
    lept_set_boolean(&v, 0);
    EXPECT_FALSE(lept_get_boolean(&v));
    lept_free(&v);
}

static void test_access_number() {
    lept_value v;
    lept_init(&v);
    lept_set_string(&v, "a", 1);
    lept_set_number(&v, 1234.5);
    EXPECT_EQ_DOUBLE(1234.5, lept_get_number(&v));
    lept_free(&v);
}

以下是访问函数的实现：

int lept_get_boolean(const lept_value* v) {
    assert(v != NULL && (v->type == LEPT_TRUE || v->type == LEPT_FALSE));
    return v->type == LEPT_TRUE;
}

void lept_set_boolean(lept_value* v, int b) {
    lept_free(v);
    v->type = b ? LEPT_TRUE : LEPT_FALSE;
}

double lept_get_number(const lept_value* v) {
    assert(v != NULL && v->type == LEPT_NUMBER);
    return v->u.n;
}

void lept_set_number(lept_value* v, double n) {
    lept_free(v);
    v->u.n = n;
    v->type = LEPT_NUMBER;
}

那问题是，如果我们没有调用 lept_free()，怎样能发现这些内存泄漏？

1A. Windows 下的内存泄漏检测方法

在 Windows 下，可使用 Visual C++ 的 C Runtime Library（CRT）检测内存泄漏。

首先，我们在两个 .c 文件首行插入这一段代码：

#ifdef _WINDOWS
#define _CRTDBG_MAP_ALLOC
#include <crtdbg.h>
#endif

并在 main() 开始位置插入：

int main() {
#ifdef _WINDOWS
    _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
#endif

在 Debug 配置下按 F5 生成、开始调试程序，没有任何异样。

然后，我们删去 lept_set_boolean() 中的 lept_free(v)：

void lept_set_boolean(lept_value* v, int b) {
    /* lept_free(v); */
    v->type = b ? LEPT_TRUE : LEPT_FALSE;
}

再次按 F5 生成、开始调试程序，在输出会看到内存泄漏信息：

Detected memory leaks!
Dumping objects ->
C:\GitHub\json-tutorial\tutorial03_answer\leptjson.c(212) : {79} normal block at 0x013D9868, 2 bytes long.
 Data: <a > 61 00 
Object dump complete.

这正是我们在单元测试中，先设置字符串，然后设布尔值时没释放字符串所分配的内存。比较麻烦的是，它没有显示调用堆栈。从输出信息中 … {79} … 我们知道是第 79 次分配的内存做成问题，我们可以加上 _CrtSetBreakAlloc(79); 来调试，那么它便会在第 79 次时中断于分配调用的位置，那时候就能从调用堆栈去找出来龙去脉。

1B. Linux/OSX 下的内存泄漏检测方法

在 Linux、OS X 下，我们可以使用 valgrind 工具（用 apt-get install valgrind、 brew install valgrind）。我们完全不用修改代码，只要在命令行执行：

$ valgrind --leak-check=full  ./leptjson_test
==22078== Memcheck, a memory error detector
==22078== Copyright (C) 2002-2015, and GNU GPL'd, by Julian Seward et al.
==22078== Using Valgrind-3.11.0 and LibVEX; rerun with -h for copyright info
==22078== Command: ./leptjson_test
==22078== 
--22078-- run: /usr/bin/dsymutil "./leptjson_test"
160/160 (100.00%) passed
==22078== 
==22078== HEAP SUMMARY:
==22078==     in use at exit: 27,728 bytes in 209 blocks
==22078==   total heap usage: 301 allocs, 92 frees, 34,966 bytes allocated
==22078== 
==22078== 2 bytes in 1 blocks are definitely lost in loss record 1 of 79
==22078==    at 0x100012EBB: malloc (in /usr/local/Cellar/valgrind/3.11.0/lib/valgrind/vgpreload_memcheck-amd64-darwin.so)
==22078==    by 0x100008F36: lept_set_string (leptjson.c:208)
==22078==    by 0x100008415: test_access_boolean (test.c:187)
==22078==    by 0x100001849: test_parse (test.c:229)
==22078==    by 0x1000017A3: main (test.c:235)
==22078== 
...

它发现了在 test_access_boolean() 中，由 lept_set_string() 分配的 2 个字节（”a”）泄漏了。

Valgrind 还有很多功能，例如可以发现未初始化变量。我们若在应用程序或测试程序中，忘了调用 lept_init(&v)，那么v.type 的值没被初始化，其值是不确定的（indeterministic），一些函数如果读取那个值就会出现问题：

static void test_access_boolean() {
    lept_value v;
    /* lept_init(&v); */
    lept_set_string(&v, "a", 1);
    ...
}

这种错误有时候测试时能正确运行（刚好 v.type 被设为 0），使我们误以为程序正确，而在发布后一些机器上却可能崩溃。这种误以为正确的假像是很危险的，我们可利用 valgrind 能自动测出来：

$ valgrind --leak-check=full  ./leptjson_test
...
==22174== Conditional jump or move depends on uninitialised value(s)
==22174==    at 0x100008B5D: lept_free (leptjson.c:164)
==22174==    by 0x100008F26: lept_set_string (leptjson.c:207)
==22174==    by 0x1000083FE: test_access_boolean (test.c:187)
==22174==    by 0x100001839: test_parse (test.c:229)
==22174==    by 0x100001793: main (test.c:235)
==22174== 

它发现 lept_free() 中依靠了一个未初始化的值来跳转，就是 v.type，而错误是沿自 test_access_boolean()。

编写单元测试时，应考虑哪些执行次序会有机会出错，例如内存相关的错误。然后我们可以利用 TDD 的步骤，先令测试失败（以内存工具检测），修正代码，再确认测试是否成功。

2. 转义序列的解析

转义序列的解析很直观，对其他不合法的字符返回 LEPT_PARSE_INVALID_STRING_ESCAPE：

static int lept_parse_string(lept_context* c, lept_value* v) {
    /* ... */
    for (;;) {
        char ch = *p++;
        switch (ch) {
            /* ... */
            case '\\':
                switch (*p++) {
                    case '\"': PUTC(c, '\"'); break;
                    case '\\': PUTC(c, '\\'); break;
                    case '/':  PUTC(c, '/' ); break;
                    case 'b':  PUTC(c, '\b'); break;
                    case 'f':  PUTC(c, '\f'); break;
                    case 'n':  PUTC(c, '\n'); break;
                    case 'r':  PUTC(c, '\r'); break;
                    case 't':  PUTC(c, '\t'); break;
                    default:
                        c->top = head;
                        return LEPT_PARSE_INVALID_STRING_ESCAPE;
                }
                break;
           /* ... */
       }
   }
 }

3. 不合法的字符串

上面已解决不合法转义，余下部分的唯一难度，是要从语法中知道哪些是不合法字符：

unescaped = %x20-21 / %x23-5B / %x5D-10FFFF

当中空缺的 %x22 是双引号，%x5C 是反斜线，都已经处理。所以不合法的字符是 %x00 至 %x1F。我们简单地在 default 里处理：

        /* ... */
            default:
                if ((unsigned char)ch < 0x20) { 
                    c->top = head;
                    return LEPT_PARSE_INVALID_STRING_CHAR;
                }
                PUTC(c, ch);
        /* ... */

注意到 char 带不带符号，是实现定义的。如果编译器定义 char 为带符号的话，(unsigned char)ch >= 0x80 的字符，都会变成负数，并产生 LEPT_PARSE_INVALID_STRING_CHAR 错误。我们现时还没有测试 ASCII 以外的字符，所以有没有转型至不带符号都不影响，但下一单元开始处理 Unicode 的时候就要考虑了。

4. 性能优化的思考

这是本教程第一次的开放式问题，没有标准答案。以下列出一些我想到的。

如果整个字符串都没有转义符，我们不就是把字符复制了两次？第一次是从 json 到 stack，第二次是从 stack 到 v->u.s.s。我们可以在 json 掃描 ‘\0’、’"’ 和 ‘\’ 3 个字符（ ch < 0x20 还是要检查），直至它们其中一个出现，才开始用现在的解析方法。这样做的话，前半没转义的部分可以只复制一次。缺点是，代码变得复杂一些，我们也不能使用 lept_set_string()。
对于掃描没转义部分，我们可考虑用 SIMD 加速，如 RapidJSON 代码剖析（二）：使用 SSE4.2 优化字符串扫描的做法。这类底层优化的缺点是不跨平台，需要设置编译选项等。
在 gcc/clang 上使用 __builtin_expect() 指令来处理低概率事件，例如需要对每个字符做LEPT_PARSE_INVALID_STRING_CHAR 检测，我们可以假设出现不合法字符是低概率事件，然后用这个指令告之编译器，那么编译器可能可生成较快的代码。然而，这类做法明显是不跨编译器，甚至是某个版本后的 gcc 才支持。

Json解析数字

2021-09-18T00:00:00+08:00

Json 解析数字

初探重构

在讨论解析数字之前，我们再补充 TDD 中的一个步骤──重构（refactoring）。根据[1]，重构是一个这样的过程：

在不改变代码外在行为的情况下，对代码作出修改，以改进程序的内部结构。

在 TDD 的过程中，我们的目标是编写代码去通过测试。但由于这个目标的引导性太强，我们可能会忽略正确性以外的软件品质。在通过测试之后，代码的正确性得以保证，我们就应该审视现时的代码，看看有没有地方可以改进，而同时能维持测试顺利通过。我们可以安心地做各种修改，因为我们有单元测试，可以判断代码在修改后是否影响原来的行为。

那么，哪里要作出修改？Beck 和 Fowler（[1] 第 3 章）认为程序员要培养一种判断能力，找出程序中的坏味道。例如，在第一单元的练习中，可能大部分人都会复制 lept_parse_null() 的代码，作一些修改，成为 lept_parse_true() 和lept_parse_false()。如果我们再审视这 3 个函数，它们非常相似。这违反编程中常说的 DRY（don’t repeat yourself）原则。本单元的第一个练习题，就是尝试合并这 3 个函数。

另外，我们也可能发现，单元测试代码也有很重复的代码，例如 test_parse_invalid_value() 中我们每次测试一个不合法的 JSON 值，都有 4 行相似的代码。我们可以把它用宏的方式把它们简化：

#define TEST_ERROR(error, json)\
    do {\
        lept_value v;\
        v.type = LEPT_FALSE;\
        EXPECT_EQ_INT(error, lept_parse(&v, json));\
        EXPECT_EQ_INT(LEPT_NULL, lept_get_type(&v));\
    } while(0)

static void test_parse_expect_value() {
    TEST_ERROR(LEPT_PARSE_EXPECT_VALUE, "");
    TEST_ERROR(LEPT_PARSE_EXPECT_VALUE, " ");
}

2. JSON 数字语法

回归正题，本单元的重点在于解析 JSON number 类型。我们先看看它的语法：

number = [ "-" ] int [ frac ] [ exp ]
int = "0" / digit1-9 *digit
frac = "." 1*digit
exp = ("e" / "E") ["-" / "+"] 1*digit

number 是以十进制表示，它主要由 4 部分顺序组成：负号、整数、小数、指数。只有整数是必需部分。注意和直觉可能不同的是，正号是不合法的。

整数部分如果是 0 开始，只能是单个 0；而由 1-9 开始的话，可以加任意数量的数字（0-9）。也就是说，0123 不是一个合法的 JSON 数字。

小数部分比较直观，就是小数点后是一或多个数字（0-9）。

JSON 可使用科学记数法，指数部分由大写 E 或小写 e 开始，然后可有正负号，之后是一或多个数字（0-9）。

JSON 标准 ECMA-404 采用图的形式表示语法，也可以更直观地看到解析时可能经过的路径：

上一单元的 null、false、true 在解析后，我们只需把它们存储为类型。但对于数字，我们要考虑怎么存储解析后的结果。

3. 数字表示方式

从 JSON 数字的语法，我们可能直观地会认为它应该表示为一个浮点数（floating point number），因为它带有小数和指数部分。然而，标准中并没有限制数字的范围或精度。为简单起见，leptjson 选择以双精度浮点数（C 中的 double 类型）来存储 JSON 数字。

我们为 lept_value 添加成员：

typedef struct {
    double n;
    lept_type type;
}lept_value;

仅当 type == LEPT_NUMBER 时，n 才表示 JSON 数字的数值。所以获取该值的 API 是这么实现的：

double lept_get_number(const lept_value* v) {
    assert(v != NULL && v->type == LEPT_NUMBER);
    return v->n;
}

使用者应确保类型正确，才调用此 API。我们继续使用断言来保证。

4. 单元测试

我们定义了 API 之后，按照 TDD，我们可以先写一些单元测试。这次我们使用多行的宏的减少重复代码：

#define TEST_NUMBER(expect, json)\
    do {\
        lept_value v;\
        EXPECT_EQ_INT(LEPT_PARSE_OK, lept_parse(&v, json));\
        EXPECT_EQ_INT(LEPT_NUMBER, lept_get_type(&v));\
        EXPECT_EQ_DOUBLE(expect, lept_get_number(&v));\
    } while(0)

static void test_parse_number() {
    TEST_NUMBER(0.0, "0");
    TEST_NUMBER(0.0, "-0");
    TEST_NUMBER(0.0, "-0.0");
    TEST_NUMBER(1.0, "1");
    TEST_NUMBER(-1.0, "-1");
    TEST_NUMBER(1.5, "1.5");
    TEST_NUMBER(-1.5, "-1.5");
    TEST_NUMBER(3.1416, "3.1416");
    TEST_NUMBER(1E10, "1E10");
    TEST_NUMBER(1e10, "1e10");
    TEST_NUMBER(1E+10, "1E+10");
    TEST_NUMBER(1E-10, "1E-10");
    TEST_NUMBER(-1E10, "-1E10");
    TEST_NUMBER(-1e10, "-1e10");
    TEST_NUMBER(-1E+10, "-1E+10");
    TEST_NUMBER(-1E-10, "-1E-10");
    TEST_NUMBER(1.234E+10, "1.234E+10");
    TEST_NUMBER(1.234E-10, "1.234E-10");
    TEST_NUMBER(0.0, "1e-10000"); /* must underflow */
}

以上这些都是很基本的测试用例，也可供调试用。大部分情况下，测试案例不能穷举所有可能性。因此，除了加入一些典型的用例，我们也常会使用一些边界值，例如最大值等。练习中会让同学找一些边界值作为用例。

除了这些合法的 JSON，我们也要写一些不合语法的用例：

static void test_parse_invalid_value() {
    /* ... */
    /* invalid number */
    TEST_ERROR(LEPT_PARSE_INVALID_VALUE, "+0");
    TEST_ERROR(LEPT_PARSE_INVALID_VALUE, "+1");
    TEST_ERROR(LEPT_PARSE_INVALID_VALUE, ".123"); /* at least one digit before '.' */
    TEST_ERROR(LEPT_PARSE_INVALID_VALUE, "1.");   /* at least one digit after '.' */
    TEST_ERROR(LEPT_PARSE_INVALID_VALUE, "INF");
    TEST_ERROR(LEPT_PARSE_INVALID_VALUE, "inf");
    TEST_ERROR(LEPT_PARSE_INVALID_VALUE, "NAN");
    TEST_ERROR(LEPT_PARSE_INVALID_VALUE, "nan");
}

5. 十进制转换至二进制

我们需要把十进制的数字转换成二进制的 double。这并不是容易的事情 [2]。为了简单起见，leptjson 将使用标准库的strtod() 来进行转换。strtod() 可转换 JSON 所要求的格式，但问题是，一些 JSON 不容许的格式，strtod() 也可转换，所以我们需要自行做格式校验。

#include <stdlib.h>  /* NULL, strtod() */

static int lept_parse_number(lept_context* c, lept_value* v) {
    char* end;
    /* \TODO validate number */
    v->n = strtod(c->json, &end);
    if (c->json == end)
        return LEPT_PARSE_INVALID_VALUE;
    c->json = end;
    v->type = LEPT_NUMBER;
    return LEPT_PARSE_OK;
}

加入了 number 后，value 的语法变成：

value = null / false / true / number

记得在第一单元中，我们说可以用一个字符就能得知 value 是什么类型，有 11 个字符可判断 number：

0-9/- ➔ number

但是，由于我们在 lept_parse_number() 内部将会校验输入是否正确的值，我们可以简单地把余下的情况都交给lept_parse_number()：

static int lept_parse_value(lept_context* c, lept_value* v) {
    switch (*c->json) {
        case 't':  return lept_parse_true(c, v);
        case 'f':  return lept_parse_false(c, v);
        case 'n':  return lept_parse_null(c, v);
        default:   return lept_parse_number(c, v);
        case '\0': return LEPT_PARSE_EXPECT_VALUE;
    }
}

1. 重构合并

由于 true / false / null 的字符数量不一样，这个答案以 for 循环作比较，直至 ‘\0’。

static int lept_parse_literal(lept_context* c, lept_value* v,
    const char* literal, lept_type type)
{
    size_t i;
    EXPECT(c, literal[0]);
    for (i = 0; literal[i + 1]; i++)
        if (c->json[i] != literal[i + 1])
            return LEPT_PARSE_INVALID_VALUE;
    c->json += i;
    v->type = type;
    return LEPT_PARSE_OK;
}

static int lept_parse_value(lept_context* c, lept_value* v) {
    switch (*c->json) {
        case 't': return lept_parse_literal(c, v, "true", LEPT_TRUE);
        case 'f': return lept_parse_literal(c, v, "false", LEPT_FALSE);
        case 'n': return lept_parse_literal(c, v, "null", LEPT_NULL);
        /* ... */
    }
}

注意在 C 语言中，数组长度、索引值最好使用 size_t 类型，而不是 int 或 unsigned。

你也可以直接传送长度参数 4、5、4，只要能通过测试就行了。

2. 边界值测试

这问题其实涉及一些浮点数类型的细节，例如 IEEE-754 浮点数中，有所谓的 normal 和 subnormal 值，这里暂时不展开讨论了。以下是我加入的一些边界值，可能和同学的不完全一样。

/* the smallest number > 1 */
TEST_NUMBER(1.0000000000000002, "1.0000000000000002");
/* minimum denormal */
TEST_NUMBER( 4.9406564584124654e-324, "4.9406564584124654e-324");
TEST_NUMBER(-4.9406564584124654e-324, "-4.9406564584124654e-324");
/* Max subnormal double */
TEST_NUMBER( 2.2250738585072009e-308, "2.2250738585072009e-308");
TEST_NUMBER(-2.2250738585072009e-308, "-2.2250738585072009e-308");
/* Min normal positive double */
TEST_NUMBER( 2.2250738585072014e-308, "2.2250738585072014e-308");
TEST_NUMBER(-2.2250738585072014e-308, "-2.2250738585072014e-308");
/* Max double */
TEST_NUMBER( 1.7976931348623157e+308, "1.7976931348623157e+308");
TEST_NUMBER(-1.7976931348623157e+308, "-1.7976931348623157e+308");

另外，这些加入的测试用例，正常的 strtod() 都能通过。所以不能做到测试失败、修改实现、测试成功的 TDD 步骤。

有一些 JSON 解析器不使用 strtod() 而自行转换，例如在校验的同时，记录负号、尾数（整数和小数）和指数，然后 naive 地计算：

int negative = 0;
int64_t mantissa = 0;
int exp = 0;

/* 解析... 并存储 negative, mantissa, exp */
v->n = (negative ? -mantissa : mantissa) * pow(10.0, exp);

这种做法会有精度问题。实现正确的答案是很复杂的，RapidJSON 的初期版本也是 naive 的，后来 RapidJSON 就内部实现了三种算法（使用 kParseFullPrecision 选项开启），最后一种算法用到了大整数（高精度计算）。有兴趣的同学也可以先尝试做一个 naive 版本，不使用 strtod()。之后可再参考 Google 的 double-conversion 开源项目及相关论文。

3. 校验数字

这条题目是本单元的重点，考验同学是否能把语法手写为校验规则。我详细说明。

首先，如同 lept_parse_whitespace()，我们使用一个指针 p 来表示当前的解析字符位置。这样做有两个好处，一是代码更简单，二是在某些编译器下性能更好（因为不能确定 c 会否被改变，从而每次更改 c->json 都要做一次间接访问）。如果校验成功，才把 p 赋值至 c->json。

static int lept_parse_number(lept_context* c, lept_value* v) {
    const char* p = c->json;
    /* 负号 ... */
    /* 整数 ... */
    /* 小数 ... */
    /* 指数 ... */
    v->n = strtod(c->json, NULL);
    v->type = LEPT_NUMBER;
    c->json = p;
    return LEPT_PARSE_OK;
}

我们把语法再看一遍：

number = [ "-" ] int [ frac ] [ exp ]
int = "0" / digit1-9 *digit
frac = "." 1*digit
exp = ("e" / "E") ["-" / "+"] 1*digit

负号最简单，有的话跳过便行：

    if (*p == '-') p++;

整数部分有两种合法情况，一是单个 0，否则是一个 1-9 再加上任意数量的 digit。对于第一种情况，我们像负数般跳过便行。对于第二种情况，第一个字符必须为 1-9，如果否定的就是不合法的，可立即返回错误码。然后，有多少个 digit 就跳过多少个。

    if (*p == '0') p++;
    else {
        if (!ISDIGIT1TO9(*p)) return LEPT_PARSE_INVALID_VALUE;
        for (p++; ISDIGIT(*p); p++);
    }

如果出现小数点，我们跳过该小数点，然后检查它至少应有一个 digit，不是 digit 就返回错误码。跳过首个 digit，我们再检查有没有 digit，有多少个跳过多少个。这里用了 for 循环技巧来做这件事。

    if (*p == '.') {
        p++;
        if (!ISDIGIT(*p)) return LEPT_PARSE_INVALID_VALUE;
        for (p++; ISDIGIT(*p); p++);
    }

最后，如果出现大小写 e，就表示有指数部分。跳过那个 e 之后，可以有一个正或负号，有的话就跳过。然后和小数的逻辑是一样的。

    if (*p == 'e' || *p == 'E') {
        p++;
        if (*p == '+' || *p == '-') p++;
        if (!ISDIGIT(*p)) return LEPT_PARSE_INVALID_VALUE;
        for (p++; ISDIGIT(*p); p++);
    }

这里用了 18 行代码去做这个校验。当中把一些 if 用一行来排版，而没用采用传统两行缩进风格，我个人认为在不影响阅读时可以这样弹性处理。当然那些 for 也可分拆成三行：

        p++;
        while (ISDIGIT(*p))
            p++;

4. 数字过大的处理

最后这题纯粹是阅读理解题。

#include <errno.h>   /* errno, ERANGE */
#include <math.h>    /* HUGE_VAL */

static int lept_parse_number(lept_context* c, lept_value* v) {
    /* ... */
    errno = 0;
    v->n = strtod(c->json, NULL);
    if (errno == ERANGE && (v->n == HUGE_VAL || v->n == -HUGE_VAL))
        return LEPT_PARSE_NUMBER_TOO_BIG;
    /* ... */
}

Json解析启程

2021-09-18T00:00:00+08:00

Json解析启程

Json是什么

JSON（JavaScript Object Notation）是一个用于数据交换的文本格式，现时的标准为ECMA-404。

虽然 JSON 源至于 JavaScript 语言，但它只是一种数据格式，可用于任何编程语言。现时具类似功能的格式有 XML、YAML，当中以 JSON 的语法最为简单。

例如，一个动态网页想从服务器获得数据时，服务器从数据库查找数据，然后把数据转换成 JSON 文本格式：

{
    "title": "Design Patterns",
    "subtitle": "Elements of Reusable Object-Oriented Software",
    "author": [
        "Erich Gamma",
        "Richard Helm",
        "Ralph Johnson",
        "John Vlissides"
    ],
    "year": 2009,
    "weight": 1.8,
    "hardcover": true,
    "publisher": {
        "Company": "Pearson Education",
        "Country": "India"
    },
    "website": null
}

网页的脚本代码就可以把此 JSON 文本解析为内部的数据结构去使用。

从此例子可看出，JSON 是树状结构，而 JSON 只包含 6 种数据类型：

null: 表示为 null
boolean: 表示为 true 或 false
number: 一般的浮点数表示方式，在下一单元详细说明
string: 表示为 “…”
array: 表示为 [ … ]
object: 表示为 { … }

我们要实现的 JSON 库，主要是完成 3 个需求：

把 JSON 文本解析为一个树状数据结构（parse）。
提供接口访问该数据结构（access）。
把数据结构转换成 JSON 文本（stringify）。

我们会逐步实现这些需求。在本单元中，我们只实现最简单的 null 和 boolean 解析。

头文件与API设计

C 语言有头文件的概念，需要使用 #include 去引入头文件中的类型声明和函数声明。但由于头文件也可以 #include 其他头文件，为避免重复声明，通常会利用宏加入 #include 防范（include guard）：

#ifndef LEPTJSON_H__
#define LEPTJSON_H__

/* ... */

#endif /* LEPTJSON_H__ */

宏的名字必须是唯一的，通常习惯以 _H__ 作为后缀。由于 leptjson 只有一个头文件，可以简单命名为 LEPTJSON_H__。如果项目有多个文件或目录结构，可以用项目名称_目录_文件名称_H__ 这种命名方式。

如前所述，JSON 中有 6 种数据类型，如果把 true 和 false 当作两个类型就是 7 种，我们为此声明一个枚举类型（enumeration type）：

typedef enum { LEPT_NULL, LEPT_FALSE, LEPT_TRUE, LEPT_NUMBER, LEPT_STRING, LEPT_ARRAY, LEPT_OBJECT } lept_type;

因为 C 语言没有 C++ 的命名空间（namespace）功能，一般会使用项目的简写作为标识符的前缀。通常枚举值用全大写（如 LEPT_NULL），而类型及函数则用小写（如 lept_type）。

接下来，我们声明 JSON 的数据结构。JSON 是一个树形结构，我们最终需要实现一个树的数据结构，每个节点使用 lept_value 结构体表示，我们会称它为一个 JSON 值（JSON value）。在此单元中，我们只需要实现 null, true 和 false 的解析，因此该结构体只需要存储一个 lept_type。之后的单元会逐步加入其他数据。

typedef struct {
    lept_type type;
}lept_value;

C 语言的结构体是以 struct X {} 形式声明的，定义变量时也要写成 struct X x;。为方便使用，上面的代码使用了 typedef。

然后，我们现在只需要两个 API 函数，一个是解析 JSON：

int lept_parse(lept_value* v, const char* json);

传入的 JSON 文本是一个 C 字符串（空结尾字符串／null-terminated string），由于我们不应该改动这个输入字符串，所以使用 const char* 类型。

另一注意点是，传入的根节点指针 v 是由使用方负责分配的，所以一般用法是：

lept_value v;
const char json[] = ...;
int ret = lept_parse(&v, json);

返回值是以下这些枚举值，无错误会返回 LEPT_PARSE_OK，其他值在下节解释

enum {
    LEPT_PARSE_OK = 0,
    LEPT_PARSE_EXPECT_VALUE,
    LEPT_PARSE_INVALID_VALUE,
    LEPT_PARSE_ROOT_NOT_SINGULAR
};

现时我们只需要一个访问结果的函数，就是获取其类型：

lept_type lept_get_type(const lept_value* v);

Json语法集

下面是此单元的 JSON 语法子集，使用 RFC7159 中的 ABNF 表示：

JSON-text = ws value ws
ws = *(%x20 / %x09 / %x0A / %x0D)
value = null / false / true 
null  = "null"
false = "false"
true  = "true"

当中 %xhh 表示以 16 进制表示的字符，/ 是多选一，* 是零或多个，( ) 用于分组。

那么第一行的意思是，JSON 文本由 3 部分组成，首先是空白（whitespace），接着是一个值，最后是空白。

第二行告诉我们，所谓空白，是由零或多个空格符（space U+0020）、制表符（tab U+0009）、换行符（LF U+000A）、回车符（CR U+000D）所组成。

第三行是说，我们现时的值只可以是 null、false 或 true，它们分别有对应的字面值（literal）。

我们的解析器应能判断输入是否一个合法的 JSON。如果输入的 JSON 不合符这个语法，我们要产生对应的错误码，方便使用者追查问题。

在这个 JSON 语法子集下，我们定义 3 种错误码：

若一个 JSON 只含有空白，传回 LEPT_PARSE_EXPECT_VALUE。
若一个值之后，在空白之后还有其他字符，传回 LEPT_PARSE_ROOT_NOT_SINGULAR。
若值不是那三种字面值，传回 LEPT_PARSE_INVALID_VALUE。

单元测试

许多人在做练习或刷题时，都是以 printf／cout 打印结果，再用肉眼对比结果是否乎合预期。但当软件项目越来越复杂，这个做法会越来越低效。一般我们会采用自动的测试方式，例如单元测试（unit testing）。单元测试也能确保其他人修改代码后，原来的功能维持正确（这称为回归测试／regression testing）。

常用的单元测试框架有 xUnit 系列，如 C++ 的 Google Test、C# 的 NUnit。我们为了简单起见，会编写一个极简单的单元测试方式。

一般来说，软件开发是以周期进行的。例如，加入一个功能，再写关于该功能的单元测试。但也有另一种软件开发方法论，称为测试驱动开发（test-driven development, TDD），它的主要循环步骤是：

加入一个测试。
运行所有测试，新的测试应该会失败。
编写实现代码。
运行所有测试，若有测试失败回到3。
重构代码。
回到 1。

TDD 是先写测试，再实现功能。好处是实现只会刚好满足测试，而不会写了一些不需要的代码，或是没有被测试的代码。

但无论我们是采用 TDD，或是先实现后测试，都应尽量加入足够覆盖率的单元测试。

回到 leptjson 项目，test.c 包含了一个极简的单元测试框架：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "leptjson.h"

static int main_ret = 0;
static int test_count = 0;
static int test_pass = 0;

#define EXPECT_EQ_BASE(equality, expect, actual, format) \
    do {\
        test_count++;\
        if (equality)\
            test_pass++;\
        else {\
            fprintf(stderr, "%s:%d: expect: " format " actual: " format "\n", __FILE__, __LINE__, expect, actual);\
            main_ret = 1;\
        }\
    } while(0)

#define EXPECT_EQ_INT(expect, actual) EXPECT_EQ_BASE((expect) == (actual), expect, actual, "%d")

static void test_parse_null() {
    lept_value v;
    v.type = LEPT_TRUE;
    EXPECT_EQ_INT(LEPT_PARSE_OK, lept_parse(&v, "null"));
    EXPECT_EQ_INT(LEPT_NULL, lept_get_type(&v));
}

/* ... */

static void test_parse() {
    test_parse_null();
    /* ... */
}

int main() {
    test_parse();
    printf("%d/%d (%3.2f%%) passed\n", test_pass, test_count, test_pass * 100.0 / test_count);
    return main_ret;
}

现时只提供了一个 EXPECT_EQ_INT(expect, actual) 的宏，每次使用这个宏时，如果 expect != actual（预期值不等于实际值），便会输出错误信息。若按照 TDD 的步骤，我们先写一个测试，如上面的 test_parse_null()，而 lept_parse() 只返回 LEPT_PARSE_OK：

/Users/miloyip/github/json-tutorial/tutorial01/test.c:27: expect: 0 actual: 1
1/2 (50.00%) passed

第一个返回 LEPT_PARSE_OK，所以是通过的。第二个测试因为 lept_parse() 没有把 v.type 改成 LEPT_NULL，造成失败。我们再实现 lept_parse() 令到它能通过测试。

然而，完全按照 TDD 的步骤来开发，是会减慢开发进程。所以我个人会在这两种极端的工作方式取平衡。通常会在设计 API 后，先写部分测试代码，再写满足那些测试的实现。

实现解析器

有了 API 的设计、单元测试，终于要实现解析器了。

首先为了减少解析函数之间传递多个参数，我们把这些数据都放进一个 lept_context 结构体：

typedef struct {
    const char* json;
}lept_context;

/* ... */

/* 提示：这里应该是 JSON-text = ws value ws，*/
/* 以下实现没处理最后的 ws 和 LEPT_PARSE_ROOT_NOT_SINGULAR */
int lept_parse(lept_value* v, const char* json) {
    lept_context c;
    assert(v != NULL);
    c.json = json;
    v->type = LEPT_NULL;
    lept_parse_whitespace(&c);
    return lept_parse_value(&c, v);
}

暂时我们只储存 json 字符串当前位置，之后的单元我们需要加入更多内容。

lept_parse() 若失败，会把 v 设为 null 类型，所以这里先把它设为 null，让 lept_parse_value() 写入解析出来的根值。

leptjson 是一个手写的递归下降解析器（recursive descent parser）。由于 JSON 语法特别简单，我们不需要写分词器（tokenizer），只需检测下一个字符，便可以知道它是哪种类型的值，然后调用相关的分析函数。对于完整的 JSON 语法，跳过空白后，只需检测当前字符：

n ➔ null
t ➔ true
f ➔ false
” ➔ string
0-9/- ➔ number
[ ➔ array
{ ➔ object

所以，我们可以按照 JSON 语法一节的 EBNF 简单翻译成解析函数：

#define EXPECT(c, ch) do { assert(*c->json == (ch)); c->json++; } while(0)

/* ws = *(%x20 / %x09 / %x0A / %x0D) */
static void lept_parse_whitespace(lept_context* c) {
    const char *p = c->json;
    while (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r')
        p++;
    c->json = p;
}

/* null  = "null" */
static int lept_parse_null(lept_context* c, lept_value* v) {
    EXPECT(c, 'n');
    if (c->json[0] != 'u' || c->json[1] != 'l' || c->json[2] != 'l')
        return LEPT_PARSE_INVALID_VALUE;
    c->json += 3;
    v->type = LEPT_NULL;
    return LEPT_PARSE_OK;
}

/* value = null / false / true */
/* 提示：下面代码没处理 false / true，将会是练习之一 */
static int lept_parse_value(lept_context* c, lept_value* v) {
    switch (*c->json) {
        case 'n':  return lept_parse_null(c, v);
        case '\0': return LEPT_PARSE_EXPECT_VALUE;
        default:   return LEPT_PARSE_INVALID_VALUE;
    }
}

由于 lept_parse_whitespace() 是不会出现错误的，返回类型为 void。其它的解析函数会返回错误码，传递至顶层。

关于断言

断言（assertion）是 C 语言中常用的防御式编程方式，减少编程错误。最常用的是在函数开始的地方，检测所有参数。有时候也可以在调用函数后，检查上下文是否正确。

C 语言的标准库含有 assert() 这个宏（需 #include ），提供断言功能。当程序以 release 配置编译时（定义了 NDEBUG 宏），assert() 不会做检测；而当在 debug 配置时（没定义 NDEBUG 宏），则会在运行时检测 assert(cond) 中的条件是否为真（非 0），断言失败会直接令程序崩溃。

初使用断言的同学，可能会把有副作用的代码放在 assert() 中：

assert(x++ == 0); /* 这是错误的! */

因为这样会导致 debug 和 release 版的行为不一样。

另一个问题是，初学者可能会难于分辨何时使用断言，何时处理运行时错误（如返回错误值或在 C++ 中抛出异常）。简单的答案是，如果那个错误是由于程序员错误编码所造成的（例如传入不合法的参数），那么应用断言；如果那个错误是程序员无法避免，而是由运行时的环境所造成的，就要处理运行时错误（例如开启文件失败）。

人体调优指南

2021-06-24T00:00:00+08:00

人体调优不完全指南

主要分为以下几个内容进行介绍：

睡眠
饮食
心态和动力
学习和专注
大脑健康
长寿

睡眠

如果你想要获得健康，更好的工作学习状态，提升生理健康如免疫，新陈代谢，以及心理健康如更好的心情，专注能力等，最最重要的前提是拥有一个良好的睡眠。

原理

在早上，身体释放的皮质醇（cortisol）和肾上腺素（aderenaline）会让我们醒来，同时还会设定松果体释放褪黑素的倒计时钟，会在十多个小时之后让我们感到困意再次入睡。

影响这个生物钟最大因素时光照，我们的眼睛除了能够看到东西，另外一个重大的作用就是通过黑视素神经节细胞来接收光照信息，用以设定我们的内在生物钟。这也是为什么有时候我们通宵工作之后，虽然已经持续很久时间没有睡眠了，但随着太阳升起，整体的生物钟被设定到了类似起床时的状态，各类化学物质的释放会让我们突然感觉又有精神了。后续很多最佳实践里也都跟这个原理相关，我们需要控制自己接收光照的时间点，类型和时长。

此外，体温也是一个用于控制我们生物钟的手段。一般来说我们的体温会从深睡眠中比较低的状态逐渐升高，到醒来后持续上升。到了一天的后半段会开始逐渐下降，直到再次进入睡眠。

实践

起床后应该到外面去接触阳光，持续 2-10 分钟
在晚上要尽量减少光源的接触（因为这会扰乱我们的生物钟，让身体系统误以为是在白天。尤其是晚上 11 点到次日凌晨 4 点之间接收光源，会抑制后续几天的多巴胺的释放，影响心情，心理健康，专注度，学习能力，新陈代谢等等。关于多巴胺的作用和机理，后面会再单独介绍。）
如果不可避免需要在晚上接触光源，处于较低位置，暗淡的红光，蜡烛之类的会相对好一些。如果要看电脑，建议使用 blue blockers 眼镜，这跟一些电脑软件会自动调节屏幕色温的效果可能类似。
傍晚观察落日，对于后续入睡也有帮助，甚至能减轻晚上摄入光照的负面影响。
体温对生物钟周期的影响：
- 早上洗冷水澡，会让人快速升温，从而把睡眠周期往前移（早起）。
- 晚上锻炼身体，会让人保持高体温，从而延后周期（晚睡）。
- 可以选购一些自动控制体温的智能床垫来提升睡眠质量。
中午可以吃低卡路里以及含酪氨酸的食物，如坚果，大豆，部分蔬菜等，提升多巴胺，肾上腺素，保持清醒。
晚上则可以吃点淀粉，白肉等富含色氨酸的食物，进而转化为血清素，会让人更加平静，容易入睡。

饮食

我们可以把身体跟进食相关的化学状态分成 2 类：

吃饱了的状态，也就是血糖含量较高的状态。此时我们身体会更活跃地进行体内细胞的复制与成长。
禁食的状态，也就是血糖含量较低的状态。此时我们的身体会更活跃地进行体内细胞的修复与清理（autophagic）。

科学家们发现这种间歇性禁食状态对于身体有非常多的好处，包括：促进肝脏健康，胆汁酸代谢，炎症自愈，保持体重，提升 brown fat 储备（对健康有益），防止非酒精性脂肪肝，血糖控制，肠道健康等等。如果养成间歇性禁食的习惯 60 天以上，还会让我们的身体倾向于代谢脂肪来供能，控制体重。

所以，何时进食，与吃什么东西，其实是同等重要的。

Fasting的实践

基础：如果想享受 fasting 的基础收益，最简单的执行原则是起床后至少 1 小时内不要吃东西，同时睡前的 2-3 小时不要吃任何东西。
高阶：目前研究结果中最理想的进食窗口是 8 小时，结合社会习俗等，一般比较合理的时间在 10-18 点或 12-20 点的范围。看起来不吃早饭并不是什么坏事 :)

实践过程中尽量保证这个窗口时间的稳定性，也非常重要。否则就跟频繁倒时差产生的效果差不多，会打不少收益折扣。

最后，如果禁食期间觉得有些头晕，颤抖，并不需要立刻进食或摄入糖分。可以喝一点盐水（可以加柠檬汁），一般就能很好的缓解症状。

心态与动力

这一部分主要介绍的是人体的多巴胺系统原理，以及如何利用它来形成健康，自律的生活方式

原理

多巴胺是一种非常重要的化学物质，主要作用于两个神经回路：一个影响身体的运动，例如帕金森病与多巴胺的分泌不足有关；另一个则影响我们的动机，欲望与快乐，这几乎与我们从事的各种活动有关，无论是工作，学习还是社交，休闲娱乐。这里我们会主要讨论多巴胺的后者影响能力。我们为什么会“放弃”，实际上是由于在不安，压力，沮丧等情绪作用下，身体内的去甲肾上腺素水平不断提升，当超过一定阈值时，神经系统中的认知控制就会关闭，我们就放弃了。多巴胺能够抑制去甲肾上腺素作用，从而持续“激励”我们前行。

神经系统中多巴胺含量水平的高低会影响我们的情绪，当多巴胺水平低时，我们会感到情绪低落，没有动力，而多巴胺水平高时，我们会感到兴奋和快乐。在通常情况下，我们的身体处于多巴胺 baseline 的状态，当我们达成一些令人兴奋的目标（比如玩游戏胜利，考试拿高分）后，多巴胺的水平会达到一个高峰，此时我们就会获得巨大的愉悦感。在高峰之后，多巴胺水平会回落到比 baseline 更低的一个水平，且这个状态会持续一段时间。

这里有两个非常重要的原理：

多巴胺绝对值含量的高低只是一方面，更重要的是其“相对变化量”的多少。比如在刷抖音时看到了一个很有趣的视频，多巴胺水平升高，你会感到快乐，刷到下一个视频时，你感到的快乐程度好像不会那么强烈了，因为多巴胺已经在一个比较高的水平，难以形成更大的变化量。而同样的视频，如果你是几天之后看到，或许你会觉得有意思的多。所以当你持续做一件喜欢的事情时，你感受到快乐的阈值也会不断提高。
多巴胺的总体“储备”是有限的

也就是说无论你是通过学习，工作，娱乐，社交，运动等不同方式来获得快乐，所消耗的“快乐货币”都是同一种：多巴胺。举几个例子来看下这个原理带来的影响：
- 很多自律的人都会说自己是 work hard，play hard 的生活方式，比如工作日通过高强度的工作来获得成就和满足感，休息日进行各种休闲娱乐，运动，社交等方式来获得快乐，其实背后都是在释放多巴胺来获取快乐。长期持续，我们身体的多巴胺 baseline 会逐渐下降，出现一种耗尽（burn out）的心理感觉，对很多事物无法保持之前的兴趣与精力。
- 很多人会对玩电子游戏着迷，因为它们能带来巨大的多巴胺释放刺激让人感到快乐。但要意识到，多巴胺的储备是有限的，如果对此上瘾，你的多巴胺耗尽问题就会变得非常严重：一方面能够引起你兴趣的事物会变少，可能只有玩游戏才能带来快乐；另一方面，后续甚至会导致玩游戏本身也无法触发多巴胺释放，引起严重的抑郁问题。

另外，多巴胺也具有叠加效应。比如你喜欢健身，那么运动就会刺激多巴胺的释放。而我们实际去健身时，可能会不自觉地安排了很多其它的“快乐因素”，比如选一个精神状态比较好的日子，运动前喝一些能量饮料，跟认识的朋友一起去，边健身边 social，听一些自己喜欢的音乐或 podcast，等等。这些因素也都会促进多巴胺的释放，让你感到“前所未有的快乐”。但要注意前面的原理，多巴胺的高峰越高，后面随之而来持续的低谷也会越长，而且长此以往，可能会降低你单纯从运动中获取快乐的能力。这样的例子还有很多，比如边跟朋友吃饭，边玩手机，拍照发朋友圈，可以计算一下叠加了几种快乐因素 :)

影响多巴胺的外界因素

我们来看下具体影响多巴胺释放的各类因素有哪些，首先是促进多巴胺分泌的：

巧克力，提升到 1.5 倍的多巴胺 baseline
性行为，提升到 2 倍
尼古丁，提升到 2.5 倍
可卡因，提升到 2.5 倍
安非他命，提升到 10 倍
咖啡因本身只会少量提升多巴胺，但它会抑制一些多巴胺受体，提升同等多巴胺造成感受的效果
马黛茶，包含咖啡因，能控制血糖，还能保护多巴胺神经元
刺蒺藜豆也能提升多巴胺（基本等同于 L-DOPA），还能提升男性精子数量和质量
运动，带有主观成分，喜欢跑步的人，可以提升到 2 倍 baseline
健康的社交关系也会促进多巴胺释放

食物方面感觉 Huberman 教授非常推荐马黛茶。

也有很多提升多巴胺释放或影响其效果的药物：

L-Tyrosine（酪氨酸），提升多巴胺
Phenethylamine（PEA），巧克力中也包含，能够提升多巴胺
Huperzine A，提升多巴胺
各种“聪明药”，如 Adderall, Modafinil, Alpha-GPC, Ginkgo 等，留学党应该很多都有耳闻

通常来说，不推荐持续使用这些药物，因为多巴胺释放之后的高峰会带来 baseline 水平的降低，导致无法享受活动的快乐，无法专注，限制学习能力和神经元可塑性等。Huberman 表示一周使用一次的频率应该是安全的。

最后还有一个比较特别的研究，就是冷水浴能够提升多巴胺释放到 baseline 的 2.5 倍左右，且持续时间更长，能达到 3 小时左右。建议使用 10-14 摄氏度的水温，注意安全。此外冷水浴也不需要太频繁，每周 11 分钟左右足够。如果已经习惯了冷水浴，那么也就没有释放多巴胺的效果了。

还有一些因素会降低多巴胺，如：

褪黑素，会引起多巴胺的减少。前面也提到过并不建议使用褪黑素来帮助入睡，或者适应时差等。
睡眠时段接触光源，也会引起接下来几天的多巴胺水平下降。半夜睡不着刷手机是很有害的哦。

维持健康的多巴胺水平

了解了原理和各种影响因素后，我们来看下如何有效设计我们的生活工作方式来维持健康，可持续的多巴胺水平。

简单回顾一下，前面我们已经知道了多巴胺储备有限，且对一件事物上瘾会不断提高感受快乐的阈值，那么如何让我们能对一件事情保持长时间的兴趣和投入度，又不至于耗尽多巴胺呢？一个经典的例子是赌场的运作方式，我们并不是每一次下注都能赢，偶尔赢一次会释放多巴胺，而且根据赢得钱的多少有所上下浮动，这会吸引玩家持续参与。这就是一种非常有效的间歇性且随机的奖励机制。感觉很多游戏，社交网络产品也借鉴了这个思路来进行设计。

对于我们经常需要从事的活动，我们也可以模拟这个机制。还记得前面提到的多巴胺叠加效应吗？我们可以通过随机化叠加因素的多少，来实现多巴胺释放的差异性。还是以健身为例，我们可以随机决定今天是否要听音乐，是否去健身时带手机，是否要在健身前喝能量饮料等因素。如果其它什么都不做，只是单纯健身，那么多巴胺的释放量就会相对较低。如此就能模拟多巴胺释放有高有低的随机奖励机制。

成长型思维

最后来看下如何构建良好的思维方式来利用多巴胺系统提升自我。

有一个非常知名的实验，挑选了一群天生喜爱画画的小朋友，在他们完成画作后给与一些奖励。后面在移除这些奖励后，小朋友们对于画画的兴趣和动力大大降低了。这个实验说明，当我们因为一个活动收到奖励（比如金钱，美食等）时，我们反而会降低活动本身的愉悦程度。而且多巴胺本身影响我们对时间的认知，同时也影响我们的情绪状态，如果我们始终以完成活动后的奖励为目标，则整个过程中就很少释放多巴胺，让原本困难的过程变得更加难以坚持。

仔细想一下，这是一个非常有意思的观察。多巴胺有点像我们的“本能系统”，决定了我们是否有动力做一件事。但反过来我们的主观思想却可以影响这个系统起作用的方式，这也是人类为何能摆脱动物本能，达成很多需要“反人性”的投入才能取得的成就的原因吧。上述的实验是我们的主观思想造成的一个反面作用的例子，我们自然也可以实现正面作用，那就是成长型思维。

具体来说，就是通过自我暗示，把努力过程本身当作一种“奖励”。我在努力学习，这个过程本身就是有趣的，会让我不断变得更强，这样的想法会在过程中激发身体系统释放多巴胺，而多巴胺提升了我们的情绪和动力水平，也会让努力的过程中碰到的困难变得相对容易克服。专注于这个过程的本身，而不是在过程前进行各种外界刺激（如前面提到的药物），或者在过程后给自己巨大的奖励。

这种思维方式看起来很主观，但这就是我们的神经系统工作的方式，虽然人类的“硬件系统”都差不多，但知识，思维这些运行之上的“软件”却可以千差万别。我们可以通过自律，自我暗示来改变自身对各类活动的喜好。例如通过暗示 fasting 对我们健康的益处，来获取满足感，而不是借助于 fasting 结束后的大快朵颐。通过自律抵御高油盐食物的吸引力，并且自我暗示植物类食物对身体的好处，坚持一段时间，会觉得花椰菜也挺美味的。这也是为什么我们在这篇文章中介绍了很多原理性的内容，而不仅仅是行为建议。因为这些原理知识能够让我们做更好的自我暗示 :)

多巴胺系统中也有对我们认知成长造成“障碍”的运作机理。例如当我们接受到的信息支撑我们之前的信念时，也能够激发多巴胺的释放让我们感到快乐，这从本质上会改变我们对世界的认知。由此可见，“空杯心态”是多么难得的品质，网上如此多的争论无法达成共识也有很大一部分“归功”于此。如何克服神经系统中的这类缺陷呢？一种可能的方法是尽可能调节情绪，使自己处于镇静的状态（提升血清素水平），这样才能让自己更好的去倾听和吸收跟自己认知不一致的信息，更好地协同合作。

学习和专注

从脑神经科学来看，学习的本质是神经元的重新连接（rewire），进一步来看，需要大脑处在一种学习的化学状态下，也就是 Huberman 经常提到的神经可塑性（neuroplasticity）状态。要达到这个神经可塑性状态，有两个重要条件，一个是足够的专注度，另外一个是“犯错”的信号（后面会展开）。另外大脑一个比较有意思的机制是，在学习时的神经可塑状态下，乙酰胆碱会标记需要改变的神经元，而具体的神经元重连接则主要是在休息和睡眠时发生，是不是有点像 JVM 虚拟机的垃圾回收机制 :)

什么是犯错信号呢？当我们尝试做一些事情，但没有达到预期目标时，身体会给大脑发信号，“我犯错了”。处在这种犯错，沮丧的认知状态下，神经系统会释放肾上腺素（提升 alertness），乙酰胆碱（提升 focus），多巴胺（促进神经元的 change，rewire）等化学物质，激活神经元的可塑性。也就是说，犯错是我们进入学习状态的重要前提。搞机器学习的同学应该很熟悉了吧，这跟我们训练模型不是一模一样么 :) 另外很多人可能觉得心流（flow）状态是学习的最佳状态，而 Huberman 则不这么认为。心流是一种精神高度集中且接近于自动化的状态，是在做我们已经知道怎么做的事情，而不是在学习新的知识技能。

对于这个学习状态，经典的实验是给人们戴上一些能转变角度的眼镜，然后执行一些类似物体抓取的任务。由于看到的东西通过眼镜改变了其本来的位置，一开始在尝试时总会出现抓取动作的偏离。但后续在进入神经可塑性状态后，我们能逐渐适应相关的视觉偏移，协调自己的听觉，动作等都与之协同，顺利完成任务。更有意思的是，这个“神经可塑性”的化学状态是可以持续的，我们甚至可以先通过一些其它操作触发大脑的这个机制，再去进行真正的学习，以加快学习的速度。这里还有一个隐藏逻辑，当你在遇到挫折困难时，大脑进入了可塑性状态，而此时你却放弃了，那么神经元也会重新连接到这种容易放弃的行为模式，形成恶性循环。

人在年幼时期大脑天然的神经可塑性会比较好，而在 25 岁以后则会大大下降。我们后面会提到如何来进行克服。

另外，休息和睡眠时也会发生大量的神经元重连接的活动，这也是之前我们就提到过的，高质量的睡眠是实现很多生理，心理健康强壮的先决条件。

利用神经可塑性

如果正在阅读文章的你还未满 25 岁，那么恭喜你，你的神经可塑性仍然非常的好，可以尽可能广泛的学习各种知识和技能。比如你可以很快学会各种乐器，新的语言，新的运动，新的专业技能等等。通过更广阔领域的体验接触，尽量找到你最有兴趣的方向，可以后续再不断深入经营。

如果已经像我一样超过了 25 岁，那么还有很多办法来提升神经可塑性：

通过实验发现，成年人对于小幅度的增量学习是完全可以适应与掌握的。例如每次视觉上的偏差只有 7 度，而不是一下子就来个 180 的大颠倒，那么成年人也能很快从错误中学习纠正。应用到实际学习中，我们每次学习的内容可以控制一下不要太多（本文有点违反了，建议收藏慢慢学习），多次积累来完成神经系统的调整学习。
对于达成目标的渴求度越高，重要性越大，奖励的刺激越大（比如为了生存），则神经可塑性就会越容易出现。这个比较符合直觉，但是现实中可操作性可能不高。
第三点最有意思，通过扰乱前庭神经系统（vestibular system），能够达到神经元可塑性的状态。简单来说，就是让你的身体有一些“新颖的重力体验”，如倒立，瑜伽，体操，滑板，任何让身体会失去平衡的一些状态等，会快速激发“我犯错了”的信号，进入学习状态，甚至可以在之后去做别的任务的学习。这一下子就让我想到了淘宝成立初期的“倒立文化”，没想到还真的有科学依据。需要注意的是，这个体验必须要新颖，也就是说如果你已经倒立很熟练了，那么去做倒立就是个日常行为，并不会给身体一种在犯错边缘，需要纠正的刺激。

Huberman 认为，大脑的主要功能链路是感知，认知，情感，思想，行动。在尝试控制我们的神经系统来进行各种任务时（例如学习，解决困难问题，挑战运动极限），我们是很难用精神思想来控制其本身的（比如不断跟自己说我不能分心），更可行的办法是“逆向链路”，从我们的行动出发，利用神经系统的运作原理，逐渐影响思想，情感，认知甚至感知部分。这也是 Huberman 非常推崇各种“行动工具”的原因。Mood follows action。

学习的理想状态

除了神经可塑性的化学状态外，我们也需要注意其它的因素。例如我们不能太放松以至于有些昏昏欲睡，也不能太紧张激动，无法控制自己拥有清晰的思考等。这些也都跟我们体内的多巴胺，肾上腺素，乙酰胆碱，血清素，褪黑素等化学物质的水平有关，需要做好调节。在之前 Rich Roll 的访谈节目中，Huberman 提了一个非常有效的“呼吸工具”，叫生理叹息（Physiological Sigh）。操作方法上简单来说就是吸两口气，然后出一口长气。通常情况下，只要一两次生理叹息就足以使我们的压力和警觉水平迅速下降，让人感到更加平静，提升学习表现。

前面提到的成长型思维也很重要，在遇到错误导致的沮丧感觉时，可以不断增强自我暗示，失败是帮助我们学习成长的唯一路径，对我们是有益的，以此增加多巴胺的释放，提升学习动力和过程中的愉悦感。

联系到睡眠对学习的促进作用，也有一些研究提供了一些相关的 tips：

在学习时听一些有规律的节拍，在入睡时也播放同样的微弱节拍，能够提升学习和记忆的效果。
一般在 90 分钟的学习后（人体生物钟的周期），可以选择进行 20 分钟的休息（non sleep deep rest），也会加强学习的效果。
Gap effect，在学习中随机停止 10 秒钟，这些停止会在睡眠中加速“播放”，提升学习效果。

提升专注

“专注”背后的机理是大脑中两种“网络模式”的协调，一种叫 Default network，在我们不做任何事情时被激活，另一种叫 Task networks，在我们专注于做某些事情时被激活。普通人的大脑能够很好地协调这两个模式，两者像跷跷板一样，当一种模式被激活时另一种模式会被抑制。而具有专注障碍（比如多动症）的人来说，这两者无法很好地进行协调，因此会出现无法专注的现象。

通过提升多巴胺水平，可以有效促进这两种网络模式的协调，因此有非常多的多动症治疗药物都跟提升多巴胺有关，例如 Adderall，Modafinil 等。一些调查表明，这些药物（经常被称为聪明药，nootropics）在美国被滥用的程度甚至超过了大麻，不少“学霸”都以此来提升注意力，减少对睡眠的需求。但 Huberman 教授表示，一方面多巴胺的刺激提升后都会带来多巴胺水平的低谷，另一方面这些药物也可能导致上瘾，对新陈代谢作用造成扰动，有很多负面影响，对长期的学习与记忆效果可能并没有提升作用。在之前介绍多巴胺的章节也有提到，应该谨慎使用这类药物，并严格控制使用频率不能过高。

最好的提升专注的方法当然是前面聊过的更好的控制我们的多巴胺系统，例如把行动跟背后的意义相连接，给自己正面的心理暗示；将任务拆成多个小的里程碑，通过过程自身的激励来促进多巴胺的释放提升我们的专注度。此外一些安全有效的提升专注力的方法包括：

适量补充 Omega-3 EPA 鱼油，这是神经细胞的组成原料之一，能够有效减轻抑郁，对治疗多动症（ADHD）也有帮助。
通过身体其它部分释放运动，可以帮助提升注意力。教授举的例子是作为神经科医生在开刀时，如果采用半蹲半站的姿态（运动释放），拿手术刀的手更稳定不容易颤抖。这让我想起以前读书时很多同学习惯转笔，现在工作了也有不少人喜欢玩指尖陀螺，或者站立办公，可能都是类似效果。
限制视野范围，能够提升专注度。比如我们经常因为眼睛瞟到了任务栏上的消息提示闪动而分心，可以通过一些设置来进入“专注模式”。
视线的高低也会影响神经状态，视线往下看会让神经系统偏向镇静，放松，甚至困倦，而视线向上则会让系统提升警惕。工作时一般至少把显示器放置在鼻子位置之上。
大脑不擅长处理大量频繁的 context switch，典型的比如刷抖音，不同的信息以非常快的速度频繁切换，这对我们的注意力是有伤害作用的。2014 年的一项研究表示，我们每天在手机上花费的时间应该少于 60 分钟（青少年）/120 分钟（成年），以免引起注意力障碍问题。
还有研究表明，17 分钟的冥想，能够对大脑中的神经元做重新连接，永久地改善注意力。只要做一次就可以，完全可以尝试一下。

大脑健康

最后来看下提升大脑健康和效能的一些方法。

首先是前面提到过的，保证高质量的睡眠。

运动方面，对大脑直接帮助最大的是有氧运动，提升心肺功能，支持大脑供能。建议每周 150-180 分钟的有氧训练。

对于大脑健康有帮助的食物，其中前三点是比较重要的，后面的部分涉及的研究没有那么多：

Omega3, 尤其是 EPA 等脂肪酸，是大脑组成的重要部分，且一般人都容易摄入不足。多吃鱼，牡蛎，鱼子酱，奇亚籽，核桃，大豆。一天至少摄入 1.5 克，理想情况需要 3 克以上。不喜欢吃鱼的话可以辅助摄入鱼油。
磷脂酰丝氨酸，也对认知能力有帮助。通过鱼，肉类，卷心菜来摄入。
乙酰胆碱，重要的神经调质，提升注意力。摄入胆碱的重要来源是鸡蛋，尤其是蛋黄。土豆，坚果，水果中也含有，虽然没有蛋黄中的含量那么丰富。可以通过 Alpha-GPC 等补充剂来获取。
肌酸，尤其对于不吃肉的人，一天需要摄入 5 克左右。
花青素，在蓝莓，黑莓，葡萄等食物中有提供。可以降低 DNA 损伤，缓解认知下降等问题。大约每天需要 60-120 克蓝莓的补充。
谷氨酰胺，可以通过牛肉，鸡肉，鱼肉，鸡蛋，大豆，卷心菜，菠菜，芹菜等食物来摄取。提升大脑在缺氧（高海拔地区）下的表现，还能够抑制对糖的需求。
水，钠，钾，镁等电解质是神经元信号传递所需的基础元素，需要保证。

这一节中还讨论了我们身体对各种食物喜好进行判断的三个渠道，前两个分别是味觉判断和营养成分的下意识判断。第三个比较有意思，也跟多巴胺有关，即我们可以通过提升大脑代谢的活跃度来增加对某种食物的喜好。比如你如果不喜欢吃鱼，一种方法是你可以把鱼跟你平时爱吃的食物一起吃，另一种是给自己足够的心理暗示，说服自己吃鱼是有益身体健康的。通过这两种办法，你都可以让大脑释放多巴胺，从而逐渐提升对鱼类食物的喜好程度。

最后，如果你对膳食补充剂感兴趣，还可以看看 Huberman 教授平时会吃的补充剂有哪些。

长寿

最后我们来看下如何延年益寿，这是 Huberman 跟这个领域的专家，来自哈佛的 David Sinclair 的一集访谈节目。

衰老的本质

Sinclair 认为，衰老是一种疾病，它本身导致了非常多通常意义上的疾病的出现，比如阿尔兹海默症，癌症等。我们可以通过科学的手段来“治疗”衰老，甚至逆转它。

从本质上来说，衰老是基因信息的损失，这分为两部分：

DNA 本身的信息，比如细胞中的 DNA 结构会在辐射等情况下受到破坏。
控制哪些基因进行表达的信息受到了破坏，也就是所谓的表观基因组（epigenome）。这部分在衰老的因素中占了 80%。

人体内有一个天然的“衰老时钟”，而且并不是以匀速走的。在年轻时我们的生长发育过程中，这个时钟走得更快。所以如果青春期发育比较迅速的人，一般来说整体的时钟走的比较快，寿命也会相对短，是不是有点吓人……而且，一般比较矮小的人，像侏儒很少会得心脏病，癌症，也会明显更长寿。不过不要紧张，前面提到了，基因本身的信息只占了衰老因素的 20%，控制基因表达这部分占了大多数。

这里有点意外的是 Sinclair 教授介绍的最重要的几个实验，都跟前面我们提到的 fasting 有关。比如一般老鼠的寿命大概是 2 年，他们实验室有一只叫 Yoda 的老鼠，活了足足 5 年。其主要的做法就是选取了侏儒基因，以及执行 fasting。

教授详细介绍了 fasting 为何能提升动物/人类 30% 以上的寿命：

在低血糖水平时，身体会抑制哺乳动物雷帕霉素靶蛋白（mTOR），激活去乙酰化酶（sirtuin），形成一个非常良好的化学状态，清理旧蛋白质，提高胰岛素敏感度，提供更多能量，修复细胞等等。后面这个乙酰化酶是我们抵御衰老的一个重要武器。
当胰岛素水平低时，“长寿基因”会被激活，如 SIRT1 等。
fasting 会给细胞足够的“休息时间”。
血糖水平低，会让身体对胰岛素更敏感，更快吸收血糖，也对健康有益。
当你从来不感受饥饿时，你的衰老时钟也走的更快。
除了 24 小时周期 fasting 触发的 autophagic，还有更深层次的清理机制，会在禁食第二，三天启动。在老年老鼠上的实验表明，这种长时间的禁食可以让他们延长寿命 35%。不过这个实操难度对普通人来说有点大。

Sinclair 也对比了一些上个世纪失败的研究，比如通过抗氧化剂来抵御衰老。现代长寿研究的核心思想是，如何通过一些机制手段来触发身体自身的衰老抵抗机制。

此外 Sinclair 也介绍了一些激动人心的前沿技术，例如通过基因治疗方法，可以重启我们的 DNA 表达系统。通过一次注射，可以让盲人恢复视力，这已经在老鼠身上得到了验证。或许几年后，我们可以像死侍那样实现身体各部分的逆转老化。

抗衰老手段

先来总览看一下各种抗衰老的手段。

饮食

包括食物结构和饮食控制。饮食控制方面前面有提到过，建议缩短进食窗口到 8 小时左右。饮食结构可以参考最新发表在 Cell 上的这篇文章 Nutrition, longevity and disease: From molecular mechanisms to interventions。简单总结一下就是多吃植物类的蛋白（花生，藜麦，豆类，西兰花等），脂肪（橄榄油，坚果，牛油果等），减少精制碳水（白米饭，白面包，蛋糕，饼干等）；动物脂肪，动物蛋白质，糖这些总体来说是加速衰老的。

体育锻炼

有氧锻炼对心肺功能，血管健康等方面的促进对延寿很有帮助。力量训练也能持续保持我们的肌肉，关节，韧带的力量水平，支撑保护能力等，在年纪大时减少各种跌倒或者受伤的风险。一般建议是一周 3 小时左右的有氧运动，搭配 2 到 3 次的力量训练。有氧运动一般比较简单，跑步，骑车，游泳都可以。力量训练有一定的门槛，个人也最近正在学习一些入门训练方式。

药物

药物方面的研究也非常多，不过绝大多数都还在人体实验的早期。具体可以参考发表在 Nature 上的这篇 The quest to slow ageing through drug discovery，总结了各种相关研究，其中就包括了著名的二甲双胍，NMN 等。

细胞重编程

前面也提到了基因表达是影响衰老最重要的因素，那么有没有手段来控制人体细胞的基因表达呢？著名的山中因子（Yamanaka Factors）给出了一种可能。山中伸弥团队发现的诱导方法是，通过慢病毒载体将 Oct4、Sox2、c-Myc、Klf4 四种转录因子基因转入成体细胞，将其转化为类似于胚胎干细胞的多能干细胞（iPS 细胞）。iPS 细胞与胚胎干细胞拥有相似的再生能力，理论上可以分化为成体的所有器官、组织，而这一点完美地对冲了由细胞衰减带来的人体衰老。听起来是不是非常的神奇？基于这些新技术也出现了很多主攻长寿领域的科技创新公司，如 Life Biosciences，Altos Labs 等，我们可以期待一下未来这些技术的普及应用。

实践

这里列出一些 Sinclair 自己的实践方式，如果想要采纳还是要结合自身的情况来看。有意思的是这集节目下有个热门留言是这个教授竟然已经 52 岁了，完全看不出来……所以你懂的。

不吃早饭，午饭也吃的比较少，酸奶或者橄榄油，晚饭吃蔬菜为主，加鱼和虾，基本不吃牛排。不吃糖，甜品，面包。基本达到了 2 小时进食窗口的高阶 fasting 状态。他偶尔也会尝试一整天都不吃东西，但比较难坚持。
每天摄入 1 克的白藜芦醇（resveratrol），1 克的 NMN（进而会转化为 NAD，which is sirtuin 的“燃料”），还有二甲双胍（metformin）。其中锻炼的日子可能会跳过一些补充品。他并不吃复合维生素。
以蔬菜为主食的好处：富含各种营养，维生素；包含异种激素（Xenohormesis），植物基于“压力”之下产生的物质，对长寿有益。后者也可以通过槲皮素（quercetin）来做膳食补充。
一般会隔一天进行有氧运动和力量训练。有氧运动能提升 NAD 水平。
根据家族病史来决定一些药物摄入，如他 29 岁就开始服用降胆固醇药物。
对于人造甜味剂，教授认为总体来说是安全的。他偶尔也会喝健怡可乐。

对于这一系列实践，Sinclair 教授都进行了 10 多年的自身实验，并使用各种手段来监控身体数据。通过监控数据可以推测出一个人的“生理年龄”如何（不是光看脸），他自己在上述实践下，生理年龄在持续下降，现在已经达到了 30 岁左右的水平（实际年龄 52 岁）。另外，他认为每个人的身体情况不一样，医院约定俗成的生理指标范围也不一定适合每个人。未来这种健康数据的实时监控与个性化诊断会成为主流。他举了一些例子：

监控血糖水平 HbA1c，观察 fasting 的影响等。
监控炎症指标 CRP，与心脏病等各种疾病的诱发相关。
监控 LDL，通过药物等进行控制。膳食胆固醇对血液胆固醇几乎没有影响，不需要戒红肉，黄油等。
补充铁元素可能加速衰老。医学指标需要个性化，低铁元素含量并不一定导致贫血。

还有一些影响寿命的负面因素：

肥胖症会加速衰老。
吸烟，会破坏基因表达，加速衰老。
X 光检查同理，没有必要时，避免接触。

补充剂

基础维生素，常规补充剂，也可以根据自己的饮食结构，生活习惯选择特定的营养物质补充。
Omega-3 EPA，常年销量靠前的补充剂，好处前面已经说了很多了。
AG1，超火的小绿粉，各种植物提取物 + 各种维生素矿物会，Fridman 等大佬的节目里都有提到。个人买了一次，不过看一些其它评测貌似并不是很划得来。
Betaine HCL & Pepsin，保护肠胃，促进吸收。
L-Tyrosine，提升多巴胺，可能会买个尝尝鲜。
二甲双胍，抗衰老“神药”，不过这个药的有效性和安全性还有争议，建议谨慎。
ResveraCel，白藜芦醇，NR 等抗衰老组合。效果同样有争议，尤其 NMN 这块更是各种产品鱼龙混杂无法分辨，谨慎购入。

第一个进程

2021-06-21T00:00:00+08:00

第一个进程的产生

Xv6执行指令时的3种模式：

machine mode
supervisor mode
user mode

CPUs provide a special instruction that switches the CPU from user mode to supervisor mode and enters the kernel at an entry point specified by the kernel.(RISC-V provides the ecall instruction for this purpose.) Once the CPU has switched to supervisor mode, the kernel can then validate the arguments of the system call(e.g.,check if the address passed to the system call is part of the application’s memory),decide whether the application is allowed to perform the requested operation(e.g., check if the applications is allowed to write the specified file), and then deny it or execute it. It is important that the kernel control the kernel entry point, a malicious application could, for example, enter the kernel at a point where the validation of arguments is skipped.

The mechanisms used by the kernel to implement processes include the user/supervisor mode flag, address spaces, and time-slicing of threads.

进程的虚拟内存分布

An address space includes the process’s user memory starting at virtual address zero. Instructions come first, followed by global variables, then stack, and finally a “heap” area(for malloc) that the process can expand as needed.

There are a number of factors that limit the maximum size of a process’s address space: pointers on the RISC-V are 64 bits wide; the hardware only uses the low 39 bits. Thus, the maximum address is $2^{38} - 1 = 0×3FFFFFFFFF$,which is MAXVA. At the top of the address space xv6 reserves a page for trampoline and a page mapping the process’s trapframe. Xv6 uses these two pages to transition in and out of the kernel and mapping thetrapframe is necessary to save/restore the state of the user process.

xv6进程的状态信息存储在struct proc
A process can make a system call by executing the RISC-V ecallinstruction. This instruction raises the hardware privilege level and changes the program counter to a kernel-defined entry point. The code at the entry point switches to a kernel stack and executes the kernel instructions that implement the system call.
When the system call completes, the kernel switches back to the user stack and returns to user space by calling sretinstruction, which lowers the hardware privilege level and resumes executing user instructions just after the system call instruction.
A process’s thread can “block” in the kernel to wait for I/O, and resume where it left off when the I/O has finished
p->state indicates whether the process is allocated, ready to run, running, waiting for I/O, or exiting.
p->pagetable holds the process’s page table, in the format that the RISC-V hardware expects. Xv6 causes the paging hardware to use a process’s p->pagetable when executing that process in user space. A process’s page table also serves as the record of the address of the physical pages allocated to store the process’s memory.

The first process and system call

The bootloader loads the xv6 kernel into memory(then, in machine mode the CPU executes xv6 starting at _entry with paging hardware disabled: virtual addresses map directly to physical address)
_entry declares space for an initial stack, stack0 in the file start.c. The code at _entry loads stack pointer sp with the address stack0 + 4096. Then _entry calls into C code at start
start function performs some configurations then switches to supervisor mode(it sets the previous privilege mode to super in the register mstatus, it sets the return address to main by writing main’s address into the page-table register satp, and delegates all interrupts and exceptions to supervisor mode)
Before jumping into supervisor mode, start performs one more task: it programs the clock chip to generate timer interrupts. Then start “returns” to supervisor mode by calling mret. This causes the program counter to change to main.
Then main initializes serval devices and subsystems, it creates the first process by userinit.
The first process executes a small program written in RISC-V assembly. initcode.S (user/initcode.S:3) loads the number for the exec system call, SYS_EXEC (kernel/syscall.h:8), into register a7, and then calls ecall to re-enter the kernel.
The kernel uses the number in register a7 in syscall (kernel/syscall.c:133) to call the desired system call. The system call table (kernel/syscall.c:108) maps SYS_EXEC to sys_exec, which the kernel invokes.

Regular Expressions

2021-05-27T00:00:00+08:00

\d # Matches any digit character. Equivalent to [0-9]
\D # Matches all non-digit characters
\w # Matches any word character. == [A-Za-z0-9_]
\s # Matches any whitespaces, tabs or line breaks
*  # Matches 0 or more of the previous pattern
+  # Matches 1 or more of the previous pattern
?  # Matches 0 or 1 of the previous pattern
{} # Use like {Min,Max}
^  # Matches the begining of a string
$  # Matches the end of a string
\b # Matches a world boundary, the begining or end of a word

The re module

re.search(pattern,string)  # returns a Match object representing the first occurrence of pattern within string
re.fullmatch(pattern,string) # returns a Match object, requiring that pattern matches the entirety of string
re.match(pattern,string) # returns a Match object, requiring that string starts with a substring that matches pattern
re.findall(pattern,string) # returns a list of strings representing all matches of pattern within string, from left to right
re.sub(pattern,repl,string) # substitutes all matches of pattern within 

Mutable-List

2021-05-27T00:00:00+08:00

We will represent a mutable linked list by a function that has a linked list as its local state. Lists need to have an identity, like any mutable value. In particular, we cannot use None to represent an empty mutable list, because two empty lists are not literal values. but None is None. On the other hand, two different functions that each have empty as their local state will suffice to distinguish two empty lists.

If a mutable linked list is a function, what arguments does it take? The answer exhibits a general pattern in programming: the function is a dispatch and it arguments are first a message followed by

Computation by such a network proceeds as follows: When a connector is given a value(by the user or by a constraint box to which it is linked) it awakens all of its associated constraints(except for the constraint box to which it is linked) it awakens all of its associate

Each awakened constraint box then polls its connectors to see if there is enough information to determine a value for a connector. If so, the box sets that connector, which then awakens all of its associated constraints, and so on. For instance, in conversion

Constraints are dictionaries that do not hold local states themselves. Their response to messages are non-pure functions that change the connectors that they constrain.

Connectors are dictionaries that hold a current value and respond to messages that manipulate value. Constraints will not change the value of connectors directly, but instead will do so by send messages, so that the connector can notify other constraints in response to the change. In this way connector represents a number, but also encapsulates connector behavior.

from operator import add, sub
def adder(a,b,c):
    """The constraint that a + b = c"""
    return make_ternary_constraint(a,b,c,add,sub,sub)

def make_ternary_constraint(a,b,c,ab,ca,cb):
    def new_value():
        av,bv,cv = [connector['has_val']() for connector in (a,b,c)]
        if av and bv:
            c['set_val'](constraint,ab(a['val'],b['val']))
        elif av and cv:
            b['set_val'](constraint,ca(c['val'],a['val']))
        elif av and bv:
            c['set_val'](constraint,cb(c['val'],b['val']))
     def forget_value():
        for connector in (a,b,c):
            connctor['forget'](constraint)
     constraint = ['new_val':new_value,'forget':forget value]
    for connector in (a,b,c):
        connector['connect'](constraint)
    return constraint

def constant(connector,value):
    constraint = {}
    connector['set_val'](constraint, value)
    connector['connect'](constraint)
    return constraint

A connector is represented as a dictionary that contains a value, but has response functions with local state. The connector must track the informant that gave it its current value, and a list of constraints in which it participates.
The constructor has local functions for setting and forgetting values, which are the response to messages from constraints.

def connector(name = None):
    """A connector between constraints"""
	informant = None
    constraints = []
    def set_value(soucre,value):
        nonlocal informant
        val = connector['val']
        if val is None:
            informant, connector['val'] = source,value
            if name is not None:
                print(name, '=', value)
            inform_all_except(source,'new_val',constraints)
        else:
            if val != value:
                print('Contradiction detected:',val,'vs','value')
     def forget_vale(source):
        nonlocal informant
        if informant == souce:
            informant, connector['val'] = None, None
            if name is not None:
                print(name,'is forgetten')
            inform_all_except(source,'forget',constraints)
	connector = {'val': None,
                 'set_val': set_value,
                 'forget': forget_value,
                 'has_val': lambda: connector['val'] is not None},
    			 'connect': lambda source: constraints.append(source)
        
def inform_all_except(source,message,constraints):
    """Inform all constraints of the message, except source"""
    for c in constraints:
        if c != source:
            c[messgae]()

Arithmetic. Special methods can also define the behavior of built-in operators applied to user-defined objects. In order to provide this generality. Python follows specify protocols to apply each operator. For example, to evaluate expression that contain the + operator. Python checks for special methods on both the left and right operands of the expression. First python checks for an_add_ method on the value of the right operand as its argument. Some examples are given in the following sections.

Multiple Representations

Abstraction barriers allow us to separate the use and representation of data. However in large programs. It may not always make sense to speak of “the underlying representation” for a data type in a program. For one thing, there might be more than one useful representation for a data object, and we might like to design systems that can deal with multiple representations.

To take a simple example. complex numbers may represented in two almost equivalent ways: in rectangular form and in polar form. Sometimes the rectangular form is more appropriate and sometimes the polar form(magnitude and angle) Indeed, it is perfectly plausible to imagine a system in which complex numbers are represented in both ways, and in which the functions for manipulating complex numbers are represented in both ways. and in which the functions for manipulating complex numbers work with either representation. We implement such a system below. As a side note, we are developing a system that performs arithmetic operations on complex numbers as a simple but unrealistic example of a program that uses generic operations.

The idea of allowing multiple representations of data arises regularly. Large software systems are often designed by many people working over extended periods of time. subject to requirements that change over time. In such environment, it is simply not possible for everyone to agree in advance We need abstraction barriers that isolate different design choices from each other and permit different choices to coexist in a single program

We will begin our implementation at the highest level of abstraction and work towards concrete representations. A complex number is a Number, and numbers can be added or multiplied together. How numbers can be added or multiplied is abstracted by the method names add and mul.

class Number:
    def __add__(self,other):
        return self.add(other)
    def __mul__(self,other):
        return self.mul(other)

This class requires that Number objects have add and mul methods, but does not define them. Moreover, it does not have and init method. The purpose of Number is not to be instantiated directly, but instead to serve as a superclass of specific number classes.

While multiplying complex numbers, it is more natural thinks in terms of representing a complex number in polar form, as a magnitude and an angle. The product of two complex numbers is the vector obtained

class Complex(Number):
    def add(self,other):
        return ComplexRI(self.real + other.real, self.imag + other.imag)
   	def mul(self,other):
        magnitutde = self.magnitude * other.magnitude
        return ComplexMA(magnitude, self.angle + other.angle)

ComplexRI constructs a complex number from real and imaginary parts
ComplexMA constructs a complex number from a magnitude and angle

interface. Objects attributes, which are a form of message passing, allows different data types to respond the same message in different ways. A shared set of messages that elicit similar behavior from different classes is a powerful method of abstraction. An interface is a set of shared attribute names. along with a specification of their behavior. In the case of complex numbers., the interface needed to implement arithmetic consists of four attributes: real, image, magnitude and angle.

Properties. The requirement that two or more attributes values maintain a fixed relationship with each other is a new problem. One solution is to store attributes values for only one representation and compute the other representation whenever it is needed.

from math import atan2
class ComplexRI(complex):
    def __init__(self,real,imag):
        self.real = real
        self.image = imag
    @property
    def magnitude(self):
        return (self.real**2 + self.image**2)**0.5
    @property
    def angle(self):
        return atan2(self.image,self.real)
    def __repr__(self):
        return 'ComplexRI({0:g}, {1:g})'.format(self.real, self.imag)
    
from math import sin, cos, pi
class ComplexMA(Complex):
        def __init__(self, magnitude, angle):
            self.magnitude = magnitude
            self.angle = angle
        @property
        def real(self):
            return self.magnitude * cos(self.angle)
        @property
        def imag(self):
            return self.magnitude * sin(self.angle)
        def __repr__(self):
            return 'ComplexMA({0:g}, {1:g} * pi)'.format(self.magnitude, self.angle/pi)

The interface approach to encoding multiple representations has appealing properties. The class for each representation can be developed separately, they must only on the names of the attributes they share, as well as any behavior conditions for those attribute. The interface is also additive. If another programmer wanted to add a third representation of complex numbers to the same program, they would only have to create another class with the same attributes.

Generic Functions

Generic Functions are methods or functions that apply to arguments of different types. We have seen many examples already. The complex.add method is generic, because it can take either a ComplexRI and ComplexMA as the value of other. This flexibility was ensuring that both ComplexRI and ComplexMA share an interface.

from fractions import gcd
class Rational(Number):
    def __init__(self,number, denom):
        g = gcd(number, denom)
        self.number = number // g
        self.denom = denom // g
    def __repr__(self):
        return 'Rational({0}, {1})'.format(self.numer, self.denom)
    def add(self, other):
            nx, dx = self.numer, self.denom
            ny, dy = other.numer, other.denom
            return Rational(nx * dy + ny * dx, dx * dy)
    def mul(self, other):
            numer = self.numer * other.numer
            denom = self.denom * other.denom
            return Rational(numer, denom)

>>> Rational(2, 5) + Rational(1, 10)
Rational(1, 2)
>>> Rational(1, 4) * Rational(2, 3)
Rational(1, 6)

Type dispatching.

One way to implement cross-type operations is to select behavior based on the types of the arguments to a function or method. The idea of type dispatching is to write functions that inspect the type arguments they receive, then execute that is appropriate for those types.

def is_read(c):
	if isinstance(c, complexRI):
		return c.image == 0
    elif isinstance(c,complexMA):
        return c.angle % pi == 0

def add_complex_and_rational(c,r):
    return ComplexRI(c.real + r.number / r.denom, c.imag)

def mul_complex_and_rational(c,r):
    return ComplexMA(c.magnitude * r.magnitude, c.angle + r.angle)

The role of type dispatching is to ensure that these cross-type operations are used at appropriate times. Below, we rewrite the Number superclass to use type dispatching for its add and mul methods.

We use the type_tag attribute to distinguish types of arguments. One could directly use the built-in isinstance method as well.

The add method considers two cases.

class Number:
	def __add__(self,other):
        if self.type_tag == other.tag:
            return self.add(other)
        elif (self.type_tag,other.type_tag) in self.adders:
            return self.cross_apply(other, self.adder)
     def __mul__(self,other):
        if self.type_tag == other.tag:
            return self.mul(other)
        elif (self.type_tag,other.type_tag) in self.multiplies:
            return self.cross_apply(other,self.multiplies)
     def cross_apply(self,other,cross_fns):
        cross_fn = cross_fns[(self.type_tag,other.type_tag)]
        return cross_fn(self,other)
     adders = {("com", "rat"): add_complex_and_rational,
                  ("rat", "com"): add_rational_and_complex}
     multipliers = {("com", "rat"): mul_complex_and_rational,
                       ("rat", "com"): mul_rational_and_complex}
        
        

In this new definition of the Number class, all cross-type implementation are

While we have introduced some complexity to the system, we can now mix types in addition and mutiplication expressions

Coercion. Often the different data types are not completely independent, and there may be ways by which objects of one type may be viewed as being of another type. This process is called coercion. For example, if we are asked to arithmetically combine a rational number with a complex number, we can view the rational number as a complex number a rational number with a complex number. we can view the rational numbers as a complex number

In general, we can implement this ideas by designing coercion functions that transform an object of one type into an equivalent object of another type.

def rational_to_complex(r):
    return ComplexRI(r.numer / r.denom, 0)

The alternative definition of the Number class performs cross-type operations by attempting to coerce both arguments to the same type. The coercions dictionary indexes all possible coercions by a pair of type tags. Indicating that the corresponding value coerces a value of the first type to a value of the second type

The coerce method returns two values with the same type_tag. It inspects the type_tags of its argument, compares them to entries in the coercions dictionary. and converts one argument to the type of the other using coerce_to. Only

class Number:
    def __init__(self,other):
        x, y = self.coerce(other)
    def __mul__(self,other):
        x, y = self.coerce(other)
        return x.mul(y)
  	def coerce(self,other):
        if self.type_tag == other.type_tag:
            return self,other
        elif (self.type_tag,other.type_tag) in self.coercions:
            return (self.coerce_to(other.type_tag), other)
        elif (other.type_tag,self.type_tag) in self.coercions:
            return (self,other.coerce_to(self.type_tag))
     def coerce_to(self,other_tag):
        coercion_fn = self.coercions[(self.type_tag, other_tag)]
        return coercion_fn(self)
     coercions = [('rat', 'com'); rational_to_complex]

Further advantages come from extending coercion. Some more sophisticated coercions schemes do not just try to coerce one type into another. but instead may try to coerce two different types each into a third common type

Streams

Streams offer another another way to represent sequential data implicitly. A stream is a lazily computed linked list. Like the Link class. A stream instance responds to requests for its first element and the rest of the stream. Like an Link, the rest of a Stream is itself a Stream. Unlike an Link, the rest of a stream is only computed when it is looked up, rather than being stored in advance. That is, the rest of a stream is computed lazily

To achieve this lazy evaluation, a stream stores a function that computes the rest of the stream. Whenever this function is called, its returned value is cached as part of the stream in an attribute called _rest named with an underscore to indicate that it should not be accessed directly.

class Stream:
    """A lazily computed linked list"""
    class empty:
        def __repr__(self):
            return 'Stream empty'
    empty = empty()
    def __init__(self,first,compute_test=lambda: empty):
    	assert callable(compute_test), 'compute_rest must be callable'
        self.first = first
        self._compute_rest = compute_rest
    @property
    def rest(self):
        """Return the rest of the stream computing it if necessary"""
        if self._compute_rest is not None:
            self._rest = self._compute_rest()
            self._compute_rest = None
        return self._rest
   	def __repr__(self):
        return 'Stream({0},<...>)'.format(repr(self.first))

When a Stream instance is constructed, the field self._rest is None, signifying that the rest of the Stream has not yet been computed. When the rest attribute is requested via a dot expression, the rest property method is invoked, which triggers computation with self._rest = self._compute_rest()

def integer_stream(first):
    def compute_rest():
        return integer_stream(first+1)
   	return Stream(fist,compute_rest)

def map_stream(fn,s):
    if s is Stream.empty:
        return s
    def compute_rest():
        return map_stream(fn,s.rest)
    return Stream(fn(s.first),compute_rest)

def filter_stream(fn,s):
    if s is Stream.empty:
        return s
    def compute_test():
        return filter_stream(fn,s.rest)
    if fn(s.first):
        return Stream(s.first,compute_rest)
    else:
        return compute_rest()

We can use our filter_stream function to define a stream of prime numbers using the sieve of Eratosthenes, which filters a stream of integers to remove all numbers that are multiples of its first element. By successively filtering with each prime, all composite numbers are removed from the stream.

def primes(pos_stream):
    def not_divible(x):
        return x % pos_stream.first != 0
    def compute_rest():
        return primes(filter_stream(not_divible,pos_stream.rest))
    return Stream(pos_stream.first,compute_rest)
        

EVAL-APPLY

2021-05-27T00:00:00+08:00

Eval

Base cases:

Primitive values(numbers)
Look up values bound to symbols

Recursive calls:

Eval(operator, operands) of call expressions
Apply(procedure, arguments)
Eval(sub-expression) of special forms

Apply

Base cases:

Built-in primitive procedures

Recursive calls:

Eval(body) of user-defined procedures

Scheme evaluation

The _scheme_val function chooses behavior based on expression form:

Symbols are looked up in the current environment
Self-evaluating expressions(booleans, numbers, nil) are returned as values
All other legal expressions are represented as Scheme lists, called combinations

Evaluating combinations

The special forms can all be identified by the first elements:

(if <predicate> <consequent> <alternative>)
(lambda (<formal-parameters> <body>))
(define <name> <expression>)

Any combination that is not a known special form must be a call expression

(define (demo s)
  	(if (null? s)
        '(3)
        (cons (car s) (demo (cdr s)))));
(demo (list 1 2))

Logical special forms

Logical forms are special forms that may only evaluate some sub-expressions.

Quotation

‘ is shorthand for (quote ) '(1 2) is equivalent to (quote (1 2))

Define Expressions

Define binds a symbol to a value in the first frame of the current environment

(define )

Evaluate the
Bind to its value in the current frame

Procedure definition is shorthand of define with a lambda expression

(define ( ) <body>)

(define (lambda () <body>))

Lambda Expressions

Lambda expressions evaluate to user-defined procedures

(lambda () <body> ...)

class LambdaProcedure:
    def __init__(self,formals,body,env):
        self.formals = formals
        self.body = body
        self.env = env

尾递归调用

In Scheme interpreters, a tail-recursive function should only require a constant number of active frames.

(define (factorial n k)
  	(if (= n 0)
        k
        (factorial (- n 1) (* k n))))

A tail call is a call expression in a tail context:

The last body sub-expression in a lambda expression
Sub-expression 2&3 in a tail context if expression
All non-predicate sub-expression in a tail context
The last sub-expression in a tail context and, or, begin or let.

(define (length s)
  (if (null? s) 0
  (+ 1 (length (cdr s)))))
//A call expression is not a tail call if more computation is stil required in the calling procedure
(define (length-tail s)
  (define (length-iter s n)
    (if (null? s) n
    (length-iter (cdr s) (+ 1 n))))
  (length-iter s 0))

Reduce

(reduce * '(3 4 5) 2) 120
(define (reduce procedure s start)
  	(if (null? s) start
        (reduce procedure
             (cdr s)
             (procedure start (car s)))))

Is is tail recursive?

Yes! Because reduce is in a tail context.

However, if procedure is not tail recursive, then this may still require more than constant space for execution.

(map (lambda (x) (- 5 x)) (list 1 2))
(define (map procedure s)
  	(if (null? s)
        nil
        (cons (procedure (car s))
              (map procedure (cdr s)))))

原文这里引用的是本机 Typora 截图，图片文件没有随仓库保存。

Is it tail recursive?

×No, because map is not in a tail context

(define (map procedure s)
  (define (map-reverse s m)
    (if (null? s)
        m
        (map-reverse (cdr s) (cons (procedure (car s)) m))))
  (reverse (map-reverse s nil)))

(define (reverse s)
  (define (reverse-iter s r)
  (if (null? s)
      r
      (reverse-iter (cdr s) (cons (car s) r))))
  (reverse-iter s nil))

(map (lambda (x) (- 5 x)) (list 1 2))

Tail call optimization with trampolining

What the thunk?

Thunk: An expression wrapped in an argument-less function.

Making thunks in Python:

thunk1 = lambda: 2 * (3 + 4)
thunk2 = lambdaL add(2, 4)

Calling a thunk later:

thunk1()
thunk2()

Trampolining

Trampoline: A loop that iteratively invokes thunk-returning functions.

def trampoline(f, *args):
	v = f(*args)
    while callable(v):
        v = v()
    return v

The function needs to be thunk-returning! One possibility:

def factorial_thunked(n, k):
    if n == 0:
        return k
    else:
        return lambda: factorial_thunked(n - 1, k * n)
    
trampoline(factorial_thunked,3, 1)

Tail Context

When trying to identify whether a given function call within the body of a function is a tail call, we look for whether the call expression is in tail context.

Given that each of the following expressions is the last expression in the body of the function, the following expressions are tail contexts:

the second or third operand in an if expression
any of the non-predicate sub-expressions in a cond expression (i.e. the second expression of each clause)
the last operand in an and or an or expression
the last operand in a begin expression’s body
the last operand in a let expression’s body

For example, in the expression (begin (+ 2 3) (- 2 3) (* 2 3)), (* 2 3) is a tail call because it is the last operand expression to be evaluated.

C string

2021-05-27T00:00:00+08:00

A string in C is just an array of characters.

char string[] = “abc”;

How do u tell how long a string is?

Last characters is followed by a 0 byte(null terminator)

int strlen(char s[])
{
    int n = 0;
    while(s[n] != 0) n++;
    return n;
}

C String Standard Functions

int strlen(char *string);
// compute the length of string
int strcmp(char *str1, char *str2);
// return 0 if str1 and str2 are identical(how is this different from str1 == str2?)
char *strcpy(char *dst, char *src);
/*
copy the contents of string src to the memory at dst. The caller must ensure that dst has enought memory to hold the data to be copied
*/

Arrays(one elt past array must be valid)

What if we have an array of large structs?
- C take care of it: In reality, p+1 doesn’t add 1 to the memory address, it adds the size of the array element.

*p++ vs (*p)++
x = *p++   -> x = *p; p = p + 1
x = (*p)++ -> x = *p; *p = *p + 1

Arrays vs. Pointers

An array name is a read-only pointer to the 0th element of the array.
An array parameter can be declared as an array or a pointer; an array argument can be passed as a pointer.

Segmentation Fault vs Bus Error?

Buss Error
- A fatal failure in the execution of a machine language instruction resulting from the processor detecting an anomalous condition on its bus. Such conditions include invalid address alignment(accessing a multi-byte number at an odd address), accessing a physical address that does not correspond to any device. or some other device-specific hardware error. A bus error triggers a processor-level exception which Unix translates into a “SIGBUS” signal which, if not caught, will terminate the current process.
Segmentation Fault
- An error in which a running Unix program attempts to access memory not allocated to it and terminates with a segmentation violation error and usually a core dump.

C Strings Headaches

One common mistake is to forget to allocate an extra byte for the null terminator.
- When creating a long string by concatenating serval smaller strings, the programmer must insure there is enough space to store the full string!
- What if u don’t know ahead of time how big your string will be?
- Buffer overrun security holes!

C structures: Overview

A struct is a data structure composed from simpler data types.

struct point{
    int x;
    int y;
}
  
void PrintPoint(struct point p)

Linked List Example

struct Node{
    char *value;
    struct Node *next;
}; // Recursive definition!
// "typedef" means define a new type
typedef struct Node NodeStruct;
//	...or...
typedef struct Node{
    char *value;
    struct Node *next;
}NodeStruct;
// ...Then
typedef NodeStruct * List;
typedef char * String;

/*
Note similarity! To define 2 nodes
*/
struct Node{
    char* value;
    struct Node *next;
}node1, node2;

// Add a string to an existing list
List cons(String s, List list)
{
    List node = (List)malloc(sizeof(NodeStruct));
    node->value =(String)malloc(strlen(s) + 1);
    strcpy(node->value,s);
    node->next = list;
    return node;
}

Basic C language

2021-05-27T00:00:00+08:00

Basic C

For C, generally a two part process of compiling source files(.c) to object files(.o), then linking the .o files into executables.

C Pre-Processor(CPP)

C source files first pass through “macro preprocessor”, before compiler sees code
CPP commands begins with “#”
- #include “file.h” // Inserts file.h into output
- #include // Looks for file in standard location
- define M_PI 3.14 // Define constant
- #if / #endif // Conditional inclusion of text

Structs in C

typedef struct{
    int length_in_seconds;
    int year_recorded;
}Song

Switch

switch(expressions){
    case const1: statements
    case const2: statements
        default: statements
}

What evaluates to FALSE in C

0(integer)
NULL(a special kind of pointer that is also 0: more on this later)
No explicit Boolean type in old-school C
- Often u see #define bool (int)
- Then #define false 0
- Alternative approach: include a header file #include to provide a boolean type
Basically anything where all the bits are 0 is false

Our Tip of the Day.. Valgrind

Valgrind
Use a <= instead of a < in initializing an array in a completely different part of the program.

Types of Pointers

*void ** is a type that can point to anything
Use *void ** sparingly to help avoid programs bugs, and security issues, and other bad thing
U can have pointers to pointers

U can even have pointers to functions…

int (*fn)(void *,void *) = &foo
// fn is a function that accepts two void* pointers and returns an int
// and initially pointing to the function foo
// (*fn)(x,y) will then call the function

More C Pointer Dangers

Declaring a pointer just allocates space to hold the pointer-it does not allocate the thing being pointed to.
Local variables in C are not initialized, they may contain anything.

Backus-Naur-Form

2021-05-27T00:00:00+08:00

Backus-Naur-Form

Basic BNF

The basic form of a grammar rule

symbol0: symbol1 symbol2 ... symboln

Symbols represent sets of strings and come in 2 flavors

Non-terminal symbols: Can expand into either non-terminal symbols or terminals
Terminal symbols: Strings or regular expressions

item* items: |items item
item+ items: item | items item
item? optitem: | it

Mathidot

Lab3_pagetable

Xv6调试指南

xv6调试指南

页表读书笔记

Physical memory allocation

Code: Physical memory allocator

Code: sbrk

Real world

命令行环境

命令行环境

任务控制

结束进程

暂停和后台执行进程

终端多路复用

别名

配置文件（Dotfiles）

可移植性

远端设备

执行命令

SSH 密钥

密钥生成

基于密钥的认证机制

通过 SSH 复制文件

端口转发

SSH 配置

杂项

Problems

终端多路复用

别名

配置文件

远端设备

HEVC

How des HEVC work?

Partitioning

Prediction

数据整理

正则表达式

回到数据整理

awk – 另外一种编辑器

分析数据

利用数据整理来确定参数

整理二进制数据

课后习题

Mit 6.s081 operating system enginerring lab1 utilities

MIT 6.S081 Operating System Enginerring Lab1 Utilities

sleep(easy)

Solution

pingpong (easy)

primes(hard)

find(moderate)

xargs(moderate)

xv6概述-1

代码组织情况和操作系统影像的生成

xv6二进制代码分为两部分

bootblock

operators and expressions

条件操作符

逗号操作符

cgdb

How to find segfaults

Other Useful GDB Commands

XV6 安装与调试

启动GDB调试xv6

GDB命令

Vim notes

5 modes

command-line mode

movement in normal mode

selection in normal mode

edit commands

count with manipulation

vim extensions

搜索和替换

多窗口

宏

扩展资料

课后练习

Vimtutor笔记

valgrind note

`Vimtutor`笔记

Json解析启程

Json解析启程