Yume

滑块游戏

2013-05-30T00:00:00+08:00

想必大家小时候都玩过右边这个玩具，在一个 $ 3\times 3 $ 的盒子里面，移动 8 块方块，最终拼成一个图案。这个看似简单的问题，寻找最优解竟然是 NP 完全的，但是本文的目的不是寻找最优解，只是简单的寻找一个解而已。

是否所有排列都有解

假设我们把里面的 8 个小方块全部挖出来，然后再随机装回去，那么这样装回去肯定能够拼回原样么？答案是不能，下面解释一下为什么不能。

首先介绍一个概念，逆序数

設 $ A $ 為一個有 $ n $ 個數字的有序集 $ (n>1) $，其中所有數字各不相同。

如果存在正整數 $ i, j $ 使得 $ 1 \le i \lt j \le n $ 而且 $ A_{ i } \gt A_{ j } $，

則 $ \left< { A }_{ i },{ A }_{ j } \right> $ 這個有序對稱為 $ A $ 的一個逆序對

逆序数就是 $ A $ 中所有逆序对的数量

$ inv(A)=\# \left\{\ \left< { A }_{ i },{ A }_{ j } \right> \mid i \lt j \ and \ { A }_{ i } \gt { A }_{ j } \right\} $

为了方便理解，这里举例说明一下：

$ \left\{\ 1,2,3,4,5 \right\} $ 五个顺序的数，逆序数为0

$ \left\{\ 1,2,4,3,5 \right\} $ 交换3-4，有一个逆序对 $ \left< 4, 3 \right> $，所以逆序数是1

$ \left\{\ 1,2,5,4,3 \right\} $ 交换3-5，产生三个逆序对 $ \left< 5, 4 \right>,\left< 5, 3 \right>,\left< 4, 3 \right> $，所以逆序数是3

下面进入正题，首先我们给 8 个方块编号，然后定义其逆序数就是按照行列顺序组成数列的逆序数，例如：

$ inv(\begin{bmatrix} 5 & 8 & 1 \\ & 9 & 2 \\ 4 & 6 & 3 \end{bmatrix})=inv(\left\{\ 5,8,1,9,2,4,6,3 \right\} ) $

我们考虑移动方块对其逆序数的影响，每次操作可以把空方块上下左右四个方向其中某个方向的方块移动到空方块的位置

明显左右移动不会影响其逆序数：

$ inv(\begin{bmatrix} 5 & 8 & 1 \\ & 9 & 2 \\ 4 & 6 & 3 \end{bmatrix})=inv(\begin{bmatrix} 5 & 8 & 1 \\ 9 & & 2 \\ 4 & 6 & 3 \end{bmatrix}) $

上下移动相当于把某数字往前移动 2 位，或者往后移动 2 位

$ inv(\begin{bmatrix} 5 & 8 & 1 \\ & 9 & 2 \\ 4 & 6 & 3 \end{bmatrix})=inv(\left\{\ 5,8,1,9,2,4,6,3\right\} )\\ inv(\begin{bmatrix} 5 & 8 & 1 \\ 4 & 9 & 2 \\ & 6 & 3 \end{bmatrix})=inv(\left\{\ 5,8,1,4,9,2,6,3\right\} ) $

这里只讨论向下移动对逆序数的影响，由于对称性，向上移动相同。向下移动就是把某个数在序列中往后移动两位，由于除了受影响的这三个数，其他数前后的顺序都没有变化，所以不会影响逆序数，我们把这三个数拿出来，分析逆序数的变化：

$ inv\left( \left\{\ a,b,c \right\} \right) -inv\left( \left\{\ b,c,a \right\} \right) =\begin{cases} -2 & \left\{\ a \lt min\left( b,c \right) \right\} \\ 0 & \left\{\ min\left( b,c \right) \lt a \lt max\left( b,c \right) \right\} \\ 2 & \left\{\ a>max\left( b,c \right) \right\} \end{cases} $

可以看出所有移动都不会改变逆序数的奇偶性，由于最终目标的逆序数是 0，所以如果初始状态的逆序数的是奇数，那么将会出现无解的情况。

解法

首先，我们需要找到一个方法在不改变逆序数的情况下，随意移动空位，明显在同一行移动空位是非常简单的：

$ \begin{bmatrix} 1 & 2 & 3 \\ & 4 & 5 \\ 6 & 7 & 8 \end{bmatrix}\leftrightarrow \begin{bmatrix} 1 & 2 & 3 \\ 4 & & 5 \\ 6 & 7 & 8 \end{bmatrix}\leftrightarrow \begin{bmatrix} 1 & 2 & 3 \\ 4 & 5 & \\ 6 & 7 & 8 \end{bmatrix} $

下面是在不同行移动空位的方法，经过 12 步移动，我们可以把空位在上下行之间移动：

$ \begin{bmatrix} 1 & 2 & 3 \\ & 4 & 5 \\ 6 & 7 & 8 \end{bmatrix}\leftrightarrow \begin{bmatrix} & 2 & 3 \\ 1 & 4 & 5 \\ 6 & 7 & 8 \end{bmatrix}\leftrightarrow \begin{bmatrix} 2 & & 3 \\ 1 & 4 & 5 \\ 6 & 7 & 8 \end{bmatrix}\\ \leftrightarrow \begin{bmatrix} 2 & 3 & \\ 1 & 4 & 5 \\ 6 & 7 & 8 \end{bmatrix}\leftrightarrow \begin{bmatrix} 2 & 3 & 5 \\ 1 & 4 & \\ 6 & 7 & 8 \end{bmatrix}\leftrightarrow \begin{bmatrix} 2 & 3 & 5 \\ 1 & & 4 \\ 6 & 7 & 8 \end{bmatrix}\\ \leftrightarrow \begin{bmatrix} 2 & & 5 \\ 1 & 3 & 4 \\ 6 & 7 & 8 \end{bmatrix}\leftrightarrow \begin{bmatrix} & 2 & 5 \\ 1 & 3 & 4 \\ 6 & 7 & 8 \end{bmatrix}\leftrightarrow \begin{bmatrix} 1 & 2 & 5 \\ & 3 & 4 \\ 6 & 7 & 8 \end{bmatrix}\\ \leftrightarrow \begin{bmatrix} 1 & 2 & 5 \\ 3 & & 4 \\ 6 & 7 & 8 \end{bmatrix}\leftrightarrow \begin{bmatrix} 1 & 2 & 5 \\ 3 & 4 & \\ 6 & 7 & 8 \end{bmatrix}\leftrightarrow \begin{bmatrix} 1 & 2 & \\ 3 & 4 & 5 \\ 6 & 7 & 8 \end{bmatrix} $

结合使用这里两种方法，我们可以在保证数列不变的情况下，随意调整空位的位置，那么剩下的思路就相当清晰了，我们通过调整空位的位置，使上下移动能够减少逆序数，然后不断减少整个数列的逆序数，最后使得其逆序数为 0，然后把空位调整到要求位置就可以了。

实现

根据上面的思路，实现起来相当简单：

case class Puzzle(val m: Array[Int]) {
  val space = m.indexOf(0)

  def swap(i: Int, j: Int) = {
    println(this)
    Puzzle(m.slice(0,i)++Array(m(j))++m.slice(i+1,j)++Array(m(i))++m.slice(j+1,9))
  }

  def u = swap(space, space+3)
  def d = swap(space-3, space)
  def l = swap(space, space+1)
  def r = swap(space-1, space)

  def moveSpace(i: Int): Puzzle = {
    if (i == space) {
      this
    } else{
      (if (i > space) {
        if (space % 3 == 2) u.r.r.d.l.u.l.d.r.r.u else l
      } else {
        if (space % 3 == 0) d.l.l.u.r.d.r.u.l.l.d else r
      }).moveSpace(i)
    }
  }

  def solve: Puzzle = {
    val seq = m.filter(_ != 0)
    for (i <- 0 until 6) {
      if (seq(i) > seq(i+1))
        return moveSpace(i+3).d.solve
    }
    moveSpace(0)
  }

  override def toString =
    (for(i <- 0 until 3) yield m.slice(i*3, i*3+3).mkString(",")).mkString("\n") + "\n"
}

测试一下：

Puzzle(Array(0,1,2,3,4,5,8,6,7)).solve

结果太长，这里就不贴了，有兴趣可以自己跑一下

多线程程序中使用 Fork/Exec

2013-04-27T00:00:00+08:00

什么是 fork

fork 是 linux 用来创建新进程的唯一方法，虽然我们在日常使用中，不会直接调用 fork，但是经常会间接使用 fork，所有编程语言中，例如：

python 的 os.spawn*
java 的 Process 类

这些都是使用 fork 创建新进程，然后在新进程中调用 exec 系列函数。下面介绍一下 fork 的使用：

pid_t fork(void);

fork 会创建一个新进程，新创建的子进程继承父的所有属性，除了：

进程id：系统会分配一个新的进程 ID 给 fork 出来的子进程
除了调用 fork 的线程，其他线程强制终止

这里使用一段代码介绍如何使用 fork/exec

pid_t pid = fork();
if (pid < 0) {
  // error process
} else if (pid > 0) {
  // parent
  waitpid(pid, ...);
} else {
  // child

  execv(prog, ...);
}

fork/exec 的用法很简单，下面介绍一下使用的时候需要注意的问题

关闭文件

由于 fork 会继承父进程的所有打开的文件，而且 exec 函数不会关闭这些文件，所以需要在运行 exec 前确保这些文件被关闭，下面两种方法

手动关闭所有文件

在调用 exec 前，遍历并关闭所有文件，如果调用 exec 前没有关闭这些文件，子进程可以任意读写这些文件，可能会引起安全问题。例如：

login 程序执行 shell 时没有关闭 /etc/shadow 文件
webserver 调用 CGI 时没有关闭与客户端之间的 socket 文件

所以，必须在调用 exec 之前关闭所有子进程不需要使用的文件描述符。例如 ptyhon 的 subprocess.Popen 类：

class subprocess.Popen(args, bufsize=0, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, close_fds=False, shell=False, cwd=None, env=None, universal_newlines=False, startupinfo=None, creationflags=0)

提供了一个 close_fds 参数，如果开启这个参数，python 会遍历所有文件描述符，从 0 到 SC_MAX_FD，调用 close 关闭这些文件。

MAXFD = os.sysconf("SC_OPEN_MAX")
def _close_fds(self, but):
    if hasattr(os, 'closerange'):
        os.closerange(3, but)
        os.closerange(but + 1, MAXFD)
    else:
        for i in xrange(3, MAXFD):
            if i == but:
                continue
            try:
                os.close(i)
            except:
                pass

如果在一些特定环境下，ulimit 的最大文件描述符数量设置得非常大，并且程序又需要频繁创建子进程，那么关闭每次都需要关闭大量文件描述符会浪费掉大量 CPU 资源，在优化程序的时候特别要注意这点。

同时 Java 也提供了，process 类，但是 Java 中做了一些优化，通过遍历 /proc/self/fd 拿到打开的文件，然后仅仅关闭这些文件，下面是 Java 中 Process 类的 jni 代码：

if ((dp = opendir(FD_DIR)) == NULL)
    return 0;

while ((dirp = readdir64(dp)) != NULL) {
    int fd;
    if (isAsciiDigit(dirp->d_name[0]) &&
        (fd = strtol(dirp->d_name, NULL, 10)) >= from_fd + 2)
        restartableClose(fd);
}

closedir(dp);

虽然说 Java 的版本比 Python 快很多，但是仍然需要额外的操作，下面介绍 Linux 下特有（非 POSIX 接口）的方法。

使用 close_on_exec 关闭文件

close on exec，从这个东西的名字就可以看出，可以在调用 exec 的时候自动关闭这个文件，我们只需要给文件描述符设置这个 flag

fcntl(fd, F_SETFD, FD_CLOEXEC);

那么在执行到 exec 的时候，这个 fd 就会被自动关闭。

File descriptor flags 与 File status flags

为了搞清楚这两个东西的关系，需要理解 File descriptor 与 File description

 * File descriptor：文件描述符，通过 dup 可以复制文件描述符，得到两个不同的文件描述符
 * File description：文件对象，通过 dup 得到的两个文件描述符指向同一个文件对象

 * File descriptor flags：File descriptor 对应的 flag
 * File status flags：File description 对应的 flag

所以 dup 得到的两个不同的文件描述符拥有不同的 File descriptor flags，但是却共享 File status flags

下面是几个典型的 flags:

File descriptor flags
 * CLOSEXEC

File status flags
 * O_NONBLOCK
 * O_DIRECT

我们可以为每个 fd 设置 close-on-exec，那么在 exec 的时候文件就会被自动关掉。但是在多线程中就不是那么简单了，考虑下面这个场景：

由于线程1在调用 open 后，未来得及调用 fcntl设置 close-on-exec，线程2调用了 fork，子进程中线程1会被强行终止，无法设置 close-on-exec，虽然父进程中线程1仍然能够正确执行，但是子进程与父进程的 fd 不共享 File descriptor flags，所以子进程的 fd 没有 close-on-exec，在调用 exec 的时候会泄漏 fd。所以，必须保证 open 与设置 close-on-exec 为原子操作，为此，linux 修改了所有会新建 fd 的 API：

open
opendir
socket
accept
pipe2
dup3

在某些操作系统中，由于系统没有提供上述 API，无法保证打开文件描述符与设置 close-on-exec 的原子性，则需要通过额外的锁来控制：

golang 为了保证移植性，使用的就是此方法。

死锁

考虑下面这个场景：

由于持有锁的线程1被强行终止了，子进程中将永远无法获取到锁，于是程序死锁。解决这个问题的方法也非常简单，在 fork 之后，exec 之前不要使用任何锁。说来简单，但是实际上陷阱非常多，因为 libc 里面有大量函数使用了锁，例如最常用的 malloc/free 函数中就有锁。如果在进程1申请内存的时候进程2调用了 fork，并且在 exec 之前尝试申请内存就会产生死锁。POSIX 标准维护了一个函数列表 Async-signal-safe functions，需要确保程序在 exec 之前不会调用任何此列表之外的任何函数，exec 后会重置所有进程状态，之前线程获取的锁会直接被销毁。

