依云's Blog

前天手上有个VPS的提供商发来通知，说VPS在攻击别人的80端口，被第三方投诉了-_-|||

我跑上去看了好久，啥也没发现。进程列表、登录日志、网络使用、各服务我能找到的日志都检查了一遍，也跑了遍 dpkg --verify，啥也没发现。没办法，我就留了句 tcpdump 命令，看看能不能抓到那些恶意流量：

sudo tcpdump -vv -s0 -w port80.log '(dst port 80 and src host 123.456.789.0) or (src port 80 and dst host 123.456.789.0)'

盯了好久，一直只看到有零星的正常访问。

就这么放了一天。第二天想起来的时候过去一看，哇塞，抓到了 2.1G 的包！看来真出问题了。先分析一下得到的 pcap 文件吧。

这么大的 pcap，自然不能拿 Wireshark 打开了。我知道 scapy 能够读取 pcap，于是用它读取 pcap，收集另一方的 IP 地址，看看流量到底都去哪里了。代码很简单，20多行。跑起来～progress 告诉我需要半小时……

于是半小时过去了。我能看到它访问了不少IP，很多是意料之外的。我就想，这些流量是什么时候发生的呢？不过我可不想再花半小时等结果了。然后再想得到点别的数据又得半小时。而且 Python 这种动态类型的语言，稍微复杂一点之后就容易抛异常。说不定快跑出结果的时候，抛个异常出来，前边就全白跑了……

所以就试试 Rust 啦。去 docs.rs 上一搜，还有好几个可以解析 pcap 的库呢。那就第一个吧，叫「pcap」的这个。程序写起来也挺容易的，甚至代码行数都跟 Python 版相仿。时间的处理也是用了一个之前没用过的库「chrono」。并没有花多长时间，直接在文档里找到我需要的功能，然后编译通过就成了 O(∩_∩)O~

extern crate pcap;
extern crate chrono;

use std::collections::BTreeMap;
use chrono::prelude::*;

fn main() {
  let mut capture = pcap::Capture::from_file("../port80.log").unwrap();
  let mut distribution = BTreeMap::new();
  while let Ok(pkt) = capture.next() {
    let t = pkt.header.ts.tv_sec;
    let by_hour = t / 3600 * 3600;
    let dt = Local.timestamp(by_hour, 0);
    *distribution.entry(dt).or_insert(0) += 1;
  }

  for (t, c) in distribution {
    println!("{}: {:8}", t.format("%Y-%m-%d %H:%M"), c);
  }
}

然后花了几秒编译出来优化版本的程序，跑起来～然后我切换到另一个 shell 去跑 progress。啥，没找到进程？再回来一看，哦哦，已经跑完了！只花了一两秒！

这是一千倍的差别啊！虽然两个程序所做的事情并不一样，比如 Python 版用的 scapy，实际上会把整个网络包的各层协议都给解析了，而不像 Rust 版只解析了 pcap 的记录头。但是我又没有别的选择，就像我也不能让 Python 别管引用计数一样。

对于这种小任务，Python 还是强在对少量数据的交互操作，比如 Jupyter Notebook 就很强大。而数据量一旦大起来，就是 Rust 的天下了 :-)

最近 #archlinux-cn 又流行玩 teeworlds 了，然而我却连不上那个服务器。

情况很奇怪。我能 ping 通服务器 IP，TCP 连接也正常，UDP traceroute 也表现得很正常（对关闭端口能够完成，对开放端口会在最后一跳开始得到一堆星号），并且我连接的时候，服务器能看到我在连接。也就是说，TCP 和 ICMP 都正常，UDP 上行正常，下行出了状况。

难道是有防火墙？首先呢，我能连接其它服务器，说明我这边没有问题；大部分人能连接上服务器，说明服务器那边也没有问题。所以，问题出在路上。也确实有另外的北京联通用户连不上这个服务器。但是很奇怪啊，为什么单单只是这一个 IP 的 UDP 包丢失了呢？