但是有时程序的执行并不是可控的，比如 Java 程序随时可能会执行 gc 代码，如果在 exec 前启动了 gc 代码可能会导致死锁，所以必须做特殊处理避免此类情况出现。反观 python，本文中提到的这些问题 python 完全没有考虑到，python 提供了原生的 fork 与 exec 调用，fork 与 exec 之间很可能会产生 gc，所以如果想给 python 添加多线程支持，就必须伤筋动骨得大改了。

网络虚拟化技术（二）: TUN/TAP MACVLAN MACVTAP

2013-03-27T00:00:00+08:00

TUN 设备

TUN 设备是一种虚拟网络设备，通过此设备，程序可以方便得模拟网络行为。先来看看物理设备是如何工作的：

所有物理网卡收到的包会交给内核的 Network Stack 处理，然后通过 Socket API 通知给用户程序。下面看看 TUN 的工作方式：

普通的网卡通过网线收发数据包，但是 TUN 设备通过一个文件收发数据包。所有对这个文件的写操作会通过 TUN 设备转换成一个数据包送给内核；当内核发送一个包给 TUN 设备时，通过读这个文件可以拿到包的内容。

如果我们使用 TUN 设备搭建一个基于 UDP VPN，那么整个处理过程就是这样：

数据包会通过内核网络栈两次。但是经过 App 的处理后，数据包可能已经加密，并且原有的 ip 头被封装在 udp 内部，所以第二次通过网络栈内核看到的是截然不同的网络包。

TAP 设备

TAP 设备与 TUN 设备工作方式完全相同，区别在于：

TUN 设备的 /dev/tunX 文件收发的是 IP 层数据包，只能工作在 IP 层，无法与物理网卡做 bridge，但是可以通过三层交换（如 ip_forward）与物理网卡连通。
TAP 设备的 /dev/tapX 文件收发的是 MAC 层数据包，拥有 MAC 层功能，可以与物理网卡做 bridge，支持 MAC 层广播

MACVLAN

有时我们可能需要一块物理网卡绑定多个 IP 以及多个 MAC 地址，虽然绑定多个 IP 很容易，但是这些 IP 会共享物理网卡的 MAC 地址，可能无法满足我们的设计需求，所以有了 MACVLAN 设备，其工作方式如下：

MACVLAN 会根据收到包的目的 MAC 地址判断这个包需要交给哪个虚拟网卡。单独使用 MACVLAN 好像毫无意义，但是配合之前介绍的 network namespace 使用，我们可以构建这样的网络：

由于 macvlan 与 eth0 处于不同的 namespace，拥有不同的 network stack，这样使用可以不需要建立 bridge 在 virtual namespace 里面使用网络。

MACVTAP

MACVTAP 是对 MACVLAN的改进，把 MACVLAN 与 TAP 设备的特点综合一下，使用 MACVLAN 的方式收发数据包，但是收到的包不交给 network stack 处理，而是生成一个 /dev/tapX 文件，交给这个文件：

由于 MACVLAN 是工作在 MAC 层的，所以 MACVTAP 也只能工作在 MAC 层，不会有 MACVTUN 这样的设备。

网络虚拟化技术（一）: Linux网络虚拟化

2013-03-01T00:00:00+08:00

笔者现在在做云计算的网络设计，涉及到上百台服务器与交换机，在实测前必须进行原型测试，但是我只有一个工作用开发机，本文介绍一种方法，使用这一台机器模拟数十台服务器以及路由器的网络环境。

Linux的网络虚拟化是LXC项目中的一个子项目，LXC包括文件系统虚拟化，进程空间虚拟化，用户虚拟化，网络虚拟化，等等
[ LXC内核命门空间 ]
，这里使用LXC的网络虚拟化来模拟多个网络环境。

创建虚拟网络环境

使用命令

$ ip netns add net0

可以创建一个完全隔离的新网络环境，这个环境包括一个独立的网卡空间，路由表，ARP表，ip地址表，iptables，ebtables，等等。总之，与网络有关的组件都是独立的。

ip命令需要root权限的，但是由于本文大量使用ip命令，于是笔者给ip命令添加了capability，使普通用户也能使用ip命令

使用命令

$ ip netns list
net0

可以看到我们刚才创建的网络环境

进入虚拟网络环境

使用命令

$ ip netns exec net0 `command`

我们可以在 net0 虚拟环境中运行任何命令

$ ip netns exec net0 bash
$ ip ad
1: lo: <LOOPBACK> mtu 65536 qdisc noop state DOWN
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00

这样我们可以在新的网络环境中打开一个shell，可以看到，新的网络环境里面只有一个lo设备，并且这个lo设备与外面的lo设备是不同的，之间不能互相通讯。

连接两个网络环境

新的网络环境里面没有任何网络设备，并且也无法和外部通讯，就是一个孤岛，通过下面介绍的这个方法可以把两个网络环境连起来，简单的说，就是在两个网络环境之间拉一根网线

$ ip netns add net1

先创建另一个网络环境net1，我们的目标是把net0与net1连起来

$ ip link add type veth
$ ip ad
1: lo: <LOOPBACK> mtu 65536 qdisc noop state DOWN
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
81: veth0: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN qlen 1000
    link/ether 12:39:09:81:3a:dd brd ff:ff:ff:ff:ff:ff
82: veth1: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN qlen 1000
    link/ether 32:4f:fd:cc:79:1b brd ff:ff:ff:ff:ff:ff

这里创建连一对veth虚拟网卡，类似pipe，发给veth0的数据包veth1那边会收到，发给veth1的数据包veth0会收到。就相当于给机器安装了两个网卡，并且之间用网线连接起来了

$ ip link set veth0 netns net0
$ ip link set veth1 netns net1

这两条命令的意思就是把veth0移动到net0环境里面，把veth1移动到net1环境里面，我们看看结果

$ ip ad
1: lo: <LOOPBACK> mtu 65536 qdisc noop state DOWN
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
$ ip netns exec net0 ip ad
1: lo: <LOOPBACK> mtu 65536 qdisc noop state DOWN
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
81: veth0: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN qlen 1000
    link/ether 12:39:09:81:3a:dd brd ff:ff:ff:ff:ff:ff
$ ip netns exec net1 ip ad
1: lo: <LOOPBACK> mtu 65536 qdisc noop state DOWN
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
82: veth1: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN qlen 1000
    link/ether 32:4f:fd:cc:79:1b brd ff:ff:ff:ff:ff:ff

veth0 veth1已经在我们的环境里面消失了，并且分别出现在net0与net1里面。下面我们简单测试一下net0与net1的联通性

$ ip netns exec net0 ip link set veth0 up
$ ip netns exec net0 ip address add 10.0.1.1/24 dev veth0
$ ip netns exec net1 ip link set veth1 up
$ ip netns exec net1 ip address add 10.0.1.2/24 dev veth1

分别配置好两个设备，然后用ping测试一下联通性：

$ ip netns exec net0 ping -c 3 10.0.1.2
PING 10.0.1.2 (10.0.1.2) 56(84) bytes of data.
64 bytes from 10.0.1.2: icmp_req=1 ttl=64 time=0.101 ms
64 bytes from 10.0.1.2: icmp_req=2 ttl=64 time=0.057 ms
64 bytes from 10.0.1.2: icmp_req=3 ttl=64 time=0.048 ms

--- 10.0.1.2 ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 1999ms
rtt min/avg/max/mdev = 0.048/0.068/0.101/0.025 ms

一个稍微复杂的网络环境

创建虚拟网络环境并且连接网线

ip netns add net0
ip netns add net1
ip netns add bridge
ip link add type veth
ip link set dev veth0 name net0-bridge netns net0
ip link set dev veth1 name bridge-net0 netns bridge
ip link add type veth
ip link set dev veth0 name net1-bridge netns net1
ip link set dev veth1 name bridge-net1 netns bridge

在bridge中创建并且设置br设备

ip netns exec bridge brctl addbr br
ip netns exec bridge ip link set dev br up
ip netns exec bridge ip link set dev bridge-net0 up
ip netns exec bridge ip link set dev bridge-net1 up
ip netns exec bridge brctl addif br bridge-net0
ip netns exec bridge brctl addif br bridge-net1

然后配置两个虚拟环境的网卡

ip netns exec net0 ip link set dev net0-bridge up
ip netns exec net0 ip address add 10.0.1.1/24 dev net0-bridge

ip netns exec net1 ip link set dev net1-bridge up
ip netns exec net1 ip address add 10.0.1.2/24 dev net1-bridge

测试

$ ip netns exec net0 ping -c 3 10.0.1.2
PING 10.0.1.2 (10.0.1.2) 56(84) bytes of data.
64 bytes from 10.0.1.2: icmp_req=1 ttl=64 time=0.121 ms
64 bytes from 10.0.1.2: icmp_req=2 ttl=64 time=0.072 ms
64 bytes from 10.0.1.2: icmp_req=3 ttl=64 time=0.069 ms

--- 10.0.1.2 ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 1999ms
rtt min/avg/max/mdev = 0.069/0.087/0.121/0.025 ms

配置lldpd检查线路链接情况

随着虚拟网络环境增加，环境中网卡数量也在不断增加，经常会忘记环境中哪些网卡连接到哪里，通过 lldp
[ Link Layer Discovery Protocol ]
协议，我们可以清楚看到每个网卡连接到了哪些环境中的哪个网卡。

github 上有一个 lldp 在 linux 下的开源实现
[ implementation of IEEE 802.1ab (LLDP) ]
，通过在每个环境中起一个 lldp daemon，我们就可以实时查看每个网卡的连接情况

Bridge 上 lldp 的数据

$ lldpcli show neighbors

LLDP neighbors:

Interface:    bridge-net0, via: LLDP, RID: 2, Time: 0 day, 00:06:53
  Chassis:
    ChassisID:    mac 82:be:2a:ec:70:69
    SysName:      localhost
    SysDescr:     net0
    Capability:   Bridge, off
    Capability:   Router, off
    Capability:   Wlan, off
  Port:
    PortID:       mac 82:be:2a:ec:70:69
    PortDescr:    net0-bridge

Interface:    bridge-net1, via: LLDP, RID: 1, Time: 0 day, 00:06:53
  Chassis:
    ChassisID:    mac b2:34:28:b1:be:49
    SysName:      localhost
    SysDescr:     net1
    Capability:   Bridge, off
    Capability:   Router, off
    Capability:   Wlan, off
  Port:
    PortID:       mac b2:34:28:b1:be:49
    PortDescr:    net1-bridge

理解函数语言

2012-10-16T00:00:00+08:00

对于熟悉对象语言的程序员来说，函数语言显得有些深奥，特别是满眼看不懂的名词，什么 lambda，high order function， currying，很多不知所谓的名词构成了一道阻碍学习之路的长城。本文的目的就是介绍一下函数语言的特等，其与对象语言的主要区别在哪里，以及对函数语言普遍的误区。

误区 1: 函数语言就是操作各种函数的语言

函数语言这个名词自身就很容易引起这种偏颇的理解，很多人在初学函数语言的时候，看到示例程序里面把函数作为参数传来传去，就会以为函数语言的目的就是把函数作为参数。所有程序的目的都是为了操作数据，虽然函数语言提供了把函数作为参数的特性，但是最终的目的仍然是为了操作数据。把函数作为参数只是为了更方便得操作数据。比如 map 函数，用于把一个列表映射成另一个列表：

List(1, 2, 3) map { _ + 1 }  // get List(2, 3, 4)

虽然 map 函数的参数是一个函数，但是它的目的是为了生成数据的列表，所有的函数都是操作数据的，脱离了数据，函数也就毫无意义

误区 2: 函数语言很难理解

其实正好相反，函数语言提供了更高层的抽象，实际上比其他语言更容易理解。觉得函数语言难于理解是由于受现有语言影响太深。比如下面两段代码：

for (int i = 0; i < 10; i++) print(i);

(0 until 10) foreach print

如果拿给不懂任何编程的人看，他更容易理解哪个呢？对于更加复杂的代码，很多人理解的时候，是使用脑内模拟执行，跟踪调试的方法，这种理解程序的方法是最不可取的！很多关于编程的等级考试以及招聘笔试都会有理解程序的题目，回想一下你是怎么做这些题目的？是否是脑内模拟执行的呢？如果是，你已经被万恶的教育制度毒害了，请立刻忘记此方法！下面教你学会函数语言的思考方式。

函数式思考 1: 考虑整体，不要考虑个体

写一段程序，求 1 + 2 + 3 + … + 100

很多人就在想了，那不就是 1 + 2 = 3，然后再 + 3 = 6，然后再 + 4 = 10 …… 于是

int sum = 0;
for (int i = 0; i <= 100; i++)  sum += i

很对，但是你的思想被局限在一个一个数相加的过程中了，你*一步一步*得把所有数加起来。现在换个思维方式，1 加到 100，无非就是把所有数都加起来么，那么我加起来就对了么：

(1 to 100) reduce { _ + _ }

对于 reduce 函数怎么实现，大家都是高手，这里不需说明，基本所有的函数语言都有这个 reduce 的实现。这里我们把 1 到 100 这 100 个数字作为一个整体去理解，而不是分割得看成 100 个单独的数字。

函数式思考 2: 循序渐进，由简入繁

写一段程序，返回 100 内所有奇数

for (int i = 1; i <= 100; i += 2)  doSth(i)

不做评论，c/java 程序员的标准答案。现在我们重新审题，返回 100 内：

(1 to 100)

所有奇数：

(1 to 100) filter { _ % 2 == 1 }

这就是函数式程序员与传统程序员的区别，传统程序员：我需要 1 3 5 ….，函数式程序员：我需要 100 以内的数，我还需要一个过滤奇数的函数。

应用示例

或许所说的几点过于教条，难于理解，下面举几个简单的例子：

把一个字符序列转换成比特序列（一字节 = 8比特）

你是不是再想：把第一字节转行成8比特，然后把第二字节转行成8比特，然后……打住！我们需要的是把毎字节转换成8比特。那么怎么把毎字节转换成8比特呢？你是不是在想：拿出第一比特，然后再拿出第二比特……再次打住！上面说了，要从整体考虑，我们要拿出所有比特：

val masks = (0 to 7).reverse map { 1 << _ }

然后：

def charToBits(byte: Byte) = masks map { mask => (byte & mask) != 0 }

最后，我们需要操作的是 Byte序列：

def charSeqToBits(bytes: Seq[Byte]) = bytes flatMap charToBits

怎么样？有没有什么感悟呢？

Linux的控制台（TTY/PTY）与多任务（MULTI-TASKING）

2012-08-20T00:00:00+08:00

Linux是一个多任务操作系统，可以方便的在一个控制台（或shell）下同时执行多条命令，达到这样的目标并不是一件容易的事情。本文帮助理解下面几个跟控制台有关的概念：tty/pty，control terminal，session，process group，signal；并设计实现一个多任务控制程序

bash 的多任务支持

熟悉Linux的同学都知道，bash支持同时跑多个任务，下面先简单演示一下 bash 的多任务。首先，运行一个 cat 命令，然后通过 Ctrl+Z 中断这个 cat 回到 bash：

$ cat
^Z
[1]+  Stopped                 cat

然后，我们可以再运行一个 cat 任务，这回让 cat 干点活，继续用 Ctrl+Z 中断：

$ cat /dev/urandom > /dev/null
^Z
[2]+  Stopped                 cat /dev/urandom > /dev/null

这样我们就有了两个 cat 任务在后台，通过 bash 内置的 jobs 命令可以查看后台的任务：

$ jobs
[1]-  Stopped                 cat
[2]+  Stopped                 cat /dev/urandom > /dev/null

大家可以看到，这两条命令都处于 Stopped 状态，现在我们通过 bg 命令让第二个 cat 在后台运行：

$ bg 2
[2]+ cat /dev/urandom > /dev/null &
$ jobs
[1]+  Stopped                 cat
[2]-  Running                 cat /dev/urandom > /dev/null &

这时可以看到，第二个 cat 变成蓝 Running 状态，同时我机器的 CPU 温度也飚上来了。我们还可以通过 fg 命令让第一个 cat 到前台执行：

$ fg 1
cat

现在这个 cat 又恢复到等待我的输入的状态了。这样看来，好像 multi-tasking 是一件非常简单的事情，那么请尝试回答下面几个问题：

Q1. 如何中断/继续程序的运行？

Q2. 如何防止后台运行的程序互相抢夺控制台输入？

TTY - signal 转换

首先，回答第一个问题

Q1. 如何中断/继续程序的运行？

很简单，通过两个 signal 就可以控制程序中断/运行：

$ man 7 signal
       ...
       SIGCONT   19,18,25    Cont    Continue if stopped
       SIGSTOP   17,19,23    Stop    Stop process
       ...

于是某同学就在 bash 的代码里面找关于这两个 signal 的代码，但是他只找到了 fg/bg 命令给程序发送了 SIGCONT，没有找到关于 SIGSTOP 的代码，于是有了下面的问题：

Q1.1: 什么程序给 cat 发送了 SIGSTOP 信号？

通过本小节标题也可以看出，signal 其实是 TTY 发送的：

$ stty -a
speed 38400 baud; rows 51; columns 185; line = 0;
.... susp = ^Z; ....
....
....

看到了里面的 susp = ^Z 了么，这个设置的意思就是一旦 TTY 收到了 Ctrl-Z 就会把其转换成 SIGSTOP 信号？同理我们可以设置 Ctrl-N 为挂起的快捷键

$ stty susp ^N
$ cat
^N
[1]+  Stopped                 cat

由于所有的信号都是 tty 控制的，我们也可以修改 Ctrl-C/S/Q 等所有信号快捷键的行为，那么这里又有了下面这个问题：

Q3. 哪些程序会收到 TTY 来的信号？如果当前 TTY 来的信号所有程序都能收到，那么 Ctrl-C 会不会连后台程序一起杀掉？

这个问题先卖个关子，下面介绍一下process group。

process group

这里先启动一些进程：

$ google-chrome &
[1] 26077
$ cat | cat

我在这个 bash session 里面启动了3个进程，一个 google-chrome，两个 cat。chrome 又继续启动了很多进程。为了方便理解画张图，理清 TTY，session 与 process group 之间的关系：

              ┌─────────────────────────────────────┐
              │ Session                             │
┌─────┐  One  │  ┌────────────────────────────────┐ │
│ TTY │<──on─>│  │ Process group                  │ │
└─────┘  One  │  │   bash                         │ │
              │  └────────────────────────────────┘ │
              │  ┌────────────────────────────────┐ │
              │  │ Active process group           │ │
              │  │   cat                          │ │
              │  │   cat                          │ │
              │  └────────────────────────────────┘ │
              │  ┌────────────────────────────────┐ │
              │  │ process group                  │ │
              │  │   /opt/google/chrome/chrome    │ │
              │  │    \_ /opt/google/chrome/chrome│ │
              │  │    \_ /opt/google/chrome/chrome│ │
              │  │    \_ /opt/google/chrome/chrome│ │
              │  └────────────────────────────────┘ │
              └─────────────────────────────────────┘

每个 TTY 对应一个 session，session 是由 login (ssh/getty/…) 程序创建的，bash 仅仅是继承了这个 session。每个 session 里面有若干个 process group，每当 bash 创建（fork）一个进程的时候，在运行程序（exec*）前，都会为这个进程创建一个新的 process group。每个 process group 中只有一个 group 处于 active 状态，由 bash 控制哪个进程处于 active 状态。每个 process group 里面有若干个进程。为什么要这样设计，且听我慢慢道来。大家是否还记得前面留下的两个悬而未决的问题：

Q2. 如何防止后台运行的程序互相抢夺控制台输入？
Q3. 哪些程序会收到 TTY 来的信号？如果当前 TTY 来的信号所有程序都能收到，那么 Ctrl-C 会不会连后台程序一起杀掉？

有了 process group 的概念，回答这两个问题就非常简单了，只有处于 Active 内的进程能够获取控制台输入，并且 signal 只发送给 Active 内的进程。当有后台运行的进程想要读取控制台的时候（比如后台运行一个 cat），tty 会向其发送 SIGSTOP 信号，挂起此程序，你会发现，企图让 cat 后台运行是不可能的。当用户按下 Ctrl-C 或者 Ctrl-Z 的时候，只有前台的进程会收到相应的信号，并执行相应的操作。由于 bash 的特殊设计，用户是无法让两个程序同时读取控制台的，如果有人实在无聊，写了个程序 fork 出几个前台进程读取控制台（比如笔者），还是会出现抢占的现象：

int main() {
        if (fork())
                execlp("awk", "awk", "{ print \"parent:\" $0 }", 0);
        else
                execlp("awk", "awk", "{ print \"child:\" $0 }", 0);
}

用户的输入会随机传给 parent 或者 child，并且结果是不可预测的。

多任务控制的实现

前面介绍的多任务控制的原理，下面我们设计一个多任务控制程序，实现和 bash 一样的功能：

在前台有任务执行的时候等待

set processGroups

int startCommand(char *cmd) {
  int pid = fork();
  if (pid) {
    int = waitpid(pid); // 等待命令返回（结束或者挂起）
    return status;
  } else {
    int mypid = getpid()
    pgid = setpgid(); // 建立新的 process group
    tcsetpgrp(pgid); // 设置当前 group 为 active
    processGroups.add(mypid)
    exec(cmd); // 运行命令
  }
}

可以随时挂起前台执行的任务

挂起程序完全由 tty 完成，只需要在 waitpid 后面检查前台程序是结束了，还是被挂起了，如果是挂起了，需要把控制台输入权限返还给 bash：

...
switch(startCommand(cmd)) {
case exit:
  processGroups.remove(pid);
  break;
case suspend:
  break; // do nothing
}
tcsetpgrp(getpgid()); // 拿回 active process group

bg 命令切换后台执行任务

只需要向程序发送 SIGCONT 信号：

void bg(pid) {
  if (issuspended(pid))
    kill(pid, SIGCONT);
}

fg 命令把任务切换到前台

先让程序继续执行，然后转移 active process group：

int fg(pid) {
  bg(pid);
  tcsetpgrp(getpgid(pid));
  return waitpid(pid);
}

jobs 命令查看当前任务

for (pid in processGroups)
  print pid;

这样我们就实现了一个多任务控制程序，由于 tty 设备的存在，使得实现多任务控制轻松了很多。Windows 下是没有 tty 设备的，于是控制台程序就有很多限制，比如无法实现一个能够获取 Ctrl-C 输入的控制台程序，只有去拦截 interrupt 信号。上面这些内容估计只有 bash 的设计师才会关注，但是下面的内容就是几乎每个 linux 程序员都会关注的内容。

daemon 程序的实现

daemon 进程就是要与 TTY 划开界限，所有东西都不依赖 TTY，那么结果就非常简单了，因为 TTY 和 session 是一一对应的关系，我们新建一个 session 就等于把与原来 TTY 有关的东西完全抛开了：

void daemonize(char *cmd) {
  close(0);
  close(1);
  close(2);
  if (fork())
    exit(0);
  else {
    setsid();
    exec(cmd);
  }
}

为什么这里需要 fork ？请查阅此文章： http://stackoverflow.com/questions/2613104/why-fork-before-setsid

RaspBerry Pi 七宗罪，Pi 极为不靠谱的测评报告

2012-06-25T00:00:00+08:00

2.29 号下单的 RaspBerry PI (以下简称 RPI) 终于在 5.30 号到了，何等漫长的等待阿… 闲话少说，使用了快一个月，列举一下 RPI 的数宗罪

外壳

RPI 只提供裸版，各路豪杰都在给 RPI DIY 外壳，但是这个外壳确实不是一件容易的事情，Dell 的服务器部门有超过一半的科研经费花在机箱内部布局以及供电和散热上。RPI 的供电和散热都没有，而供电和散热，却又是 RPI 最严重的问题，后面会抱怨更多跟供电和散热有关的问题。由于没有外壳，在给 RPI 拔插设备的时候，就很难下手，只能按住接地的部分操作，而且上面突出的针脚又很多，稍不小心就会碰到某些阵脚，导致重启/死机/无法启动等问题。回去买一桶乐高积木，搭一个外壳出来试试。

Bootloader

RPI 由于没有集成存储芯片(节约成本)，所以靠 SD 卡引导，但是支持众多型号的 SD 卡不是一件容易的事情。芯片中只提供了几百字节的 GPU 代码空间，用于从 SD 卡中加载 bootloader，所以就有一些型号的 SD 卡无法使用。但这还不是最严重的问题，当 RPI 无法启动的时候，就不得不排查很多问题，供电，SD卡，显示。普通的硬件产品，例如家用电脑，路由器，手机，都是有内部存储的，系统从内部存储引导，引导出错会给出出错信息用于排查错误。RPI 直接从外设引导，出问题排查时会有些麻烦，要尝试各种不同的电源，各种不同型号的 SD 卡，刷写不同的系统到 SD 卡上。

CPU

RPI 的 CPU 标称 700 MHz ARM11，没有接触过 ARM 的可能不知道这个是什么概念，我们做一个简单的对比：

2003 年主流配置，赛扬 1.7G，256MB 内存，编译内核：5～10 分钟
RPI，700 MHz ARM11，256MB 内存，编译内核：6 小时

RPI 刚出来的几天，众多 Geek 的 RPI 都在忙于编译内核，直到有人研究出来如何 CrossCompile，才把 RPI 从编译内核的苦海中解救出来

RTC

RTC (Real-time clock) 是所有桌面/手持设备必备的部件，用于在系统启动的时候告诉系统当前时间。缺少 RTC 的系统在启动后无法获取当前时间，关机重启后系统时间就清零，给使用带来众多不便，虽然能够通过 NTP 启动后自动获取时间，但是没有网络的环境就悲剧了 (Model A 是不带以太网口的)。时间是系统中很重要的部分，很多服务都依赖时间，比如 802.1X，WPA2-enterprise，HTTPS，总之，需要使用证书认证的部分都将无法工作。RPI 不包含 RTC 的主要原因就是其成本太高了，需要 RTC 芯片以及一块在断电后仍能供电的电池，大概需要 3～5 刀 (RPI Model A $25)。

USB

RPI 的 USB 是问题最严重的部分了，为了配合 RPI 的低功耗，板载的两个 USB 端口的输出功率被限制在 140mA 以下，就是说几乎全部的读卡器/外接硬盘/无线网卡都将无法使用。即使你的电源再牛逼，也无法把功率送到 USB 口。当然，没有 Geek 解决不了的问题，各路神仙都出现，自己 mod USB 供电电路。最简单的方法就是直接短接 USB 电流限制部分。不过还有新问题，USB 是支持 HotPlug 的，当插入一个新 USB 设备的时候，会有很大的瞬间电流，而 RPI 的供电电路只有一个电容做缓冲，一旦这个电流超过此电容整流能力，会导致核心电压下降，结果就是导致重启。于是又有 Geek mod 了给一个 USB 供电的电容。道路真是坎坷阿，估计下个版本这些问题都会修正。

温度感应器