于是继续试验。从最简单的开始，用 netcat / socat 尝试通讯。方向反过来，我监听，服务器那边连接。端口是我在路由器上做过端口映射的。结果是正常的。再来，服务器那边监听，我往那边发，果然我就收不到包了。按理说，UDP 双方是对等的，不应该换了个方向就出问题呀。难道是因为端口映射？Wireshark 抓包看到本地使用的端口号之后，在路由器上映射一下，果然就通了！

然后，我注意到了一件十分诡异的事情：虽然我和服务器能够通讯了，但是我的 Wireshark 上只显示了我发出去的包，却看不到回来的包！我抓包时按服务器 IP 做了过滤，所以，回来的包的源 IP 不是服务器的地址！

重新抓包一看，果然。服务器 IP 是 202.118.17.142，但是回来的包的源 IP 变成了 121.22.88.41……看起来这是联通的设备，在下行 traceroute 时能够看到有节点与它 IP 相似（121.22.88.1）。原来又是这著名的「联不通」又干坏事了 -_-|||

虽然 socat 接收 UDP 时不介意源 IP 变化了，但是 teeworlds 介意啊。并且 NAT 那边也会不知所措。所以，首先得告诉路由器把来自这个 IP 的 UDP 包全部扔给我：

ssh 192.168.1.1 iptables -I FORWARD -i ppp0.2 -p udp -s 121.22.88.41 -j ACCEPT

于是数据包有了。接下来是修正源 IP。我试过 SNAT，无效。这东西似乎只对本地发出的包有用？于是我又用 netfilter_queue 了。这东西很强大呢～一个简单的 Python 脚本搞定：

#!/usr/bin/env python3

from netfilterqueue import NetfilterQueue
from scapy.all import *

def main(pkt):
  p = IP(pkt.get_payload())
  # print('recv', p)
  p.src = '202.118.17.142'
  p.chksum = None
  p[UDP].chksum = None
  pkt.set_payload(bytes(p))
  # print('fixed to', p)
  print('.', flush=True, end='')
  pkt.accept()

conf.color_theme = DefaultTheme()
nfqueue = NetfilterQueue()
nfqueue.bind(1, main)
try:
  nfqueue.run()
except KeyboardInterrupt:
  pass

然后是 iptables 命令：

sudo iptables -I INPUT -s 121.22.88.41 -p udp -j NFQUEUE --queue-num 1 --queue-bypass

scapy 这个神奇的网络库在 Arch 官方源里叫「scapy3k」。Python 的 netfilterqueue 模块需要用我自己修改过的这个版本。

2017年7月30日更新：Python 的依赖有点麻烦，所以我又写了个 Rust 版本，放在 GitHub 上了。

最近很火的 Rust 前不久发布了 alpha 版。正式版虽不说指日可待（还在各种大改中），但是也不是那么遥远了。而经过了这么久，再见 Rust，感觉完全不一样呢。

还记得第一次见 Rust，是在 Fantix 的博客上。现在只记得当时看到各种~和生命周期的东西，挺头疼的。而这次是看到 Rust for beginners 以及已经被合并到《The Rust Programming Language》这本书的官方 guide。感触很容易概括：「一门实用的类 Haskell 语言，是我很早就想要的东西呢。」于是才有了我的第一个 Rust 程序，以及后来的 各种语言实现的 swapview。

当然后来事实证明 Rust 不仅仅有着与 Haskell 类似的代数数据类型，比如有表示空的 unit 类型、表示可选的 option 类型、用于返回结果或错误的 Result 类型。作为一名曾经苦学 Haskell 还折腾过 OCaml 的人，看到这些熟悉的类型，感到甚是亲切。这种类型系统最大的特点是类型安全、没有 null 指针/类型。

我接触到的绝大多数编程语言，都会有 null 指针，或者 null / none / nil 类型：

• C、C++：「Segmentation fault」
• Java：还记得经常在日志里露脸的「NullPointerException」吗
• Python：一不小心就会出现的「AttributeError: 'NoneType' object has no attribute 'xxx'」
• Lua：「attempt to index global 'xxx' (a nil value)」
• 等等