现在基本所有的家用 PC 内部都有数个温度感应器，分布在 CPU/GPU/电源/硬盘等重要部位。Intel CPU 内部的温度感应器甚至可以控制 CPU 运行频率，在温度低的时候如果有突发任务，可以短时间超频处理，超频幅度达到 3～4 倍（看我20倍界王拳，迷）。RPI 虽然功率很小，但是其芯片也非常小，热量有可能散发不出去，右边是某人给 CPU 和 Ethernet 芯片加了散热器。没有温度感应器，在芯片过热的情况下，可能会直接导致死机。RPI 论坛上已经有不少人在抱怨 RPI 无故死机的问题。

结论

RPI 终归是个 Geek 的玩具，在 RPI 上面你会碰到各种各样没有遇到过的硬件问题，RPI 离产品化距离相当遥远。不过 RPI 的出现，应该能够推动低功耗，低成本家用设备的普及。StackOverflow 竟然开了 RPI 专版，我被雷到了。虽然 RPI 有这么多的缺点，但是 $35 买个玩具还是很值的。

高阶流程控制语句（五）: 用 delimited continuation 实现 RAII

2012-05-16T00:00:00+08:00

什么是RAII？

RAII 就是在进入代码块的时候运行构造函数，在退出代码块的时候运行析构函数。C++ 原生支持 RAII：

class Resource {
public:
    Resource() { init...; }
    ~Resource() { fini...; }
};

int main() {
    Resource resource;
}

RAII 的实现: using

C#有个语法糖 using，支持对 IDispose 接口的 RAII：

using (MyResource myRes = new MyResource())
{
    myRes.DoSomething();
}

展开成实际代码就是：

MyResource myRes= new MyResource();
try
{
    myRes.DoSomething();
}
finally
{
    if (myRes!= null) ((IDisposable)myRes).Dispose();
}

Scala 可以自己实现 using 函数：

def using[T <: { def dispose: Unit }, R](resource: => T)(block: (T) => R) = {
  var res = resource
  try {
    block(res)
  } finally {
    if (res != null) res.dispose
  }
}

使用起来也跟 C# 的方法差不多：

class Res {
  println("init")
  def dispose = { println("fini") }
  def work = { println("work") }
}

using(new Res) { _.work }

这个实现有个麻烦的地方，如果多层 using 套用的话，代码会乱成一坨：

using(new Res) { res1 =>
  using(new Res) { res2 =>
    using(new Res) { res3 =>
      using(new Res) { res4 =>
        doSomething
      }
    }
  }
}

RAII 的实现: reset/shift

现在我们用 reset/shift 实现 RAII

import scala.util.continuations._

def managed[T <: { def dispose: Unit }](resource: => T): T @suspendable =
  shift { k =>
    val res = resource
    try {
      k(res)
    } finally {
      res.dispose
    }
  }

与之前的 using 实现类似，但是 using 使用一个闭包 block 作为参数，这里没有使用闭包作为参数，而是使用了 shift 捕获了后续的代码块，赋给 shift 的参数 k，我们先调用 k 然后再调用 dispose，可以做到析构函数类似的效果。这样 managed 函数在使用的时候也比 using 方便很多，需要做的就是在用 reset 把变量的作用域包起来：

class Res(name: String) {
  println("init: " + name)
  def dispose = { println("fini: " + name) }
  def work = { println("work: " + name) }
}

reset {
  val res = managed(new Res("X"))
  res.work
}

init: X
work: X
fini: X

这样使用多个资源也不会出现嵌套的问题了，而且会按照初始化相反的顺序进行析构：

reset {
  val res1 = managed(new Res("A"))
  val res2 = managed(new Res("B"))
  val res3 = managed(new Res("C"))
  val res4 = managed(new Res("D"))
  res1.work
  res2.work
  res3.work
}

init: A
init: B
init: C
init: D
work: A
work: B
work: C
fini: D
fini: C
fini: B
fini: A

备注: Scala 中 continuation 的使用

从官网下载 Scala 解压后 bin 目录下有名称为 scala 的可执行文件，如果要使用 continuation 必须添加参数 -P:continuations:enable，下面是以运行本文中的例子：

$ ./scala -P:continuations:enable
Welcome to Scala version 2.9.2 (OpenJDK 64-Bit Server VM, Java 1.6.0_24).
Type in expressions to have them evaluated.
Type :help for more information.

scala> import scala.util.continuations._
import scala.util.continuations._

scala> def managed[T <: { def dispose: Unit }](resource: => T): T @suspendable =
     |   shift { k =>
     |     val res = resource
     |     try {
     |       k(res)
     |     } finally {
     |       res.dispose
     |     }
     |   }
managed: [T <: AnyRef{def dispose: Unit}](resource: => T)T @scala.util.continuations.cpsParam[Unit,Unit]

scala> class Res(name: String) {
     |   println("init: " + name)
     |   def dispose = { println("fini: " + name) }
     |   def work = { println("work: " + name) }
     | }
defined class Res

scala> reset {
     |   val res = managed(new Res("X"))
     |   res.work
     | }
init: X
work: X
fini: X

scala>

高阶流程控制语句（四）: 实战 delimited continuation

2012-01-30T00:00:00+08:00

前面大量篇幅介绍了很多理论知识，这次介绍一下 delimited continuation 的一个应用，使用 Scala 的 reset/shift 实现一个单线程的 Echo Server

首先看一下下面这段代码：

object Echo extends App {
  val server = ServerSocketChannel.open
  server.socket.bind(new InetSocketAddress(12345))
  while (true) {
    server.accept match {
      case c: SocketChannel =>
        println("Accept: " + c)
        while (c.isOpen && c.isConnected) {
          val bb = ByteBuffer.allocateDirect(1024)
          c.read(bb) match {
            case count if count > 0 =>
              println("Read: " + c + " count: " + count)
              bb.flip
              while (bb.hasRemaining) {
                c.write(bb) match {
                  case count if count > 0 =>
                    println("Write: " + c + " count: " + count)
                  case count if count == 0 =>
                    println("WriteBlock: " + c)
                  case _ =>
                    println("WriteError: " + c)
                    bb.clear
                    c.close
                }
              }
            case count if count == 0 =>
              println("ReadBlock: " + c)
            case _ =>
              println("ReadError: " + c)
              c.close
          }
        }
      case null =>
        println("AcceptBlock")
    }
  }
}

这看起来像是一个 Echo Server，不过写出这种代码的哥们估计第二天就会被炒鱿鱼了。众所周知，实现单线程的多 TCP 连接程序，肯定要使用 Select/Epoll 这些多路 IO 复用机制，如果不使用这些机制，就会像上面这段程序一样，只能处理一条连接。但是这段程序并不是一无是处，它*逻辑清晰，简单易懂*。几十行代码一气呵成，把需要的逻辑都包含了：接受连接，读取数据，返回数据。后来我想尝试用 Java NIO 写了一下 Echo Server，不过在我动手前，我的脑袋已经被各种回调扭成麻花了，如果没有 mina netty 这种框架，写网络程序无异于自杀。

回到上面那段有问题的程序，将错就错，先使用多线程，让它能跑起来：

object EchoMultiThread extends App {
  val server = ServerSocketChannel.open
  server.socket.bind(new InetSocketAddress(12345))
  while (true) {
    server.accept match {
      case c: SocketChannel =>
        (new Thread(new Runnable {  // <============================= 1
          override def run { // <==================================== 2
            println("Accept: " + c)
            while (c.isOpen && c.isConnected) {
              val bb = ByteBuffer.allocateDirect(1024)
              c.read(bb) match {
                case count if count > 0 =>
                  println("Read: " + c + " count: " + count)
                  bb.flip
                  while (bb.hasRemaining) {
                    c.write(bb) match {
                      case count if count > 0 =>
                        println("Write: " + c + " count: " + count)
                      case count if count == 0 =>
                        println("WriteBlock: " + c)
                      case _ =>
                        println("WriteError: " + c)
                        bb.clear
                        c.close
                    }
                  }
                case count if count == 0 =>
                  println("ReadBlock: " + c)
                case _ =>
                  println("ReadError: " + c)
                  c.close
              }
            }
          } // // <================================================== 3
        })).start // <=============================================== 4
      case null =>
        println("AcceptBlock")
    }
  }
}

上面加了四行代码，把这段程序变成多线程，跑起来了，不过离我们的目标还有一段距离，我们需要使用单线程和 Java NIO 把这段程序跑起来。分析一下这段程序，主线程阻塞在外层 while 循环，所有子线程阻塞在里面的 while 循环，如果我们能够使用 reset/shift 把这两个 while 循环变成可中断的，那么问题不就解决了么？

先把这段程序中，需要使用线程的部分用 reset 包起来

object Echo extends App {
  val server = ServerSocketChannel.open
  server.socket.bind(new InetSocketAddress(12345))
  server.configureBlocking(false)
  reset { // <=================================== here it is the main thread
    while (true) {
      server.accept match {
        case c: SocketChannel =>
          reset { // <=========================== here it is child threads
            println("Accept: " + c)
            c.configureBlocking(false)
            while (c.isOpen && c.isConnected) {
              val bb = ByteBuffer.allocateDirect(1024)
              c.read(bb) match {
                case count if count > 0 =>
                  println("Read: " + c + " count: " + count)
                  bb.flip
                  while (bb.hasRemaining) {
                    c.write(bb) match {
                      case count if count > 0 =>
                        println("Write: " + c + " count: " + count)
                      case count if count == 0 =>
                        println("WriteBlock: " + c)
                      case _ =>
                        println("WriteError: " + c)
                        bb.clear
                        c.close
                    }
                  }
                case count if count == 0 =>
                  println("ReadBlock: " + c)
                case _ =>
                  println("ReadError: " + c)
                  c.close
              }
            }
          }
        case null =>
          println("AcceptBlock")
      }
    }
  }
}

然后找到需要阻塞的地方 shift 出去，shift 的时候把 continuation 函数注册到 Selector 里面:

object Echo extends App {
  val selector = Selector.open
  val server = ServerSocketChannel.open
  server.socket.bind(new InetSocketAddress(12345))
  server.configureBlocking(false)
  reset {
    while (true) {
      server.accept match {
        case c: SocketChannel =>
          reset {
            println("Accept: " + c)
            c.configureBlocking(false)
            while (c.isOpen && c.isConnected) {
              val bb = ByteBuffer.allocateDirect(1024)
              c.read(bb) match {
                case count if count > 0 =>
                  println("Read: " + c + " count: " + count)
                  bb.flip
                  while (bb.hasRemaining) {
                    c.write(bb) match {
                      case count if count > 0 =>
                        println("Write: " + c + " count: " + count)
                      case count if count == 0 =>
                        println("WriteBlock: " + c)
                        // <=============================== May block here
                        shift[Unit, Unit, Unit] { cont =>
                          c.register(selector, SelectionKey.OP_WRITE, cont)
                        }
                      case _ =>
                        println("WriteError: " + c)
                        bb.clear
                        c.close
                    }
                  }
                case count if count == 0 =>
                  println("ReadBlock: " + c)
                  // <===================================== May block here
                  shift[Unit, Unit, Unit] { cont =>
                    c.register(selector, SelectionKey.OP_READ, cont)
                  }
                case _ =>
                  println("ReadError: " + c)
                  c.close
              }
            }
          }
        case null =>
          println("AcceptBlock")
          // <============================================= May block here
          shift[Unit, Unit, Unit] { cont =>
            server.register(selector, SelectionKey.OP_ACCEPT, cont)
          }
      }
    }
  }
}

最后，加上 Selector 的 select 部分，select 成功后调用 shift 时存放在 attachment 中的 continuation 函数。为了编译通过，必须保证所有的 match/case 条件分支语句返回值类型相同，需要加入一些 shiftUnit 语句：

object Echo extends App {
  val selector = Selector.open
  val server = ServerSocketChannel.open
  server.socket.bind(new InetSocketAddress(12345))
  server.configureBlocking(false)
  reset {
    while (true) {
      server.accept match {
        case c: SocketChannel =>
          reset {
            println("Accept: " + c)
            c.configureBlocking(false)
            while (c.isOpen && c.isConnected) {
              val bb = ByteBuffer.allocateDirect(1024)
              c.read(bb) match {
                case count if count > 0 =>
                  println("Read: " + c + " count: " + count)
                  bb.flip
                  while (bb.hasRemaining) {
                    c.write(bb) match {
                      case count if count > 0 =>
                        println("Write: " + c + " count: " + count)
                        shiftUnit[Unit, Unit, Unit]()
                      case count if count == 0 =>
                        println("WriteBlock: " + c)
                        shift[Unit, Unit, Unit] { cont =>
                          c.register(selector, SelectionKey.OP_WRITE, cont)
                        }
                      case _ =>
                        println("WriteError: " + c)
                        bb.clear
                        c.close
                        shiftUnit[Unit, Unit, Unit]()
                    }
                  }
                case count if count == 0 =>
                  println("ReadBlock: " + c)
                  shift[Unit, Unit, Unit] { cont =>
                    c.register(selector, SelectionKey.OP_READ, cont)
                  }
                case _ =>
                  println("ReadError: " + c)
                  c.close
                  shiftUnit[Unit, Unit, Unit]()
              }
            }
          }
          shiftUnit[Unit, Unit, Unit]()
        case null =>
          println("AcceptBlock")
          shift[Unit, Unit, Unit] { cont =>
            server.register(selector, SelectionKey.OP_ACCEPT, cont)
          }
      }
      shiftUnit[Unit, Unit, Unit]()
    }
  }

  val keys = selector.selectedKeys
  while (true) {
    selector.select
    keys foreach { k =>
      k.interestOps(0)
      k.attachment.asInstanceOf[Function1[Unit, Unit]].apply(Unit)
    }
    keys.clear
  }
}

大功告成，怎么样，感觉不错吧，这样一个逻辑非常清晰的 Echo Server 就做完了，所有麻花一样的回调过程都隐藏在 reset/shift 的过程中了。源代码在这里，有兴趣可以研究一下。

高阶流程控制语句（三）: delimited continuation

2012-01-18T00:00:00+08:00

In programming languages, a delimited continuation, composable continuation or partial continuation, is a "slice" of a continuation frame that has been reified into a function.

— Wikipedia

这次使用 Scala 作为示范语言介绍 Delimited continuation, 因为 Scala 是我知道的除了括号语言(Lisp, Scheme 及其方言)之外, 唯一一个支持 Delimited continuation 的语言.

按照惯例, 还是从 Fibonacci 函数开始, 这里定义一个 Ruby yield 风格的 Fibonacci 函数:

def fibonacci(f: BigDecimal => Unit) {
  var (i, j) = (BigDecimal(1), BigDecimal(1))
  while (true) {
    f(j)
    val t = i + j; i = j; j = t
  }
}

fibonacci { println _ }

这个函数是一个高阶函数
[Higher-order function: 参数或者返回值为函数的函数]
, 其参数 f 是一个能处理 BigDecimal 的函数. 虽然这个函数工作得非常好, 但是有几个致命缺点:

无法终止: 一旦开始遍历, 就没法停下来
难以控制: 比如打印[100,10000)区间的 fibonacci 数, 或者打印第10~15个 fibonacci 数, 这种需求很难实现

如果我们能够实现一个 fibonacci 数的 Iterator, 通过 Scala 的 Iterator 库, 很容易就可以实现这些需求:

// print all fibonacci number inside [100,10000)
fibonacciIteritor
  .dropWhile(_ < 100)
  .takeWhile(_ < 10000)
  .foreach(println _)

// print the 10th ~ 15th fibonacci number
fibonacciIteritor
  .slice(10, 15)
  .foreach(println _)

现在就变个魔术, 把上面的 Ruby yield 风格的 fibonacci 函数, 变成一个 Iterator:

object fibonacciSeq {
  import scala.util.continuations._
  private var continuation: Unit => BigDecimal = reset {
    shift(identity[Unit => BigDecimal])
    var (i, j) = (BigDecimal(1), BigDecimal(1))
    while (true) {
      shift { k: (Unit => BigDecimal) => continuation = k; j } // f(j)
      val t = i + j; i = j; j = t
    }
    null // unreachable code, trick the compiler's type system
  }

  def next = continuation()
}

val fibonacciIteritor = Iterator.continually(fibonacciSeq.next)

这段代码最关键的东西, 就是 reset, shift 这两个函数. 在 Scala 的语法规则中, 这两个函数仅仅是普通的高阶函数
[hof]
, 其参数就是后面的 { … } 部分. reset 函数接受一段代码作为其参数, shift 函数接受一个函数作为其参数, 下面是这两个函数的声明:

def reset[A,C](ctx: =>(A @cpsParam[A,C])): C
def shift[A,B,C](fun: (A => B) => C): A @cpsParam[B,C]

reset 函数定义了一个闭锁空间(其参数), 在这个空间里面, 会发生一些违背物理常识的事情. shift 就是这个闭锁空间中的凉宫春日, 可以自由自在地操作这个空间, 具体方式就是操作时间流动(程序流程). 当程序运行到 shift 函数的时候, 会中断闭锁空间内部程序的执行, 生成一个当前闭锁空间的 snapshot, 包含当前的调用堆栈等信息, 然后调用 shift 函数的参数, 当这个函数执行完之后, 程序*不会*从 shift 函数后面继续执行, 而是跳出闭锁空间, 从当初进入闭锁空间的地方继续执行. 比如下面这段代码:

scala> reset {
     |   shift { k: (Unit => Unit) =>
     |     println("get here")
     |   }
     |   println("never reach here")
     | }
get here

shift 函数的参数执行完之后, 跳出闭锁空间, 回到当初进入的地方, 所以 shift 参数的返回值, 就是 reset 的返回值:

scala> val result = reset {
     |   shift { k: (Unit => Int) => 1 }
     |   2
     | }
result: Int = 1

根据上面 shift 函数的定义, shift 函数的参数也是一个函数, 这个函数接受一个参数, 这个参数就是当前闭锁空间的 snapshot. 现在来关注一下这个 snapshot, 首先这个 snapshot 代表了一段程序(从当前 shift 函数返回开始到闭锁空间内剩下的程序流程), 所以这个 snapshot 一定是一个函数闭包, 既然是函数, 那么就必须有参数和返回值, snapshot 对象是在进入 shift 函数时生成的, 那么其入口也就是从当前 shift 返回开始, snapshot 函数的参数就是 shift 的返回值:

scala> reset {
     |   val x = shift { snapshot: (Int => Unit) =>
     |     snapshot(1)
     |     snapshot(5)
     |     snapshot(25)
     |   }
     |   println("shifted: " + x)
     | }
shifted: 1
shifted: 5
shifted: 25

这里 snapshot 函数就捕捉了从 shift 返回开始, 到 reset 结束为止的程序流程, 即相当于:

val snapshot = { argument: Int =>
  val x = argument
  println("shifted: " + x)
}

下面考察一下 snapshot 函数的返回值. reset 作为一个程序块, 必然有返回值, 既然 snapshot 捕捉了到 reset 为止的所有程序流程, 那么 snapshot 的返回值就应该是 reset 程序块的返回值:

scala> reset {
     |   val x = shift { snapshot: (Unit => String) =>
     |     println(snapshot())
     |   }
     |   "I'm the return value"
     | }
I'm the return value

现在, 讲解了魔术的原理, 再回头看看上面那个 fibonacciSeq 实现, 应该知道其中变化了. 下次会介绍一些实际的应用场景

高阶流程控制语句（二）: stackful coroutine

2011-12-20T00:00:00+08:00

上次介绍了 stackless coroutine(generator) , 这次介绍真正具有完整功能的coroutine

首先看一下下面这段遍历二叉树的代码:

var travel = function(tree) {
        if (leaf(tree)) {
                yield tree;
        } else {
                /*???*/ travel(left(tree));
                /*???*/ travel(right(tree));
        }
};

对于叶子节点, 直接yield就可以了, 但是对于递归的traval调用. ??? 处应该填什么?

方法1: 借助stackless coroutine实现stackful coroutine

回想一下上次实现的Fibonacci generator:

function fib() {
  var i = 0, j = 1;
  while (true) {
    yield i;
    var t = i;
    i = j;
    j += t;
  }
}

Fibonacci内部只需要保存两个状态, F(n-2)与F(n-1), 分别用i,j保存. 但是遍历二叉树, 我们需要保存的状态是 从当前叶子节点到根节点的整条路经, 遇到这种状态是动态的情况, stackless coroutine就无能为力了. 不过我们可以借助闭包, 把需要保存的状态记录在闭包里面, 这样使用stackless coroutine保存这单个闭包, 就可以了:

var join = function() {
        for (var index in arguments) {
                for (var i in arguments[index]) {
                        yield i;
                }
        }
};
var travel = function(tree) {
        if (leaf(tree)) {
                return (function() {
                        yield tree;
                })();
        } else {
                return join(travel(left(tree)), travel(right(tree)));
        }
};

由于javascript调用函数是按值传递的, 上面这段代码运行到join函数之前, 会先计算join的参数, 递归调用travel函数, 导致很多次travel调用, 我们希望在开始遍历的时候再调用travel函数, 所以这里需要一次lazy优化:

var join = function() {
        for (var index in arguments) {
                for (var i in arguments[index]()) {
                        yield i;
                }
        }
};
var travel = function(tree) {
        if (leaf(tree)) {
                return (function() {
                        yield tree;
                })();
        } else {
                return join(function() {
                        return travel(left(tree));
                }, function() {
                        return travel(right(tree));
                });
        }
};

通过这个例子, 我们用stackless coroutine实现了stackful coroutine, 其中的关键, 就是这个join函数.

使用类似概念实现的coroutine有很多, 比如Kilim
[Kilim: Isolation-Typed Actors for Java. ( pdf ) ]
. 通过把需要Join的函数调用标记出来, 可以由编译器自动生成代码, 实现类似这里Join函数的工作. Kilim就是用@pausable这个annotation来标记需要Join的函数调用.

方法2: 使用CPS变换实现stackful coroutine

除了使用这个Join函数实现stackful coroutine之外, 还可以使用CPS变换实现stackful coroutine. 在流程控制领域, CPS变换几乎是万能的, 以后会解释为什么CPS是万能的.

首先, 从原始的traval函数开始:

var travel = function(tree) {
        if (leaf(tree)) {
                yield tree;
        } else {
                travel(left(tree));
                travel(right(tree));
        }
};

然后, 对这个函数做CPS变换:

var $travel = function(k, tree) {
        if (leaf(tree)) {
                return $yield(k, tree);
        } else {
                return $travel(function() {
                        return $travel(k, right(tree));
                }, left(tree));
        }
};

最后, 把上面这个函数包装成generator:

var travel = function(tree) {
        var generator = {};
        var $yield = function(k, result) {
                generator.next = k;
                return result;
        };
        var $travel = function(k, tree) {
                if (leaf(tree)) {
                        return $yield(k, tree);
                } else {
                        return $travel(function() {
                                return $travel(k, right(tree));
                        }, left(tree));
                }
        };
        generator.next = function() {
                return $travel(function() {
                        throw "stopIterator";
                }, tree);
        };
        return generator;
};

完整的代码如下, 各位可以试试, 看看里面是如何工作的:

var leaf = function(tree) {
        return typeof tree !== "object";
};
var left = function(tree) {
        return tree.l;
};
var right = function(tree) {
        return tree.r;
};

var travel = function(tree) {
        var generator = {};
        var $yield = function(k, result) {
                generator.next = k;
                return result;
        };
        var $travel = function(k, tree) {
                if (leaf(tree)) {
                        return $yield(k, tree);
                } else {
                        return $travel(function() {
                                return $travel(k, right(tree));
                        }, left(tree));
                }
        };
        generator.next = function() {
                return $travel(function() {
                        throw "stopIterator";
                }, tree);
        };
        return generator;
};

var g = travel({
        l: {
                l: 1,
                r: 2
        },
        r: 3
});

for (;;) {
        print(g.next());
}

杂谈

javascript的语法真是又臭又长, 使用CoffeeScript重写了一下上面的代码, 发现简洁好多 (44 → 24 lines):

leaf = (tree) -> typeof tree != "object"
left = (tree) -> tree.l
right = (tree) -> tree.r

travel = (tree) ->
        $yield = (k, result) ->
                generator.next = k
                result
        $travel = (k, tree) ->
                if leaf(tree)
                        $yield(k, tree)
                else
                        $travel((() -> $travel(k, right(tree))), left(tree))
        generator =
                next: () -> $travel((() -> throw "stopIterator"), tree)

g = travel
        l:
                l: 1
                r: 2
        r: 3

while true
        console.log(g.next())

虽然CoffeeScript仅仅是完全山寨javascript, 无任何创新, 但是最近却非常火热, 说明javascript实在是丑到家了

云峰的餐盒饭问题

2011-12-12T00:00:00+08:00

在云风的blog上看到一个有趣的概率问题 , 用概率学分析一下这个问题</em>

问题描述

有四份盒饭: 三份牛展, 一份是香菇, 我不知道我的盒饭是什么, 也不知道其他员工的盒饭是什么. 请问:

我的盒饭是牛展的概率是多少
如果员工A的盒饭是牛展, 请问我的盒饭是牛展的概率是多少
如果员工A, B的盒饭都是牛展, 请问我的盒饭是牛展的概率是多少

样本空间

分析离散概率问题最好的方法是把样本空间罗列出来:

事件	我	员工A	员工B	员工C
$E_1$	香菇	牛展	牛展	牛展
$E_2$	牛展	香菇	牛展	牛展
$E_3$	牛展	牛展	香菇	牛展
$E_4$	牛展	牛展	牛展	香菇

这里假设 $ E_1, E_2, E_3, E_4 $ 发生的概率是一样的, 都是1/4

事件

通过简单的查表操作就可以得到:

$ P(I) = E_2∪E_3∪E_4, \{\ I = 我的盒饭是牛展 \} $ $ P(A) = E_1∪E_3∪E_4, \{\ A = 员工A的盒饭是牛展 \} $ $ P(B) = E_1∪E_4, \{\ B = 员工A, B的盒饭都是牛展 \} $

条件概率

条件概率就是事件A在另外一个事件B已经发生条件下的发生概率。条件概率表示为P(A|B)

$P(A|B) = \frac{P(A \cap B)}{P(B)}$

计算结果

有了这些知识, 计算开始那三个问题就非常容易了

我的盒饭是牛展的概率是多少

$P(I) = \frac{E_{2} \bigcup E_{3} \bigcup E_{4}}{U} = \frac{3}{4}$

如果员工A的盒饭是牛展, 请问我的盒饭是牛展的概率是多少

$P(I|A) = \frac{( E_{2} \bigcup E_{3} \bigcup E_{4} ) \bigcap ( E_{1} \bigcup E_{3} \bigcup E_{4} )}{E_{1} \bigcup E_{3} \bigcup E_{4}} = \frac{( E_{3} \bigcup E_{4} )}{E_{1} \bigcup E_{3} \bigcup E_{4}} = \frac{2}{3}$

如果员工A, B的盒饭都是牛展, 请问我的盒饭是牛展的概率是多少

$P(I|B) = \frac{( E_{2} \bigcup E_{3} \bigcup E_{4} ) \bigcap ( E_{1} \bigcup E_{4} )}{E_{1} \bigcup E_{4}} = \frac{E_{4}}{E_{1} \bigcup E_{4}} = \frac{1}{2}$

for loop is EVIL !!

2011-12-12T00:00:00+08:00

for (int i = 0; i < LENGTH; ++i) {
    print(i);
}

无论是C++, JAVA还是javascript, 这种for循环都是非常常见的代码; 但是在所有的函数式语言中: Scala, Scheme, Erlang, Haskell为什么语法中都没有这样的for循环?

考察下面这段代码:

var a = ['a.html', 'b.html', 'c.html'];
for (var i = 0; i < a.length; ++i) {
    console.log(a[i] + ": " + a[i].length);
}

运行起来还算正常

现在修改一下需求, 返回这几个页面的字符数:

var a = ['a.html', 'b.html', 'c.html'];
for (var i = 0; i < a.length; ++i) {
    $.ajax(a[i], {
        success: function (text) {
            console.log(a[i] + ": " + text.length);
        }
    });
}

看起来这段代码与上面那段没什么太大区别, 应该不会出问题, 但是实际应用中, 立刻就看到问题了, 这段代码输出:

undefined: 100
undefined: 200
undefined: 300

原因很简单, 虽然闭包success捕获了变量i, 但是i在后面发生了变化, 调用success闭包的时候, i变成了3, a[i]返回undefined.

解决这个问题的方法也很简单: 不要使用变量

var a = ['a.html', 'b.html', 'c.html'];
$.each(a, function (k, v) {
    $.ajax(v, {
        success: function (text) {
            console.log(v + ": " + text.length);
        }
    });
});

由于传统的for循环必然引入变量, 一般的函数式语言的语法中都不包含传统的for循环. == Scala == for循环是一个语法糖:

for (i <- a) { foo i }

相当于:

a each { i => foo i }

每次都会生成一个新的变量i, 以及包含这个i的新闭包为了强调i不是变量, Scala标准废弃了下面这种语法:

for (var i <- a) { foo i }

Scheme

Scheme的do循环其实是一个宏:

(do ((i 0 (+ i 1)))
    ((= i 5) i)
  (foo i))

展开后就是一个递归调用:

(letrec
  ((loop (lambda (i)
    (if (= i 5)
      i
      (begin (foo i) (loop (+ i 1)))))))
  (loop 0))

对列表操作的时候最好使用srfi-1的map函数:

(map (lambda (i) (foo i)) a)

Haskell

Haskell提供的循环:

[ foo i | i <- a ]

或者使用list monad:

do
  i <- a
  return (foo i)

可以看出, 所有的函数式语言提供的for循环都没有使用变量, 变量在函数式语言中天生水土不服. javascript本身就是个畸形, 标榜自己是函数式语言, 却处处学习C/java的语法, 在使用javascript的时候, 最好尽量避免使用传统的for循环

高阶流程控制语句（一）： stackless coroutine

2011-11-15T00:00:00+08:00

coroutine是一种常见的流程控制语句, 可以在单线程内模拟多线程的执行, 经常被用于非抢占式用户态纤程(Fiber) 这里先要区分一下两种不同的coroutine

stackless coroutine (semi-coroutine)
stackful coroutine (coroutine)

下面先讨论一下stackless coroutine, 后面会继续讨论stackful coroutine. 对于两者的区别, 分别了解了两种coroutine后自然会非常清楚.

stackless coroutine又经常被称为generator. 下面这些语言中的<span style="color: blue">yield</span>都属于stackless coroutine

javascript 1.7
python
ruby

本文主要是讲解stackless coroutine的本质及其实现原理, 对于stackless coroutine比较陌生的同学可以先简单学习一下javascript 1.7的coroutine: https://developer.mozilla.org/en/New_in_JavaScript_1.7#Generators