都是一个不小心，没注意检查对象是不是 null 值就用，然后程序跑着跑着就出错了。

而 Haskell 和 Rust 都能有效地避免这一点，至少是你可以预先察觉，因为它返回的是不一样的类型。比如在 Rust 中，想要把字符串解析成整数，你写let a: i32 = "123".parse()不成。因为不是所有字符串都能解析成整数的，所以parse方法会返回一个Result<i32,ParseIntError>类型（早期版本是返回Option<i32>）。你需要显式地处理错误——或者忽略，如果你希望在出错的时候程序崩溃的话。不管选哪条路，写的时候都是明确知道这个地方可能出错的。不像我写 Python 时那样，直接想当然地写int(xxx)，很少会想到想当然以为是个整数表示的xxx其实可能是别的什么东西（比如None）。我总不可能在每一次按.键（取属性）、(键（函数调用开始）、[键（取下标）时都先想想「相关对象会不会是奇怪的东西、是的话要怎么处理」吧？当然这样的错误处理会比较麻烦。如果一个项目不值得这样麻烦的错误处理的话，那就换个更适合的语言去做就是了。

Rust 另一个小特点是，if这类条件判断后边只能是布尔值，和 Haskell 一样，而和 Python、Lisp、Lua 等都不同，就更别说没有真正的布尔类型的 C 了。这样更严谨，挺好的，意义明确。像把0当成假值这种事 Lua 就不干，把空容器当假这事 Python 喜欢但是别的语言又不一样。早先版本的datetime模块甚至认为午夜是假的、其它时间才是真的……

Rust 还有个显著的特点是，关键字都特别短，但是不至于短到不认识，比如pub, fn, mut, ref, impl等。有些人不喜欢，我倒是觉得挺好的。非要写一长串字符浪费空间嘛，虽然现在的显示器不是终端机那样一行只能显示80字符，但我要分割成多列呢。笔记本显示器可以显示两列代码对照着看，外接显示器要显示两行三列还不计偶尔会用到的侧栏呢。

Rust 还继承了 Python 式的显式名称导入。只要不用星号，一个名字是从哪里来的，当前文件里搜一下就找到了。不像 Ruby 那样子，String 莫名其妙多了个方法不知道是干什么的？拿 Google 搜索整个互联网吧……

Rust 资源管理很有特点，我还没在其它语言里看到这种。Rust 程序里，编译器知道每一个对象的生命周期，所以可以在编译期就插入相应的释放资源的代码，不需要 gc 过一段时间停下所有工作来检查一遍。也不像引用计数那样得维护计数，引起很多不必要的内存写请求。毕竟 Rust 的目标是像 C++ 那样高效的系统级编程语言嘛。当然引用计数如果需要还是可以有的。最初 Rust 的另一目标——像 Erlang 那样的并发性，因为绿色用户级线程被官方移出之后就大打折扣了。不过因为类型检查和生命周期推断，线程安全的特性还是保留了下来。

Rust 有各式各样的 trait，类似于 Haskell 里的类型类。要指定资源释放时调用的函数的话，直接实现Drop trait 就可以了。比如我的：

struct AtDir {
  oldpwd: Path,
}

impl AtDir {
  fn new(dir: &str) -> io::IoResult<AtDir> {
    let oldpwd = try!(std::os::getcwd());
    try!(std::os::change_dir(&Path::new(dir)));
    Ok(AtDir { oldpwd: oldpwd })
  }
}

impl std::ops::Drop for AtDir {
  fn drop(&mut self) {
    std::os::change_dir(&self.oldpwd).unwrap();
  }
}

使用的时候直接在需要的作用域时生成一个变量就好，就像下边这样子。Rust 保证在其生命周期结束时调用drop方法。而且是按其所有者变量定义的顺序的逆序调用的。不像 Python，PEP 442折腾了之后，反而是把我一个模块的__del__方法在解释器关闭时的调用顺序弄错了。虽然 Rust 没有 Python 那样的with语句，但是拿Drop可以做到一样的效果，而且能保证调用的时机与预期的一致。

let _cwd = match AtDir::new(directory_name) {
  Ok(atdir) => atdir,
  Err(err) => return Err(err.desc.to_string()),
};

Rust 编译器及标准库目前大部分（92.0%）使用 Rust 编写。而在此之前，Rust 竟然是使用 OCaml 编写的。这从侧面解释为什么目前 79.4% 使用 Go 编写 Go 语言用起来那么像 C（因为它的开发者用的是 C，设计目标好像也是更好的 C），而 Rust 虽然有很多借鉴自 C++ 的东西，导致其语法有些像 C，但写起来完全没有 C 和 Go 那样原始的感觉。这也是我更喜欢 Rust 的原因之一。

目前，除了还在改来改去，让我的程序过几天就各种报错编译不了之外，作为一名初学者，我能发现的另一个缺点就是编译极其费时了，特别是普通优化和链接时优化全开的时候，我一运行时间不到 0.2 秒的小程序，竟然需要半分钟才能编译好……

对了，之前给 Arch Linux 打包的 thestinger 不再打包 Rust 了，所以我开始在 archlinuxcn 源里维护64位的 rust-git、cargo-git（因为 Rust 更新的原因，至今还没打包成功……）以及 vim-rust-git。这些包是自动更新的，因此不出问题的话，有更新就会在一天内更新。

PS: 写的时候有点赶，希望没有写得太乱 ( >﹏<。)

序

swapview 起源于我很早之前看到的一个 shell 脚本。当时正在学习 Haskell，所以就拿 Haskell 给实现了一遍。为了对比，又拿 Python 给实现了一遍。而如今，我又在学习另一门新的语言——Rust，也拿 swapview 来练习了。相比仅仅输出字符串的「Hello World」程序，swapview 无疑更实际一些：

• 文件系统操作：包括列目录、读取文件内容
• 数据解析：包括简单的字符串处理和解析，还有格式化输出
• 数据处理：求和啊排序什么的
• 流程控制：循环啊判断啊分支什么的都有
• 错误处理：要忽略文件读取错误的

因此，swapview 成为了依云版的「Hello World」:-)

感谢所有给 swapview 提交代码的朋友们！

本文只是借 swapview 这个程序，一窥众编程语言的某些特征。很显然，编程语言们各有所长，在不同的任务下会有不同的表现。而且 swapview 各个版本出自不同的人之手，代码质量也会有所差异。

闪耀！那些令人眼前一亮的语言们

从运行效率上来看，C 如预期的一样是最快的。但令人惊讶的是，由我这个 Rust 初学者写的 Rust 程序竟然紧随其后，超越了 C++。

而原以为会跟在 Rust 之后的 C++，却输给了作为脚本语言存在的 Lua 语言的高效实现 LuaJIT（与 Rust 版本相当）。而且非 JIT 版本的 Lua 5.1 和 5.2 也都挺快的。Lua 这语言自带的功能非常少，语法也简单，但是效率确实高，让人又爱又恨的。

失望！那些没预期中的高效的语言们

没想到 Python 2 也挺快的，很接近 Go 了。PyPy 大概是因为启动比较慢的原因而排在了后面。Python 3 有使用两个版本的代码，Python3_bytes 把文件读取改为使用 bytes，仅在需要的时候才解码成 str。仅此之差，运行速度快了10%。可见 Python 的 Unicode 处理十分耗时，难怪 Python 3 在各种测试中都比 Python 2 要慢上一截。至于 PyPy3，怎么跑到那么靠后的地方去了呢……

Go 很快。至少比 Python 快。但也仅此而已了，不仅比 C++ 慢，甚至连 Lua（非 JIT 版）都不如。Go 语言版本虽然不是我写的，但我看过代码，感觉很原始。至少比 Lua 原始。看起来 Go 只不过是带接口和并发支持的 C 而已。而且，作为静态类型的编译型语言，却我却有一种很不放心的感觉。大约是因为我改动时发现传给 fmt.Printf 的参数类型和数目错了都不会得到警告或者错误的原因。而且我从来没见过 Go 编译时出现警告，对于还没入门的初学者写的、改过的程序，这样子不科学啊。早期我倒是见过 Go 报错了，但那只不过是编译器还不完善的表现而已。

传闻 NodeJS 很快。但至少它在 swapview 这种脚本中没能体现出来。正常版本比 Python 3 还要慢一点。而使用异步啊并行什么的版本还要慢上差不多三分之一，不知道怎么搞的。

编译型的 Chicken、OCaml、Haskell 都排在了一众脚本语言后边，虽然很可能是对语言本身不熟导致写出来的程序比较慢，但还是挺令人失望的。经过高手优化的 Haskell2 版本效率接近于 Python 3，但也到此为止了（因为不想使用 cabal 安装依赖，所以 Haskell2 没有参与这场对决）。我曾见过有人把 Haskell 代码优化到比 C 还快，但我宁愿去看汇编也不要去读那种代码……

Lisp 系（Chicken、Racket、SBCL（标注为 CommonLisp 的项）、Guile）也都挺慢的。不知道 LispWorks 之类的会不会快一大截呢。

预料之中的以及结果截图

Ruby 比 Python 略慢一点。

Java、Elixir 比较靠后。没办法，它们启动慢。也许以后我会出不考虑启动时间的版本。

以下是本文发表前的测试结果截图。其中 Erlang 版本因为有问题被信号所杀所以被扔在了最后。

测试使用的是benchmark子目录中的 Rust 程序，使用cargo build --release命令即可构建。另外也可以使用 farseerfc 的 Python 脚本。

代码量

Elixir 代码量挺少的。Python、Ruby 也挺不错。Java 版本竟然跟 Haskell 一样。不管是 JavaScript 还是 CoffeeScript 都比较长，比 Java 还长。Rust 比 Python 长不少，但也比 Go 短不少。而 Go 比起 C、C++ 要短一些。最长的，除了我不了解的 Pascal，竟然还有因为程序出错还没有测试的 Erlang！如果不算按行读取的 line_server.erl 的放大，只有不到一百行，倒还不算多。

                  Elixir:   50
                   Julia:   51
           Python3_bytes:   53
                  Python:   56
                    Ruby:   56
                  Racket:   58
                    Bash:   63
                   OCaml:   65
          CommonLisp_old:   67
          CommonLisp_opt:   67
           Bash_parallel:   69
             C++14_boost:   69
                   Guile:   70
                 Haskell:   73
                 Chicken:   75
                    Java:   75
                  NodeJS:   76
                    Vala:   78
                Haskell2:   81
                       D:   86
                    Rust:   88
                   C++14:   89
                  CSharp:   91
                     Lua:   91
            NodeJS_async:   93
            CoffeeScript:   93
   CoffeeScript_parallel:   95
                     PHP:   97
           Rust_parallel:   98
                      Go:  103
                   C++11:  128
                   C++98:  141
                       C:  149
              FreePascal:  185
                  Erlang:  232

编译速度

这个比较非常粗糙，比如联网下载依赖也被算进去了。不过可以肯定，不算下载依赖部分的话，Rust 是最慢的！其次是 Haskell。标榜编译速度非常快的 Go 并不是最快的，和 C++ 不相上下（当然不知道代码复杂之后会如何了）。

0.36 C
0.60 FreePascal
0.80 OCaml
0.83 CoffeeScript_parallel
1.48 CSharp
1.67 Vala
1.68 Erlang
2.13 NodeJS_async
2.27 C++14
2.49 Go
2.53 CoffeeScript
2.90 C++11
3.01 C++98
3.23 Java
3.52 Racket
3.98 NodeJS
6.05 CommonLisp_opt
7.07 D
9.01 C++14_boost
10.41 Haskell
13.07 Rust
14.74 Chicken
15.37 Rust_parallel

结语

这个项目最初只是练习而已。后来不同语言的版本有点多，于是才演变成众编程语言的竞技。也就随意地测试了一下在给定需求下不同语言的表现而已。其实比较有意思的部分，一是使用正在学习的编程语言写作程序的新奇感、新知、新的领悟（这也是我的测试程序使用 Rust 编写的原因），二是对比不同编程语言的风格和对同样需求的处理方式。

各位读者对 swapview 有任何补充和改进，欢迎贡献代码哦～项目地址：https://github.com/lilydjwg/swapview。

更新区

2015年1月9日更新：又收到了不少版本和改进，以下是最新的测试结果。很不幸地，现在已经跑得很快的 Erlang 在测试中又没反应被杀掉了。并行版的 Rust 的结果很不稳定，这次跑得好快！C++ 的除了 C++98 版的之外都到 Rust 前边去了。PHP 竟然比 LuaJIT 还要快！D 怎么到 PyPy 后边去了。

2015年1月10日更新：C++ 版本继续改进，好多都超越 C 了，Rust 1.0.0alpha 的并列版本又快又稳定，Erlang 版本终于跑完了全部测试而没有出事，LLVM 版 D 快了好多。

2015年1月18日更新：继续更新。又添加了若干语言，不过期待中的 Nim、Zimbu 以及传统脚本语言 Perl、Tcl 依旧缺席中。另外，正文也进行了更新，重新计算了代码量，添加了编译速度的粗略比较。

最近又看到 Rust 的相关东西了，入门指南也写得挺不错的。这语言我越看越喜欢。

Rust 的目标是系统级编程，就像 C 那样，快速高效。同时它继承了 Haskell 的诸多特性，包括其类型系统（包括类型类和类型推断）、模式匹配。而读写起来，又和 Python 差不多简单明了。简直是把这三种语言的优点全学到了！（当然 Rust 不仅仅受到了这几种语言的影响啦。）

当然，要体验一门编程语言，最好的方式就是使用它。于是我拿它实现了我最开始用来练习 Haskell 用的 swapview 程序。

swapview 的功能是，读取/proc下每一个进程目录下边的cmdline和smaps文件，得到其命令行和 swap 使用量，然后排序、格式化，并打印出来。

Haskell 第一版实现挺慢的：

swapview  1.27s user 0.26s system 98% cpu 1.555 total

我随手写了个 Python 版，效率翻了一倍还要多！很令人惊讶的呢。作为解释执行、还一直被认为很慢的 Python 竟然在没有任何优化的情况下就超过了编译型的 Haskell：

swapview.py  0.35s user 0.18s system 97% cpu 0.548 total

后来在 IRC 上遇到一位懂行的人，用了不少手段优化，最终得到了 Haskell 第二版：

swapview2  0.42s user 0.15s system 98% cpu 0.583 total

比 Python 版略慢。

才学 Rust 没几天，我对 Rust 比对 Haskell 更不熟。花了不少时间查阅文档、调整代码。不过因为之前的 Haskell 基础，也没遇到太大的困难。结果如下：

swapview  1.84s user 0.15s system 97% cpu 2.038 total

呃呃呃，怎么比 Haskell 版本还要慢上不少啊？

本来是找 profiling 方法的。翻着 rustc 的 man 文档，看到了-O选项，眼前一亮——我忘记告诉编译器要优化了！这是启用优化的结果，比 Python 版又快了一倍：

swapview  0.10s user 0.13s system 96% cpu 0.237 total

真棒呢～

不过很遗憾的是，它的格式化函数的第一个参数必须是字面量，连常量都不行。因为那是个宏，要在编译期解析格式……另外似乎也不支持现在连 JavaScript 都已经支持了的 generator（只支持 iterator，得先写一个 struct 才能用）。

PS: Rust 的文档挺赞的，和 Python 的一样有 JavaScript 实现的搜索功能，比起 Nimrod 和 Zimbu 的好用太多了。

PPS: 谁有兴趣可以贡献个 Go 版、C 版、C++ 版、LuaJIT 版什么的=w=

2014年12月25日更新：目前的结果是（运行时间）：Rust < LuaJIT < C++14 (gcc 4.9.2) < Lua 5.1 / 5.2 << Python 3 < Haskell <<< OCaml < SBCL。手动测试的。有空我再写个好点的自动测试程序。

2015年1月6日更新：添加了更多的编程语言，以及更准确的运行时间测试，请见新文章编程语言对决——战场：swapview。

看到别人的 Racket 版，心里痒痒，写了个 Haskell 版。只用了尾递归，没用什么高级特性。题目地址。

calc3xp1 :: Int -> Int
calc3xp1 n | even n = n `div` 2
           | otherwise = 3 * n + 1

countlen :: Int -> Int
countlen = countlen_tail 0

countlen_tail :: Int -> Int -> Int
countlen_tail c n | n == 1 = c
                  | otherwise = countlen_tail (c+1) $ calc3xp1 n

findmax :: Int -> Int
findmax = findmax_tail 1 1 1

findmax_tail max maxn n final | n >= final = maxn
                              | otherwise = if new_len > max
                                               then findmax_tail new_len n n' final
                                               else findmax_tail max maxn n' final
                                             where new_len = countlen n
                                                   n' = n + 1

main = print $ findmax 1000000

>>> time ./3xp1
./3xp1  14.92s user 0.02s system 99% cpu 14.955 total

Erlang 版本直接照抄 Haskell 版：

-module(e3xp1).
-export([main/1]).

calc3xp1(N) when N rem 2 == 0 ->
  N div 2;
calc3xp1(N) ->
  3 * N + 1.

countlen(N) -> countlen_tail(0, N).

countlen_tail(C, 1) ->
  C;
countlen_tail(C, N) ->
  countlen_tail(C+1, calc3xp1(N)).

findmax(N) ->
  findmax_tail(1, 1, 1, N).

findmax_tail(_, Maxn, N, Final) when N >= Final ->
  Maxn;
findmax_tail(Max, Maxn, N, Final) ->
  Newlen = countlen(N),
  if Newlen > Max -> findmax_tail(Newlen, N, N+1, Final);
    true -> findmax_tail(Max, Maxn, N+1, Final)
  end.

main(_) ->
  io:format("~B~n", [findmax(1000000)]).

它在六分钟后还没能输出结果……

>>> time escript e3xp1.erl
^C
escript e3xp1.erl  374.55s user 0.94s system 99% cpu 6:15.76 total

Racket 版在同一机器上用时：

>>> time racket 3xp1.racket
racket 3xp1.racket  3.22s user 0.22s system 99% cpu 3.448 total

这是为什么呢？

PS: C 更快，不到半秒就搞定了……

更新：又试了试 Lua 版本的，和 Haskell 版速度相当。但是——LuaJIT 竟然只 2.4s 出结果，因为换了机器，所以实际上它应该比 Racket 版快一倍以上。

再次更新：Erlang 版编译后还是挺快的：

>>> erlc e3xp1.erl
>>> time erl -noshell -s e3xp1 main -s init stop
erl -noshell -s e3xp1 main -s init stop  5.59s user 0.01s system 84% cpu 6.608 total

不过，它什么事都不干启动后立即停止也花了一秒多，比 Java 更厉害：

>>> time erl -noshell -s init stop
erl -noshell -s init stop  0.06s user 0.01s system 6% cpu 1.077 total

2014年12月24日更新：Rust 版也非常快，而且写起来舒服：

fn calc3xpi(n: uint) -> uint {
    if n % 2 == 0 {
        n / 2
    } else {
        3 * n + 1
    }
}

fn countlen(&n: &uint) -> uint {
    let mut c = 0;
    let mut x = n;
    while x != 1 {
        c += 1;
        x = calc3xpi(x);
    }
    c
}

fn findmax(n: uint) -> uint {
    range(1, n).max_by(countlen).unwrap()
}

fn main(){
    let mut stdout = std::io::stdout();
    stdout.write_uint(findmax(1000000));
    stdout.write_char('\n');
}