stackless coroutine本质上仅仅是一个 语法糖 , 例如下面这段javascript代码
[摘自 New in JavaScript 1.7 #Generators ]
, 可以转换成不使用yield的代码:

function fib() {
  var i = 0, j = 1;
  while (true) {
    yield i;
    var t = i;
    i = j;
    j += t;
  }
}

首先把while/for循环转换成递归, 并且新建一个generator对象:

function fib() {
  var generator = {};
  generator.next = function () {
    var i = 0, j = 1;
    var $while = function () {
      yield i;
      var t = i;
      i = j;
      j += t;
      $while();
      /* 1 */
    }
    $while();
    /* 2 */
  }
  return generator;
}

然后对generator内部做cps变换. 经过cps变换后, yield成为一个普通函数:

function fib() {
  var generator = {};
  var $yield = function (k, value) {
    generator.next = k;
    return value;
  };
  generator.next = function () {
    var i = 0, j = 1;
    var $while = function (k /* $while never return, so k is never called. */) {
      return $yield(function () {
        // all statements after yield become continuation of yield, which comes into this function
        var t = i;
        i = j;
        j += t;
        return $while(function () { /* 1 */ });
      }, i /* arguments of yield */);
    };
    return $while(function () { /* 2 */ });
  }
  return generator;
}

// test code, copy into any javascript engine and check result
var g = fib();
for (var i = 0; i < 10; i++) {
  console.log(g.next());
}

上面所使用到了两种转换:

循环变递归
CPS变换

这两种转换都是通用转换, 任何程序都可以做这样的转换, 通过这两种转换可以把任何使用yield的代码转换成普通代码. 实际上, stackless coroutine的实现就是编译器(或者解释器)在背后做了这些工作.

Call/CC与Node.js

2011-10-31T00:00:00+08:00

本文介绍一个使用大概10行代码, 实现一个类似老赵JSCEX
[JavaScript版本的AsyncEnumerator http://blog.zhaojie.me/2010/11/asynciterator-the-asyncenumerator-in-javascript.html]
的工具

首先来看一下下面这段Node.js代码:

var copy = function(src, dst) {
  var fd_src = fs.open(src, "r");
  var fd_dst = fs.open(dst, "w");
  while (true) {
    var buffer_size = 4096;
    var buffer = new Buffer(buffer_size);
    var bytes_read = fs.read(fd_src, buffer, 0, buffer_size);
    if (bytes_read > 0) {
      var write_at = 0;
      while (write_at < bytes_read) {
        write_at += fs.write(fd_dst, buffer, write_at, bytes_read - write_at);
      }
    } else {
      break;
    }
  }
};

这段看起来像是一个文件拷贝的函数, 但是这个函数在Node里面是无法运行的, 因为Node的所有函数调用都必须是异步的, 这里用到的fs.open, fs.read, fs.write都必须修改为异步调用, 修改后可运行的代码如下:

var copy = function(src, dst) {
  fs.open(src, "r", undefined, function(err, fd_src) {
    fs.open(dst, "w", undefined, function(err, fd_dst) {
      var copy_rec = function(position) {
        var buffer_size = 4096;
        var buffer = new Buffer(4096);
        fs.read(fd_src, buffer, 0, buffer_size, position, function(err, bytes_read) {
          if (bytes_read > 0) {
            var write_rec = function(write_at) {
              if (write_at < bytes_read) {
                fs.write(fd_dst, buffer, 0, bytes_read, position, function(err, written) {
                  if (written > 0) {
                    write_rec(write_at + written);
                  }
                });
              } else {
                copy_rec(position + bytes_read);
              }
            };
            write_rec(0);
          }
        });
      };
      copy_rec(0);
    });
  });
};

看到这里, 我想第一次接触Node的同学就已经要崩溃了, 一个简单的文件拷贝函数竟然需要嵌套4~5层函数回调, 那么更复杂的比如web servlet岂不是要嵌套10多层函数回调了?

难道没有方法让最上面的简洁明了的代码运行起来么? 下面就介绍一种方法, 不修改最开始那个简洁明了的拷贝函数, 让它直接跑起来, 并且不会阻塞整个JS引擎

首先分析一下同步调用与异步调用的区别

// sync
var fd = fs.read (name, mode);
// use fd


// async
fs.read (name, mode, function (fd) {
  // use fd
});

仔细观察这两个调用, 会发现其实这就是一个CPS变换
[Continuation-passing style http://en.wikipedia.org/wiki/Continuation-passing_style ]
, 所以, 我们只需要做一个CPS变换的包装就可以实现同步的文件操作, 具体实现如下:

var efs = {
  open: function (name, mode) {
    return call_cc(function (continuation) {
      fs.open(name, mode, undefined, function(err, fd_src) {
        continuation(fd_src);
      });
    });
  },
  read: function (fd, buffer, offset, length) {
    return call_cc(function (continuation) {
      fs.read(fd, buffer, offset, length, null, function(err, bytes_read) {
        continuation(bytes_read);
      });
    });
  },
  write: function (fd, buffer, offset, length) {
    return call_cc(function (continuation) {
      fs.write(fd, buffer, offset, length, null, function(err, written) {
        continuation(written);
      });
    });
  }
};

这个实现的核心就是call/cc函数
[Call-with-current-continuation http://en.wikipedia.org/wiki/Call-with-current-continuation ]
, 如果了解lisp或者scheme的同学可能会非常熟悉这个函数, 这个函数作用是把当前正在运行的线程挂起, 然后执行call/cc本体, call/cc函数*不会返回*, 直到主动调用参数传进来的那个回调函数(本例中continuation变量绑定的函数), call/cc函数的返回值就是传给回调函数的参数. call/cc函数确实很难理解, 下面举例说明一下:

util.log("before call/cc");
var result = call_cc(function (continuation) {
  util.log("in call/cc before set timer");
  setTimeout(function () {
    util.log("before callback");
    continuation("hello world!");
    util.log("after callback");
  }, 1000);
  util.log("in call/cc after set timer");
});
util.log("after call/cc " + result);

这段代码的输出为:

31 Oct 13:01:33 - before call/cc
// 运行call/cc函数主体
31 Oct 13:01:33 - in call/cc before set timer
31 Oct 13:01:33 - in call/cc after set timer
// 休息1秒, 进入setTimeout的回调
31 Oct 13:01:34 - before callback
// 进入continuation函数, 调用continuation函数就相当于call/cc函数返回了"hello world!", 从call/cc返回开始继续执行
31 Oct 13:01:34 - after call/cc hello world!
// 执行setTimeout回调剩下部分
31 Oct 13:01:34 - after callback

现在我们已经使用CPS转换得到了"同步"的文件处理函数, 虽然说看起来是同步的, 但是内部使用的是call/cc实现, 实际上是不会阻塞JS引擎的, 其他回调仍然能正常执行. 有了这些函数的支持, 本文开头给出的那个文件拷贝函数就能够*不作任何修改正常执行*, 现在一切问题都已经解决了, 唯一剩下的问题就是call/cc函数的实现, 标准的node.js引擎是没有call/cc函数的, 这里我们使用node-fibers
[Fiber support for v8 and Node https://github.com/laverdet/node-fibers]
实现call/cc函数.

var call_cc = function(cont) {
  var fiber = Fiber.current;
  cont(function (a) {
    fiber.run(a);
  });
  return Fiber["yield"]();
};

由于node-fiber的限制, 这个copy函数必须运行在fiber环境中, 完整代码如下:

var fs = require("fs");
require("fibers");

var call_cc = function(cont) {
  var fiber = Fiber.current;
  cont(function (a) {
    fiber.run(a);
  });
  return Fiber["yield"]();
};

var efs = {
  open: function (name, mode) {
    return call_cc(function (continuation) {
      fs.open(name, mode, undefined, function(err, fd_src) {
        continuation(fd_src);
      });
    });
  },
  read: function (fd, buffer, offset, length) {
    return call_cc(function (continuation) {
      fs.read(fd, buffer, offset, length, null, function(err, bytes_read) {
        continuation(bytes_read);
      });
    });
  },
  write: function (fd, buffer, offset, length) {
    return call_cc(function (continuation) {
      fs.write(fd, buffer, offset, length, null, function(err, written) {
        continuation(written);
      });
    });
  }
};

var copy = function(src, dst) {
  var fd_src = efs.open(src, "r");
  var fd_dst = efs.open(dst, "w");
  while (true) {
    var buffer_size = 4096;
    var buffer = new Buffer(buffer_size);
    var bytes_read = efs.read(fd_src, buffer, 0, buffer_size);
    if (bytes_read > 0) {
      var write_at = 0;
      while (write_at < bytes_read) {
        write_at += efs.write(fd_dst, buffer, write_at, bytes_read - write_at);
      }
    } else {
      break;
    }
  }
};

Fiber(function () {
  copy("src", "dst");
}).run();

最后一点空间, 我想简单评论一下老赵的JSCEX
[jscex]
, 简单来说, 就是一点: 简直就是在重复发明轮子. 有关函数式编程, 在lisp界已经有40~50年的研究, 各个方面都已经有非常完善的体系, 当然这种异步同步函数之间互相转换早已经有体系化, 可证明的研究
[Olivier Danvy and Andrzej Filinski. 1990. Abstracting control. In Proceedings of the 1990 ACM conference on LISP and functional programming (LFP '90). ACM, New York, NY, USA, 151-160. DOI=10.1145/91556.91622 http://doi.acm.org/10.1145/91556.91622 ]
, 实现这样一个异步类库, 最好是从底层做起, 首先实现fiber
[fiber]
或者shift/reset
[Tiark Rompf, Ingo Maier, and Martin Odersky. 2009. Implementing first-class polymorphic delimited continuations by a type-directed selective CPS-transform. In Proceedings of the 14th ACM SIGPLAN international conference on Functional programming (ICFP '09). ACM, New York, NY, USA, 317-328. DOI=10.1145/1596550.1596596 http://doi.acm.org/10.1145/1596550.1596596 ]
这样的底层函数, 然后再其之上, 构建一个异步框架. 像老赵这样, 一上来就搞JS再编译, 那是绕了十万八千里的远路, 不仅本身会引入bug, 也会给用户的调试造成很大困扰, 性能问题也无法保证.

整理背包问题

2011-07-08T00:00:00+08:00

问题

现有编号为1 ~ n的n件物品, 随机放在编号为1 \~ n的n个背包中, 现在需要通过交换背包中的物品, 最终使物品 i 放在对应的背包 i 中, 需要交换的次数就是这个排列的逆序数. 现在考虑这样一个问题, 每轮交换, 可以选取任意对背包, 交换里面的物品, 但是同一个背包不能被选择两次, 那么需要几轮交换才能整理好所有物品?

比如有3个物品, 排列{2,3,1}, 要整理好, 至少需要两次交换{2,3,1} → {3,2,1} → {1,2,3}

再比如有4个物品, 排列{2,3,4,1} 要整理好, 也至少需要两次交换 {2,3,4,1} → {3,2,1,4} → {1,2,3,4} 第一次交换(2<⇒3)(4<⇒1), 第二轮交换(1<⇒3)

下面我们证明, 最多只需要两轮交换就能整理好所有背包.

使用 Cyclic notation 证明

原命题可以表示为:

若:

$ P = \prod_{i} (a_{i1}, a_{i2}, \dots, a_{is_{i}}) \hspace{40pt} (\sum_{i} s_{i} = n, a_{ij} \in \{ 1 \dots n \}, a_{ij} \neq a_{kl}) $

则, P可以表示为:

$ P = \prod_{i} (x_{i1}, x_{i2}) \prod_{i} (y_{i1}, y_{i2}) \hspace{25pt} (x_{ij}, y_{ij} \in \{ 1 \dots n \}, x_{ij} \neq x_{kl}, y_{ij} \neq y_{kl}) $

首先有:

$ (1, 2, \dots, s_{i}) = (1, s_{i-1})(2, s_{i-2})\dots(\lfloor s_{i}/2 \rfloor, \lceil s_{i}/2 \rceil) \hspace{10pt} (1, s_{i})(2, s_{i}-1)\dots(\lfloor (s_{i}+1)/2 \rfloor, \lceil (s_{i}+1)/2 \rceil) \\ $

所以可以记:

$ a_{i} = (a_{i1}, a_{i2}, \dots, a_{is_{i}}) \hspace{40pt} (A_{i} = \{ a_{ip} | p \in {1 \dots s_{i}\} \}, A_{i} \cap A_{j} = \varnothing) \\ x_{i} =(a_{i1}, a_{is_{i-1}})(a_{i2}, a_{is_{i-2}})\dots(a_{i\lfloor s_{i}/2 \rfloor}, a_{i\lceil s_{i}/2 \rceil}) \\ y_{i} =(a_{i1}, a_{is_{i}})(a_{i2}, a_{is_{i-1}})\dots(a_{i\lfloor (s_{i}+1)/2 \rfloor}, a_{i\lceil (s_{i}+1)/2 \rceil}) \\ a_{i} = x_{i}y_{i} $

所以P可以表示为:

$ P \\ = \prod_{i} a_{i} \\ = \prod_{i} x_{i}y_{i} \\ = \prod_{i} x_{i} \prod_{i} y_{i}) $

最后一步是因为 $ A_{i} \cap A_{j} = \varnothing $ , 所以, 原命题得证.

证明看起来很麻烦, 但是背后的原理非常简单, 所有的排列都可以表示为若干个环, 例如:

然后证明每个环都能够通过两轮交换还原. 上面证明中的 $ x_{i}y_{i} $ 就是还原了环 $ a_{i} $ , 方法就是通过一轮交换, 变成倒序, 然后再通过一轮交换, 变成正序.

$ \begin{pmatrix} 2 & 3 & 4 & \cdots & n-1 & n & 1 \\ & & & \downarrow & & & \\ n & n-1 & n-2 & \cdots & 3 & 2 & 1 \\ & & & \downarrow & & & \\ 1 & 2 & 3 & \cdots & n-2 & n-1 & n \end{pmatrix} $

又因为每个环都是独立的, 所以第一步交换可以同时进行, 一轮就可以完成所有环的第一步, 第二轮完成所有环的第二部, 问题解决.

使用排列矩阵证明

考虑题目的交换方式, 每轮能够交换任意对物品, 那么每轮交换的变换矩阵就是一个对称排列矩阵. 比如同时交换(1<⇒2)(3<⇒4)的变换矩阵就是

$ \begin{bmatrix} & 1 & & \\ 1 & & & \\ & & & 1 \\ & & 1 & \\ \end{bmatrix} $

原命题就等价于:

对于任意排列矩阵 $ P $, 存在对称排列矩阵 $ L $ , $ R $ , 使 $ P=LR $

下面我们开始构造 $ L $ 与 $ R $ .

首先分析P的特征根:

$ P-λE=0 $

P的特征多项式为:

$ \prod_{i} (\lambda^{s_{i}} \pm 1)=0 $

$ s_{i} $ 与上个证明中相同, 为每个环的元素数, 这不是巧合.

所以P有p组独立的特征根, 分别是 $ \{\lambda_{11}, \dots, \lambda_{1s_{1}}\}, \dots, \{\lambda_{p1}, \dots, \lambda_{ps_{p}}\} $ , 每组都分布在复平面的单位圆上. 考察P的特征分解 :

$ P = Q \Lambda Q^{-1} = (Q \Lambda Q^{T}) ((Q^{T})^{-1} Q^{-1}) = (Q \Lambda Q^{T}) (Q Q^{T})^{-1} \\ Q = \begin{bmatrix} | & & | & & | & & | \\ X_{11} & \cdots & X_{1s_{1}} & \cdots & X_{p} & \cdots & X_{ps_{p}} \\ | & & | & & | & & | \end{bmatrix} \Lambda = \begin{bmatrix} \lambda_{11} & & 0 \\ & \ddots & \\ 0 & & \lambda_{ps_{p}} \end{bmatrix} $

$ X_{ij} $ 为特征值 $ \lambda_{ij} $ 对应的特征向量标准化.

下面我们证明:

$ L = Q \Lambda Q^{T} \\ R = (Q Q^{T})^{-1} $

都是对称排列矩阵.

R的对称性:

$ R^{T} = ((Q Q^{T})^{-1})^{T} = ((Q Q^{T})^{T})^{-1} = ((Q^{T})^{T} Q^{T})^{-1} = (Q Q^{T})^{-1} = R $

R是排列矩阵:

L的对称性:

$ L^{T} = (Q \Lambda Q^{T})^{T} = (Q^{T})^{T} \Lambda^{T} Q^{T} = Q \Lambda Q^{T} = L $

L是排列矩阵:

$ L = PR^{-1} $

两个排列矩阵的积还是排列矩阵

PS: 此问题来源于WOW整理背包的插件, 一次可以向服务器提交一系列移动物品的指令, 但是不能涉及到重复的物品栏, 那么至少需要提交几次移动指令才能把背包整理好, 答案是2次!! 结论: 现有的整理背包插件都是渣.

自己动手修改Android程序 - twicca改造

2011-03-03T00:00:00+08:00

仅以此文悼念为了使用twicca上twitter与GFW搏斗浪费掉的20多个小时

apktool

首先介绍一个软件 apktool , 利用它可以反汇编Android的二进制软件包. 利用apktool反汇编Android程序的结果与程序源代码目录结构相同, 唯一区别是包含Java代码的src目录变成了包含Dalvik汇编码的smali目录.

twicca.org/
|-- AndroidManifest.xml
|-- apktool.yml
|-- res
|   |-- anim
|   |-- color
|   |-- drawable
|   |-- layout
|   |-- values
|   `-- xml
`-- smali
    `-- [dalvik assembler code]

修改代码后使用apktool可以重新编译修改过的反汇编结果, 生成新的Android程序.

Dalvik

smali目录里面是Dalvik虚拟机的汇编码. Dalvik 是android使用的Java虚拟机, 类似sun的JVM, 使用与Java bytecode类似的指令集. 与Java bytecode最大的区别是Dalvik是寄存器机, Java bytecode是堆栈机. Dalvik的效率更高, 因为现有大部分硬件体系都是寄存器机, Dalvik能够更加充分得利用寄存器资源; 而且Dalvik的汇编代码也更加容易理解, 寄存器变量比堆栈变量更加清晰明了.

比如说这样一段代码

public void HelloWorld(String p1, String p2) {
    System.out.println(p1 + p2);
}

编译成JVM和Dalvik分别是

JVM byte code

public void HelloWorld(java.lang.String, java.lang.String);
  Signature: (Ljava/lang/String;Ljava/lang/String;)V
  Code:
   0:   getstatic       #36; //Field java/lang/System.out:Ljava/io/PrintStream;
   3:   new     #37; //class java/lang/StringBuilder
   6:   dup
   7:   invokespecial   #38; //Method java/lang/StringBuilder."<init>":()V
   10:  aload_1
   11:  invokevirtual   #39; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   14:  aload_2
   15:  invokevirtual   #39; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   18:  invokevirtual   #40; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
   21:  invokevirtual   #41; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   24:  return

Dalvik

.method public HelloWorld(Ljava/lang/String;Ljava/lang/String;)V
    sget-object v0, Ljava/lang/System;->out:Ljava/io/PrintStream;
    new-instance v1, Ljava/lang/StringBuilder;
    invoke-direct {v1}, Ljava/lang/StringBuilder;-><init>()V
    invoke-virtual {v1, p1}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;
    move-result-object v1
    invoke-virtual {v1, p2}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;
    move-result-object v1
    invoke-virtual {v1}, Ljava/lang/StringBuilder;->toString()Ljava/lang/String;
    move-result-object v1
    invoke-virtual {v0, v1}, Ljava/io/PrintStream;->println(Ljava/lang/String;)V
    return-void
.end method

很明显, 下面Dalvik的汇编代码容易理解, 即使没有接触过Dalvik也能轻松理解这段代码. 上面的JVM bytecode就不是那么容易理解了, 函数调用的参数与结果都隐含在堆栈中, 必须分析堆栈才能知道程序意义.

调试

使用apktool的-d参数解开/打包的程序会拥有调试信息, 在Android上运行的时候可以通过JPDA调试, 在手机上使用Dev Tools打开调试, 然后在PC上用Android SDK里面的ddms连上去, 启动程序, 用任意一个JPDA客户端连上去就可以调试了. apktool的作者测试, Eclipse无法设置断点, 其他功能正常, 笔者使用jswat所有功能都正常. apktool作者的调试教程在这里

有了apktool, 并且熟悉了Dalvik bytecode, 我们就可以对所有的Android程序动手术了.

twicca的防篡改机制

twicca这个程序会在运行的时候把自己的signature发给服务器验证本身的没有被篡改, 改过程序的signature肯定会变化, 无法通过服务器验证, 不过得到自己signature的程序也是程序写的, 我们把这段改掉, 直接返回正确的signature就可以了. 得到一个程序signature的方法有很多种, 通过调试器在原程序得到signature的地方设置断点, 直接从程序内存中取出来; 或者写一个程序在手机中运行计算原程序的signature. 这里笔者使用的是另外一个黑客研究出来的方法, 可以直接在PC上获得程序的signature . 获取到程序正确的signature后, 要想办法替换到程序中得到修改过的signature.

下面这段代码是twicca获取自己signature的代码

    const-string v1, "jp.r246.twicca"
    const/16 v2, 0x40
    invoke-virtual {v0, v1, v2}, Landroid/content/pm/PackageManager;->getPackageInfo(Ljava/lang/String;I)Landroid/content/pm/PackageInfo;
    move-result-object v0
    iget-object v0, v0, Landroid/content/pm/PackageInfo;->signatures:[Landroid/content/pm/Signature;
    const/4 v2, 0x0
    aget-object v0, v0, v2
    invoke-virtual {v0}, Landroid/content/pm/Signature;->toCharsString()Ljava/lang/String;
    move-result-object v0

翻译成Java就是

    PackageManager v0a = ...;
    PackageInfo v0b = v0a.getPackageInfo("jp.r246.twicca", 0x40);
    Signature[] v0c = v0b.signatures;
    Signature v0d = v0c[0];
    String v0e = v0d.toCharsString();

我们只需要把最后的结果改成正确的signature, 而不是从PackageInfo中得到的signature, 所以只需要改最后一句, 直接给v0e赋值就可以了, 修改后就是这样(注意只有最后一句有变化).

    const-string v1, "jp.r246.twicca"
    const/16 v2, 0x40
    invoke-virtual {v0, v1, v2}, Landroid/content/pm/PackageManager;->getPackageInfo(Ljava/lang/String;I)Landroid/content/pm/PackageInfo;
    move-result-object v0
    iget-object v0, v0, Landroid/content/pm/PackageInfo;->signatures:[Landroid/content/pm/Signature;
    const/4 v2, 0x0
    aget-object v0, v0, v2
    invoke-virtual {v0}, Landroid/content/pm/Signature;->toCharsString()Ljava/lang/String;
    const-string v0, "30820269308201d2......27a2ee"

这样的话无论我们如何篡改程序, 它在自检验的时候都会得到我们硬编码到这段代码中的signature, 这样就能跳过它的自检验了.

下面就可以充分发挥想象力随意修改程序了, 比如把所有指向twitter.com的请求改成指向某代理的请求…

这是笔者修改的用来翻墙的twicca 0.8.24c的patch

twicca.diff

使用fakeroot模拟root权限执行程序

2011-02-11T00:00:00+08:00

最近从田春那里借来一本好书ハッカー秘伝のテクニック100選里面各种奇技淫巧，其中有一章讲解了fakeroot的实现，比我自己总结清晰很多，就拿来翻译一下试试。

Hack #57: 使用fakeroot模拟root权限执行程序

fakeroot是什么

例如Debian在生成package的时候，编译完之后，不能立刻在当前环境执行make install，需要执行make install DESTDIR=$(pwd)/debian/tmp把生成的文件安装到build目录的里面$(pwd)/debian/tmp。然后使用那个目录里面的全部内容生成Debian包（实际上包里面还会包含control和maintainer script等）。这个包里面的文件所有者必须是root，所以需要以root来执行打包命令。但是应该避免在制作Debian包的时候使用root权限。为了解决这个矛盾，fakeroot被开发出来了。在fakeroot环境中，操作文件就像使用root操作文件一样。但是，实际上系统中文件的权限还是原来的权限。

$ ls
foo
$ ls -l
total 0
-rw-r--r-- 1 kghost staff 0 Feb 11 14:17 foo
$ fakeroot
# id
uid=0(root) gid=0(root) groups=0(root),50(staff),100(users)
# ls -l
total 0
-rw-r--r-- 1 root root 0 Feb 11 14:17 foo
# touch bar
# ls -l
-rw-r--r-- 1 root root 0 Feb 11 14:17 bar
-rw-r--r-- 1 root root 0 Feb 11 14:17 foo
# chown www-data:www-data foo
# ls -l
total 0
-rw-r--r-- 1 root     root     0 Feb 11 14:17 bar
-rw-r--r-- 1 www-data www-data 0 Feb 11 14:17 foo
# exit
$ ls -l
total 0
-rw-r--r-- 1 kghost staff 0 Feb 11 14:17 bar
-rw-r--r-- 1 kghost staff 0 Feb 11 14:17 foo

像这样执行fakeroot后会在fakeroot环境中启动一个shell。这个shell中就像拥有root权限一样。执行id(1)命令会提示为root，并且文件的所有者也会变成root。新生成的文件所有者也是root，还可以把现有文件的所有者改成其他人。但是实际上变更的只反应在fakeroot环境内部。退出fakeroot环境后就能看到实际上的文件属性。在制作Debian包的时候，需要使用root权限来执行某些命令。本来是应该使用sudo来运行这些命令的，但是通常情况下是使用fakeroot模拟root运行。

fakeroot的实现

fakeroot仅仅是简单的shell script。简单来说fakeroot做下面的事情。 * 启动faked，获取FAKEROOTKEY * 设置环境变量FAKEROOTKEY，LD_LIBRARY_PATH，LD_PRELOAD。执行命令（默认是shell）

faked是管理虚拟的文件所有者，文件权限信息的守护进程。在fakeroot中执行的命令会加载由LD_LIBRARY_PATH，LD_PRELOAD环境变量指定的一个动态链接库（/usr/lib/libfakeroot/libfakeroot-sysv.so）

LD_LIBRARY_PATH=/usr/lib/libfakeroot LD_PRELOAD=libfakeroot-sysv.so

libfakeroot-sysv.so导出了以下函数

**Table 1.** test
getuid()	geteuid()	getguid()	getegid()
mknod()
chown()	fchown()	lchown()
chmod()	fchmod()
mkdir()
lstat()	fstat()	stat()
unlink()	remove()	rmdir()	rename()

这些函数会使用FAKEROOTKEY与faked通讯，返回虚拟的所有者与权限信息。

/usr/lib/libfakeroot-sysv.so

与faked通讯的库文件是/usr/lib/libfakeroot/libfakeroot-sysv.so，但是/usr/lib/libfakeroot-sysv.so也是存在的。这个文件是在fakeroot中运行suid程序所必须的。 fakeroot中会设定LD_LIBRARY_PATH环境变量。设定LD_LIBRARY_PATH后LD_PRELOAD就不需要是完整路径了。但是如果LD_PRELOAD不使用完整路径，suid的程序会忽略LD_LIBRARY_PATH而直接在/lib与/usr/lib中寻找LD_PRELOAD指定的库文件。如果LD_PRELOAD指定的文件没有找到这个suid的程序就会启动失败。所以会存在/usr/lib/libfakeroot-sysv.so这样一个suid的dummy库，在运行suid程序的时候通过LD_PRELOAD加载这个库，就跟没有加载任何东西一样，正常执行。 * 普通的程序使用LD_LIBRARY_PATH=/usr/lib/libfakeroot LD_PRELOAD=libfakeroot-sysv.so，通过preload加载/usr/lib/libfakeroot/libfakeroot-sysv.so的与faked通讯 * suid的程序无视LD_LIBRARY_PATH，使用LD_PRELOAD=libfakeroot-sysv.so，通过preload加载/usr/lib/libfakeroot-sysv.so，因为这是一个dummy库，就与这个库不存在一样，程序正常执行。

总结

例如Debian生成package这样，在必须使用root的时候，使用fakeroot模拟root权限。fakeroot使用libfakeroot-sysv.so库文件中的函数与faked通讯管理文件权限信息。

— Fumitoshi Ukai

用矩阵解概率问题

2011-01-05T00:00:00+08:00

在做topcoder的时候, 遇到了一个很有趣的问题

问题描述是这样的: 有n种不同的糖果,分成n堆,每种一堆,每堆C个. 从这n*C个糖果中随机选出两个交换, 交换S次后, 每堆糖果中各种糖果出现的概率是多少. 假设每种糖果的价值是 $ Value_{i} $ , 那么每堆糖果中任意一个糖果的价值期望是多少.

我们使用矩阵P描述每种糖果在每堆中的概率, 那么P[i][j]表示第i种糖果在第j堆中的出现概率. 开始的时候第i堆只有第i种糖果, 表示成矩阵就是

$ \begin{bmatrix} 1 & & & & & & \\ & 1 & & & & & \\ & & 1 & & & & \\ & & & \ddots & & & \\ & & & & 1 & & \\ & & & & & 1 & \\ & & & & & & 1 \end{bmatrix} $

每个交换操作都使用乘以相应的变换矩阵表示, 比如交换第i堆与第j堆中的一个糖果, 就是把第i堆的 $ 1 \over C $ 移动到第j堆, 反过来第j堆的 $ 1 \over C $ 移动到第i堆, 所以变换矩阵如下:

$ \begin{bmatrix} 1 & &i & &j & & \\ &\ddots & & & & & \\ i & &C - 1 \over C &\cdots &1 \over C & & \\ & &\vdots &\ddots &\vdots & & \\ j & &1 \over C &\cdots &C - 1 \over C & & \\ & & & & &\ddots & \\ & & & & & &1 \end{bmatrix} $

然后找到所有变换矩阵(一共 $ n*(n-1) \over 2 $ 个), 并且乘以他们被使用的概率( $C*C \over nC*(nC-1)/2$ ), 累加起来

$\sum_{0 <= i < j < n}^{ } \begin{bmatrix} 1 & &i & &j & & \\ &\ddots & & & & & \\ i & &C - 1 \over C &\cdots &1 \over C & & \\ & &\vdots &\ddots &\vdots & & \\ j & &1 \over C &\cdots &C - 1 \over C & & \\ & & & & &\ddots & \\ & & & & & &1 \end{bmatrix} * {C*C \over nC*(nC-1)/2} \Rightarrow A $

最后加上交换的两个糖果来自同一堆的变换矩阵乘以来自同一堆的概率($C-1 \over n*C - 1$)

$\begin{bmatrix} 1 & & & & & & \\ &1 & & & & & \\ & &1 & & & & \\ & & &\ddots & & & \\ & & & &1 & & \\ & & & & &1 & \\ & & & & & &1 \end{bmatrix} * {C-1 \over n*C - 1} \Rightarrow B$

这样就得到了一次交换的变换矩阵. 因为需要做S次交换, 所以要计算这个变换矩阵的S次方, 这样就得到了变换结果的概率矩阵.

$ {(A + B)}^{S} \Rightarrow P$

最后价值期望就是乘以价值矩阵

$ \begin{bmatrix} Value_{1} & \cdots & Value_{n} \end{bmatrix} * P$

class CandyBox {
public:
        vector <double> expectedScore(int, vector <int>, int);
};

int n;
#define N 50
double m1[N][N];
double m2[N][N];
double m3[N][N];

void matrix_times(double result[N][N], double c) {
        for (int i = 0; i < n; ++i)
                for (int j = 0; j < n; ++j)
                        result[i][j] *= c;
}

void matrix_plus(double result[N][N], double m[N][N]) {
        for (int i = 0; i < n; ++i)
                for (int j = 0; j < n; ++j)
                        result[i][j] += m[i][j];
}

void matrix_mul(double result[N][N], double m1[N][N], double m2[N][N]) {
        for (int i = 0; i < n; ++i)
                for (int j = 0; j < n; ++j) {
                        result[i][j] = 0;
                        for (int k = 0; k < n; ++k)
                                result[i][j] += m1[i][k] * m2[k][j];
                }
}

vector <double> CandyBox::expectedScore(int C, vector <int> score, int S) {
        n = score.size();
        for (int i = 0; i < n; ++i)
                for (int j = 0; j < n; ++j)
                        m1[i][j] = 0;

        for (int i = 0; i < n; ++i)
                for (int j = 0; j < n; ++j)
                        m3[i][j] = i == j ? 1 : 0;

        for (int i = 0; i < n; ++i) {
                for (int j = i + 1; j < n; ++j) {
                        for (int x = 0; x < n; ++x) {
                                for (int y = 0; y < n; ++y)
                                        if (x == i && y == i)
                                                m2[x][y] = 1.0 - 1.0/C;
                                        else if (x == i && y == j)
                                                m2[x][y] = 1.0/C;
                                        else if (x == j && y == i)
                                                m2[x][y] = 1.0/C;
                                        else if (x == j && y == j)
                                                m2[x][y] = 1.0 - 1.0/C;
                                        else if (x == y)
                                                m2[x][y] = 1;
                                        else
                                                m2[x][y] = 0;
                        }
                        matrix_plus(m1, m2);
                }
        }
        matrix_times(m1, 2.0*C*C/((n*C)*(n*C - 1)));
        matrix_times(m3, ((double)(C-1))/(n*C - 1)),
        matrix_plus(m1, m3);

        for (int i = 0; i < n; ++i)
                for (int j = 0; j < n; ++j)
                        m3[i][j] = i == j ? 1 : 0;

        for (int i = 0; i < S; ++i) {
                matrix_mul(m2, m3, m1);
                memcpy(m3, m2, sizeof(m2));
        }

        for (int j = 0; j < n; ++j)
                m2[0][j] = score[j];
        for (int i = 1; i < n; ++i)
                for (int j = 0; j < n; ++j)
                        m2[i][j] = 0;

        matrix_mul(m1, m2, m3);

        return vector<double>(m1[0], m1[0] + n);
}

后记：其实算法还有很多可以优化的地方

一次变换的矩阵可以直接用公式算出来，是一个对角阵，主对角线上的元素相同，其他元素相同，所以只需要用一个pair<double, double>就可以存下来了
求一个对角阵的S次方，结果还是一个对角阵。
总时间复杂度可以优化到O(S*n)，空间复杂度O(1)

用scheme实现lambda-calculus

2011-01-04T00:00:00+08:00

church number 里面 pred 实在让人看得头痛，用scheme实现一下，立刻变得容易理解了（真的容易理解么？！)

(define pred
  (lambda (n)
    (lambda (f)
      (lambda (x)
        (((n (lambda (g)
               (lambda (h)
                 (h (g f)))))
          (lambda (u) x))
         (lambda (u) u))))))

(define (church n)
  (lambda (f)
    (lambda (x)
      (if (= n 0)
        x
        (((church (1- n)) f) (f x))))))

(write `(lambda (f)
             (lambda (x)
                   ,(((pred (church 5)) (lambda (x) (list 'f x))) 'x))))

在guile里面跑了一下，效果不错，结果是

(lambda (f) (lambda (x) (f (f (f (f x))))))

正好是church number 4

Hello World

2011-01-03T00:00:00+08:00

Scheme

(write "Hello World !")

C

#include <stdio.h>

int main(void)
{
  printf("Hello world\n");
}

C++

#include <iostream>

int main()
{
  std::cout << "Hello World!" << std::endl;
}

Java

public class HelloWorld {//this file MUST have a name "HelloWorld.java"
   public static void main(String[] args) {
       System.out.println("Hello world!");
   }
}

Javascriopt

document.write('Hello world!');

Scala

object HelloWorld extends Application {
  println("Hello world!")
}

Yume

滑块游戏

是否所有排列都有解

解法

实现

多线程程序中使用 Fork/Exec

什么是 fork

关闭文件

手动关闭所有文件

使用 close_on_exec 关闭文件

死锁

网络虚拟化技术（二）: TUN/TAP MACVLAN MACVTAP

TUN 设备

TAP 设备

MACVLAN

MACVTAP

网络虚拟化技术（一）: Linux网络虚拟化

创建虚拟网络环境

进入虚拟网络环境

连接两个网络环境

一个稍微复杂的网络环境

配置lldpd检查线路链接情况

理解函数语言

误区 1: 函数语言就是操作各种函数的语言

误区 2: 函数语言很难理解

函数式思考 1: 考虑整体，不要考虑个体

函数式思考 2: 循序渐进，由简入繁

应用示例

Linux的控制台（TTY/PTY）与多任务（MULTI-TASKING）

bash 的多任务支持

TTY - signal 转换

process group

多任务控制的实现

daemon 程序的实现

RaspBerry Pi 七宗罪，Pi 极为不靠谱的测评报告

外壳

Bootloader

CPU

RTC

USB

温度感应器

结论

高阶流程控制语句（五）: 用 delimited continuation 实现 RAII

什么是RAII？

RAII 的实现: using

RAII 的实现: reset/shift

备注: Scala 中 continuation 的使用

高阶流程控制语句（四）: 实战 delimited continuation

高阶流程控制语句（三）: delimited continuation

高阶流程控制语句（二）: stackful coroutine

方法1: 借助stackless coroutine实现stackful coroutine

方法2: 使用CPS变换实现stackful coroutine

杂谈

云峰的餐盒饭问题

问题描述

样本空间

事件

条件概率

计算结果

for loop is EVIL !!

Scheme

Haskell

高阶流程控制语句（一）： stackless coroutine

Call/CC与Node.js

整理背包问题

问题

使用 Cyclic notation 证明

使用 排列矩阵 证明

自己动手修改Android程序 - twicca改造

apktool

Dalvik

调试

twicca的防篡改机制

使用fakeroot模拟root权限执行程序

Hack #57: 使用fakeroot模拟root权限执行程序

fakeroot是什么

fakeroot的实现

/usr/lib/libfakeroot-sysv.so

总结

用矩阵解概率问题

使用排列矩阵证明