江淼的Blog

Linux下的数据统计

JiangMiao — Fri, 23 Dec 2011 22:26:10 +0800

最近2天CSDN的密码泄漏，部份人可能会像我一样去作一些统计，比如邮箱占有率等一些数据。统计方式五花八门，但我觉得在Linux下用命令组合统计最为方便。

一、基本统计

先看密码文档 www.csdn.net.sql 格式
用户名 # 密码 # 邮箱
以’ # ‘分列
3个字符可以用awk等进行切割

使用到的相关统计命令与参数为

sort
  -g 按照 常规数值排序
  -r  逆序输出排序结果
  -k 排序的列

uniq
  -c 统计数量
  -d 只输出重复的行

注: uniq只能对sort过的数据统计

例：统计密码使用频率并按使用频率从多到少排列
awk -F ‘ # ‘ ‘{print $2}’ www.csdn.net.sql|sort|uniq -cd|sort -rgk1|tee password_frequency.txt
输出

 235012 123456789
 212749 12345678
  76346 11111111
  46053 dearbook
  34952 00000000

...

例2：统计邮箱域名使用频率
@之后的都作为域名一部份，并转成小写，转成小写也可以通过命令tr [:upper:] [:lower:]
perl -pe ‘s/.*@(.*)/lc($1)/ei’ www.csdn.net.sql|tr -d “\r”|sort|uniq -c|sort -rgk1 > email_frequency.txt

1976210 qq.com
1766931 163.com
 807897 126.com
 351594 sina.com
 205491 yahoo.com.cn
...

2012384 qq
1785057 163
 808173 126
 396855 sina
 326406 yahoo
 204509 hotmail
 187087 gmail
 105379 sohu
  72470 tom
...

二、图形化统计结果

图形化的工具有gnuplot，R语言等，我这里使用了R语言

例4：由邮箱频率前9名与其余总和生成饼图
输出前9名与其总和 awk ‘NR < 10 { print $1, $2 } NR >= 10 { others += $1} END { print others, “others” }’ email_agency_frequency.txt > email_agency_top10.txt

2012384 qq
1785057 163
808173 126
396855 sina
326406 yahoo
204509 hotmail
187087 gmail
105379 sohu
72470 tom
516409 others

用R语言输出饼图
R脚本

table <- read.table("email_agency_top10.txt")
percent <- round(table$V1/sum(table$V1)*100)
png(file="email_agency_market_share.png", width=500, height=500)
pie(table$V1, labels=paste(table$V2, '(', percent, '%)', sep=""), col=rainbow(length(table$V1)), main="邮箱占有率", family='DejaVu Sans')

三、相关链接

gawk
sed
perl
R语言

node.js成也异步，败也异步，评node.js的异步特性

JiangMiao — Tue, 01 Nov 2011 03:02:48 +0800

node.js最大的卖点就是异步，声称以此获得更高的性能，而我认为，node之所以快并不是因为异步而快，而是因为V8而快。异步仅在资源占有明显优势，而引入异步却大大增加了编程的复杂度，且异步在http服务上并没有或者无法用在刀刃上。

以目前node来看，其作为单独http服务器的实现远远不如nginx，若以node建站，更普遍的选择是nginx 反向代理 node，一则由于node作为http服务器功能简单，实现更是差nginx几个台阶，其次因node单线程特性，若要发挥多核的优势，也必然会开2个以上的node进程，由此nginx + node几乎是首选模式，如果使用cluster，可以达到不错的性能，但也是因为简单而快，非异步的优势。相对于nginx + n * php-cgi模式，其工作模式近似看成 nginx + n*65535*node，n*65535*node为假想的大量worker，n为node进程数。

首先看传统的 nginx + 50*php-cgi 工作模式。
如果使用php-fpm进行fastcgi spawn，那么平每个空php-fpm基础占用物理内存6.4M，50个php-cgi则占用了 320M + 每个请求占用的内存。
而nginx + 4*node，占用的内存仅为 52M + 每个请求占用的内存。

同样100个worker会有100个不同的持久化连接，而node可以通过各种connections pool，使其共享持久化连接，大大减少其总连接数，node可以在任意时刻把一个连接取出或放回连接池而几乎没有性能上的损失。

这也是node异步资源上的优势。而除此之外，异步并没有想像中的这么美。

一、异步在http服务器上表现

1. 充分利用等待时间的谎言

先看完整一次http请求，花费的时间可能是
40ms 服务器从客户端连接并接收数据
5ms 各类数据传输与接收
2ms 数据处理
1ms rendering
10ms 服务器向客户端发送数据

由此可以近似看成 55ms等待时间 + 3ms 数据实际处理时间。
但由于nginx fastcgi buffer，upload等的存在，对于php-cgi实际等待时间仅为 5ms，如果数据库处理的很糟糕，等待时间则延长为 50ms，由于存在50个worker，那么相当于每个worker延长了1ms，所以node的充分利用等待时间本身就形成了一个伪命题。由于1ms的等待那么php-cgi将占用的cpu最大为75%，等待中的25%，正好可以给系统其它进程所利用，似乎也物尽其用。且若是CPU真得持续跑在50%以上了，那也到了不得不升级硬件的时候了。

2. 无法出众的http性能

node作为独立服务器，可以达到不俗的性能，而由若与nginx配合，对比nginx + php-cgi中并没有占到太多优势。在不同机器上快约-10%~25%不等，差距并不明显。若是完整用例的快，是因为V8的出色表现，和异步与否并没有太大的关系。

3. 艰难的异步之路

并不是说异步难写，而是相对于同步来讲，如今有各种异步实现模型，其跟本的目的也是简化异步实现。而异步再简化，再优雅都还是异步，易用性比起同步来讲仍然是天地之别。用繁复的异步换取不多的性能提升，实在是得不尝失。

二、 node异步的用武之地

批判了node的异步，但异步也并非一无是处，worker无法很好胜任的场合是异步的舞台。

各种需要要持久化连接的非http连接的服务器，如网游服务器。

大量远程api调用，假设每次请求都会有2~3次通过服务器的远程api调用，那么每个请求会有400ms以上的等待时间。而这类请求数量过多，会导致阻塞了普通动态页面请求。需要增大的worker数量，或者使用不同通道的worker。但显然没有异步来得实惠，而且这类请求逻辑通常不会复杂。

简言之，如果传统的线程池或者多进程worker，数量不得不达到100以上，那么就是异步的用武之地了。

三、一组hello world的测试

在四核 AMD Phenom 9650 下的一组最简单的hello world的测试结果
nginx + node sock

var http   = require('http');
http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('Hello World\n');
}).listen("/tmp/node-"+process.argv[2]+".sock");

node + cluster

var http    = require('http');
var cluster = require('cluster')
var server  = http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('Hello World\n');
});
cluster(server).listen(1337);

及php

<?php
echo 'hello world';

测试结果如下，单位(rps)
20并发与100并发

	siege -c 20	ab -c 100
node + cluster	12548	19194
nginx + 5*node sock	7260	12803
nginx + php-fpm	8400	11242

无并发

	siege -c 1	ab -c 1
node + cluster	6019	6535
nginx + 5*node sock	3024	3830
nginx + php-fpm	3839	4297

从测试结果可以发现，node + cluster 最快，nginx + php-fpm 次之，而nginx + node sock最慢。
也意味着 php-fpm 甚至快于 node sock，而cluster因其功能简单，node又没有php般完整http请求初始化，综合评价，node的底层实现不出众，异步优势更是无法得到充份的体现，

有人会说，hello world没用到异步，只是对入口的测试，对于单连接，同步在性能上并不会弱于异步，异步的优势只能在大规模持久连接或大延迟中才能得到体现。正如我上文充分利用等待时间的谎言所述，我对node与php下PostgreSQL查询性能比较，两者性能是几乎一致的。而php下memcache的实现就很不如意，比起异步还是同步更多取决于语言本身，不过这些不在本文讨论范围之内。本文主要讨论node的异步在http服务下情况，而非node vs php或者v8 vs php，

四、小结

本文不否认node快，但快与异步与否并没有太大关系，只因node简单，更重要的是其背后的v8引擎。对于逻辑复杂的网站，抛开异步是更佳的选择。

node.js异步数据库连接，事务查询思考

JiangMiao — Sun, 30 Oct 2011 17:00:14 +0800

首先思考一下场景

1、同时有50个并发请求，
2、每个请求将连接PgSQL并执行一个事务：调用2个不同的Model Bill与Profile，执行 Bill.insert 与 Profile.update
3、PgSQL最大连接数为20

因为使用到事务，所以同一个数据库连接不可能同用于两个不同的http请求

如果在PHP中，那么开20个不同的php-cgi，并对每个php-cgi进行操作，其余30个在请求nginx队列
1、nginx接受50个http请求
2、php-cgi接受20个请求，并建立20个全局持久化连接 db
3、Model Bill 与 Profile 通过全局变量 db 进行操作
4、cgi结束进行各种资源，连接回收
5、对队列中下一个请求进行操作

在node中行为将变成
1、接受50个http请求
2、从最大连接数为20的连接池中取得一个连接局域变量db，其余30个连接请求加入队列
3、Model Bill 与 Profile 通过某种途径访问局域变量进行操作
4、单个请求完毕，对资源连接回收
5、对队列中下一个请求进行操作

由此，对比PHP与node，本质上的不同仅仅是 db 变量的全局与局域的区别，

一、解决方法

以下测试均在CPU Atom D510 1.66G 单核下测试。

1. 通过vm

通过vm的runInNewContext可以把局域变量变成全局变量，但性能上大打折扣，对于空脚本的
script.runInNewContext() 为 1386 tps，
script.runInThisContext() 为 416667 tps
eval 为 13966 tps，
空循环为 Infinity tps

由上述可列公式，
在runInNewContext中的最终性能为 1386x / (1386 + x)
在runInThisContext中的最终性能为 416667x / (416667 + x)

比如，原程序通过使用node达到了1000 rps，也是node使用http.createServer跑hello world的性能
重新设计并使用scriptInNewContext后，那么性能最佳也只能有 1386k / 2386 = 580 rps，
而在实际使用中，包含一次redis查询的完整应用，包含render，cache等部份可以达到 550 rps，那么runInNewContext性能降至 316 rps，
而相对应的php，包含一次redis查询的更复杂的完整应用，也可以保持在240 rps，对比，使用了scriptInNewContext后，node不再具有性能优势。

如果使用scriptInThisContext，性能只下降到 416667k / 417667 = 997 rps，几乎没有影响。但在这里没啥用。scriptInThisContext用于模版rendering是非常之不错。

2. 通过建立model后赋于变量

每个Model实例添加额外的变量，用以保存当前请求将要用到的连接。
那么 model 则由new Model(arg1, arg2, …) 变成 req.create(Model, arg1, arg2, …)，似乎能很好的解决创建问题。
但若要执行静态函数，Model.find_or_create 等，变成 req.exec(Model, Model.find_or_create, arg1, arg2, ….)，感觉上就不漂亮了。

3. Model模版

使用闭包生成一个新的Model类，是个好方法，在Model的使用上也无区别。对性能的影响为 714k tps，如果每次必须重新生成10个Model，则为71k，对性能的影响也是微乎其微。
ModelTemplate模型 ToffeeScript 代码

ModelTemplate = (req) ->
  {db} = req
  class Model
    @create: ->
      console.info "create #{db}"

st = Date.now()
for i in [1..1000]
  Model = ModelTemplate({db: 'hello'})

console.info Date.now() - st

如果有多个Model
比如 class Bill, class Profile，改进成

ModelTemplate = (req) ->
  {db} = req
  class Bill
    @create: ->
      console.info "create bill #{db}"

  class Profile
    @create: ->
      console.info "create profile #{db}"

  {Bill, Profile}

st = Date.now()
for i in [1..1e4]
  models = ModelTemplate({db: :hello})
  {Bill} = models

console.info 1e4 * 1e3 / (Date.now() - st)

但仍然有个缺点，各个Model揉在一起，再改进成


ModelTemplateBill = (req) ->
  {db} = req
  class Bill
    @create: ->
      console.info "create bill #{db}"

ModelTemplateProfile = (req) ->
  class Profile
    @create: ->
      console.info "create profile #{db}"

ModelTemplate = (req) ->
  {db} = req

  {Bill}    = ModelTemplateBill(req)
  {Profile} = ModelTemplateProfile(req)

  {Bill, Profile}

st = Date.now()
for i in [1..1e4]
  models = ModelTemplate({db: :hello})
  {Bill} = models

console.info 1e4 * 1e3 / (Date.now() - st)

若再借用exports思想，那么可以变成

# models/bill.toffee
ModelTemplateBill = (req) ->
  {db} = req
  class Bill
    @create: ->
      console.info "create bill #{db}"

module.exports = ModelTemplateBill

#----
ModelTemplate = (req) ->
  @BillTemplate    ?= require('./models/bill')
  @ProfileTemplate ?= require('./models/profile')

  Bill    = @BillTemplate(req)
  Profile = @ProfileTemplate(req)

  {Bill, Profile}

st = Date.now()
for i in [1..1e4]
  models = ModelTemplate({db: :hello})
  {Bill} = models

console.info 1e4 * 1e3 / (Date.now() - st)

4. 资源池

由于Model的引入的最主要目的是对连接的控制，达到类似连接池的效果，因此由此脱离req，建立持久化连接池才是根本目的
代码则变成

class ResourcePool
  # 代码略

st = Date.now()
res_pool = ResourcePool.create({db: :hello})

for i in [1..1e4]
  res = res_pool.create()
  {Bill, db} = res
  res.close()

console.info 1e4 * 1e3 / (Date.now() - st)

而resurce中的各个连接池独立，且redis，pgsql最大连接数量可以不同，只要在设计成在执行查询时进行连接即可，只要保证在resource中的db等连接在一次生命周期永远是同一指向即可。

二、小结

资源池应该是最佳方案，性能，易用性兼得。

ToffeeScript – 支持异步语法的CoffeeScript

JiangMiao — Fri, 21 Oct 2011 01:31:02 +0800

ToffeeScript是CoffeeScript衍生，在完全兼容CoffeeScript的语法下提供了一些新的特性。

一、特性一览

异步语法支持
Ruby Symbol语法的字串
正则运算符 =~
正则Magic标识符 \& \~ \1..9

1. 异步语法支持

语法: 在调用的函数尾加上!(感叹号)
输入:

    do ->
      # ! always is a function
      foo_0_0!
      @va = obj.foo_2_1! 'pa', 'pb'
      # @ is inherited
      [va, @vb] = obj::foo_2_2! 'pa', 'pb'

    # another async block
    do ->
      @va = @foo! 'pa'

    # if, while and so on has block too
    if true
      va = foo!
    else
      vb = foo!

输出:

    var _this = this;

    (function() {
      var _this = this;
      return foo_0_0(function() {
        return obj.foo_2_1('pa', 'pb', function(va) {
          _this.va = va;
          return obj.prototype.foo_2_2('pa', 'pb', function(va, vb) {
            _this.vb = vb;
          });
        });
      });
    })();

    (function() {
      var _this = this;
      return this.foo('pa', function(va) {
        _this.va = va;
      });
    })();

    if (true) {
      foo(function(va) {});
    } else {
      foo(function(vb) {});
    }

a. 原理

ToffeeScript 会把

    [any expression] = foo!(params)
    other expression

转换为

    foo params, (any expression) =>
      other expression

因此

    [a = '3', @b = '4'] = foo!
    @a = foo!
    ...
    等等

都是有效的异步语法

2. Symbol语法的字串

ToffeeScript引用了Ruby Symbol的语法，但本质仍是字串，可以看成一种字串的便捷写法。
语法: 以:开头的字串 /^\:((?:\\.|\w|-)+)/
备注: – 是有效的字串部份，
输入:

    :hello_world
    :hello-world

输出:

    'hello_world'
    'hello-world'

3. 正则运算符 =~

语法: 字串 =~ 正则表达式
输入:

    "hello" =~ /\w+/

输出:

    var __matches = null;
    __matches = "hello".match(/\w+/);

4. 正则Magic标识符 \& \~ \1..9

Magic标识符:

    \~: the match
    \&: match[0]
    \1: match[1]
    \2: match[2]
    ...
    \9: match[9]

输入:

    if :hello =~ /^\w+$/
      console.info :matched

    if :333-444 =~ /^(\d+)-(\d+)$/
      console.info \1, \2

输出:

    (function() {
      var __matches = null;
      if (__matches = 'hello'.match(/^\w+$/)) console.info('matched');
      if (__matches = '333-444'.match(/^(\d+)-(\d+)$/)) {
        console.info(__matches[1], __matches[2]);
      }
    }).call(this);

二、安装

npm install -g toffee-script

ToffeeScript有两个可执行文件 toffee and tcons 相对于CoffeeScript的 coffee 与 cake

Dart试用手记 – 2、语法与评论

JiangMiao — Tue, 11 Oct 2011 12:38:51 +0800

Dart的语法比较传统，可以看到Java，C++的影子

1. 注释

// 单行注释
/* … */ 注释块

2. 变量

Dart有2种变量var与final
final必需要初使化且只能赋值一次

3. 函数

Dart的函数格式：[返回类型] [函数名] 参数列表函数体
参数列表与函数体是必需的其余可省略
而 Dart的函数体有2种形式
=> 单一表达式
{ 各种表达式 }

由此以函数都是合法的

(a, b) => a + b;
() => 'yes';
(a, b) { return a + b; };
() { return 'yes'; };
add(a, b) => a+b;
int add2(a, b) { return a+b; };

匿名函数使用的小例子

print((a, b) { return a + b; }(3, 4)); // 输出 7
print(((a, b) => a + b)(3,4)); // 输出 7

同时函数可以写成
final add = (a, b) => a + b;
但只能在函数体中使用，无法在类与全局中使用，否则会出 Error: line 1 pos 13: initializer must be a compile time constant 错误
合法

main()
{
	final add = (a, b) => a + b; //合法
	print(add(3,4));
}

不合法

class Foo
{
	final add = (a, b) => a + b; // 不合法 1
}
final add = (a, b) => a + b; // 不合法 2，1与2两者实质是一样的

main ()
{
}

4. 闭包

Dart可谓是为专门闭包而生，由以上的函数定义，可以写一个闭包的小例子

foo()
{
	var hello = 'hello';
	return () {
		return hello;
	};
}
main()
{
	print(foo()()); // 输出 hello
}

5. 类

Dart万物皆类，所以类是Dart中不可缺少的一部分
类定义

class 类名称 { [各种成员与方法] }

方法定义

[static] [返回类型] [get|set] 名称 参数列表

抽象方法

abstract [static] [返回类型] [get|set] 名称

由以上类定义写一个类的小例子

class Foo
{
	static add(a, b) => a + b;
	sub(a, b)
	{
		return a - b;
	}

	get a()
	{
		return 'a';
	}

} 

main()
{
	print(Foo.add(3, 4));         // 输出 7
	print((new Foo()).sub(4, 3)); // 输出 1
	print((new Foo()).a); // Getter a，输出 a
}

类继承，Dart只支持单继承
class 类名 extends 类名
调用父方法 super

Dart支持多个接口
interface, implements 与 factory
interface 名称 [factory 名称]
{
}

class 名称 [implements 以,分割的多个名称]
{
}

6. 数组与Hash

[ ] Array 例 [1, 2]
{} Hash 例 {‘a’: ‘b’}

7. 循环

for (名称 in 容器) {
}

for (定义; 条件; 执行) {
}

while (条件) {
}

do {
} while (条件);

例

main()
{
	for (var i in [1, 2]) {
		print(i);
	}

	for (var i=0; i<10; ++i) {
		print(i);
	}

	var i =0;
	while (i < 10) {
		print(i);
		++i;
	}

	i = 0;
	do {
		print(i);
		++i;
	} while (i < 10);

}

静观其变

==在试验中发现如下代码==

main()
{
	var st = new Date.now();
	var j = 0;
	for (var i=1; i <= 100000; ++i)
	{
		j += i;
	}
	var ed = new Date.now();

	print(j);
	print(ed.difference(st));
}

输出

5000050000
0:00:00.288

288ms，对比ruby的73ms，V8的5ms，C的2ms可谓相当之慢，使用命令为out/Release_ia32/dart_bin hello.dart，希望是我使用上的问题。且Dart的语法略显拙劣，由此我放弃继续对Dart的学习，静观其变。

Dart评论

缺点与疑点
1、class {} 后不能接分号
理论上;号作为分隔符存在class {};理应是合法的，class行为过于诡异。

2、Dart强制分号作分割
说不上好坏，但定位显得有问题，对于部份不习惯用;结尾的js使用者来说会有不适

3、怪异的私有变量声明，前置 _
根据Dart规范中描述前置 _ 变量名意为私有，_在C里是作为系统或内部命令存在，而在Dart中成了普遍，更奇怪的除了若要声明私有除了前置_别无选择。

4、展开的’字串行为
对于目前所有流行语言，皆为”#{嵌入的语句}”或”{$foo}”等，而单引号不展开，而Dart中单引号却会展开如 ‘hello $world’

5、不尽人意的性能
Dart的纯面向对象的设定出发点是支持的，我也希望能有好的表现，但现在来看此设定大大影响了语言的性能，而且实现上似乎有问题，在数值计算中连Ruby都比不过，Dart若用于Canvas，游戏运算等，定会面对大量的数值运算，如果未来性能仍然不佳，难免沦落成为一个鸡肋的存在。

优点
更加完整的OO支持，OO虽然不是必需的，但有比没有好，但担心复杂的特性或多或少会带来性能上的损失，不清楚Dart能优化到什么程度。

同样Dart的严格，使灵活性大大不如Javascript，失去灵活性代码量必然会上升，严格与灵活，各有所长，但在追求代码简练高产的脚本领域，Dart显得有些劣势。

Dart试用手记 – 1、编译与安装

JiangMiao — Tue, 11 Oct 2011 01:49:51 +0800

今天Google发布了Dart，定位用以替代JavaScript，从架势来看未来应该也会有所投入，加之Google在V8的丰富经验，Dart定能有出色的发挥，所以打算第一时间了解下。但Dart究竟如何，是否有足够的竞争力，还要待使用后才能有定论。

一、安装

1. 准备

Linux系统，chromium提供了一个安装依赖的脚本

$ wget http://src.chromium.org/svn/trunk/src/build/install-build-deps.sh
$ source install-build-deps.sh

不过我跳过了这步，不知效果如何，install-build-deps会自动检测系统环境并使用相应的包管理工具进行安装包

2. 安装Depot_tools

Dart使用的是用depot_tools管理代码，可从chromium上checkout depot_tools

svn co http://src.chromium.org/svn/trunk/tools/depot_tools

3. 配置gclient

Dart有两种不同的包all与standalone，all包含eclipse之类的软件，功能全体积大，而standalone仅仅是dart，体积小，30M左右

gclient config http://dart.googlecode.com/svn/trunk/deps/standalone.deps

4. 同步代码

depot_tools/gclient sync

5. 修改一个gcc的小问题

因dart在我使用的gcc 4.6.1会出
../runtime/vm/parser.cc:3666:12: 警告：variable ‘expr_pos’ set but not used [-Wunused-but-set-variable]
加上-Werror导至编译失败。
处理方法：修改tools/gyp/configurations_mak.gypi第13行注释掉#’-Werror’
再使用 depot_tools/gclient runhooks 重新生成Makefile等文件

6. 编译

我直接生成debug与release两个版本

cd dart
../tools/build.py --arch=ia32 --mode=all

如果是64位则用–arch=x64 ../tools/build.py –help查看更多帮助。
生成的文件在out/Release_ia32与out/Debug_ia32中
有不少文件，我比较关心的有以下5个
dart 需要动态链接库的可执行文件
dart_bin 无需动态链接库的可执行文件
lib.target/libdart.so 动态链接库
另外有2个无snapshot版的
dart_no_snapshot 与 dart_no_snapshot_bin
无snapshot同V8一样，体积小但初始运行速行慢

7. 测试

测试用的参数可以使用编译时参数一致进行全面测试

../tools/test.py --arch=ia32 --mode=all
# 也可以仅测试其中的部份，如
../tools/test.py --arch=ia32 --mode=release

二、介绍

在下载和编译时过一遍语法和特性，全部规范只有78页，不知是语言简单还是文档简单。
Dart规范下载页

1. Dart的基本特性

Dart是基于类，单继承，纯面向对象语言。
Dart程序可以做一些静态检查
Dart可以以2种方式运行，产品模式与检查模式
Dart只能单线程运行，若要并行可以通过isolates，每一个isolate有自已的内存与线程。

三、Hello World

main() {
  print('Hello World');
}

CoffeeScript 功能加强

JiangMiao — Fri, 02 Sep 2011 02:42:54 +0800

CoffeScript makes javascript fun, and the CoffeeScript’s source code write clearly and easy to extend, I add 2 string related features: Ruby symbol like string and long string.

CoffeeScript让javascript变得有趣，而且代码清晰，易用扩展，我在CoffeeScript的原基础上加入2个新字符串相关的语法。一个是类似Ruby Symbol的字串，一个是超长字串

1. Ruby Symbol like

CoffeeScript:

console.info :hello, :world

JavaScript:

console.info('hello', 'world');

Remark:

What will be translated to for those code?
1. info:hello
{info: hello}

2. {:hello, :world}
ERROR! use {hello, world} instead

2. 正则表达示运算符

if :hello =~ /^\w+$/
  console.info :ok, \&

生成

var __matches = null;
if (__matches = 'hello'.match(/^\w+$/))
  console.info('ok', __matches[0]);

3. Links

My forked CoffeeScript GitHub Repo with those 2 features
Original CoffeeScript GitHub Repo

Linux libaio

JiangMiao — Thu, 18 Aug 2011 15:51:08 +0800

Linux aio是Linux下的异步读写模型。
对于文件的读写，即使以O_NONBLOCK方式来打开一个文件，也会处于”阻塞”状态。因为文件时时刻刻处于可读状态。而从磁盘到内存所等待的时间是惊人的。为了充份发挥把数据从磁盘复制到内存的时间，引入了aio模型。linux下有aio封装，但是aio采用的是线程或信号用以通知，为了能更多的控制io行为，可以使用更为低级libaio。

一、基本函数与结构

1. libaio函数

extern int io_setup(int maxevents, io_context_t *ctxp);
extern int io_destroy(io_context_t ctx);
extern int io_submit(io_context_t ctx, long nr, struct iocb *ios[]);
extern int io_cancel(io_context_t ctx, struct iocb *iocb, struct io_event *evt);
extern int io_getevents(io_context_t ctx_id, long min_nr, long nr, struct io_event *events, struct timespec *timeout);

2. 结构

struct io_iocb_poll {
	PADDED(int events, __pad1);
};	/* result code is the set of result flags or -'ve errno */

struct io_iocb_sockaddr {
	struct sockaddr *addr;
	int		len;
};	/* result code is the length of the sockaddr, or -'ve errno */

struct io_iocb_common {
	PADDEDptr(void	*buf, __pad1);
	PADDEDul(nbytes, __pad2);
	long long	offset;
	long long	__pad3;
	unsigned	flags;
	unsigned	resfd;
};	/* result code is the amount read or -'ve errno */

struct io_iocb_vector {
	const struct iovec	*vec;
	int			nr;
	long long		offset;
};	/* result code is the amount read or -'ve errno */

struct iocb {
	PADDEDptr(void *data, __pad1);	/* Return in the io completion event */
	PADDED(unsigned key, __pad2);	/* For use in identifying io requests */

	short		aio_lio_opcode;
	short		aio_reqprio;
	int		aio_fildes;

	union {
		struct io_iocb_common		c;
		struct io_iocb_vector		v;
		struct io_iocb_poll		poll;
		struct io_iocb_sockaddr	saddr;
	} u;
};

struct io_event {
	PADDEDptr(void *data, __pad1);
	PADDEDptr(struct iocb *obj,  __pad2);
	PADDEDul(res,  __pad3);
	PADDEDul(res2, __pad4);
};

3. 内联函数

static inline void io_set_callback(struct iocb *iocb, io_callback_t cb);
static inline void io_prep_pread(struct iocb *iocb, int fd, void *buf, size_t count, long long offset);
static inline void io_prep_pwrite(struct iocb *iocb, int fd, void *buf, size_t count, long long offset);
static inline void io_prep_preadv(struct iocb *iocb, int fd, const struct iovec *iov, int iovcnt, long long offset);
static inline void io_prep_pwritev(struct iocb *iocb, int fd, const struct iovec *iov, int iovcnt, long long offset);
/* Jeff Moyer says this was implemented in Red Hat AS2.1 and RHEL3.
 * AFAICT, it was never in mainline, and should not be used. --RR */
static inline void io_prep_poll(struct iocb *iocb, int fd, int events);
static inline int io_poll(io_context_t ctx, struct iocb *iocb, io_callback_t cb, int fd, int events);
static inline void io_prep_fsync(struct iocb *iocb, int fd);
static inline int io_fsync(io_context_t ctx, struct iocb *iocb, io_callback_t cb, int fd);
static inline void io_prep_fdsync(struct iocb *iocb, int fd);
static inline int io_fdsync(io_context_t ctx, struct iocb *iocb, io_callback_t cb, int fd);
static inline void io_set_eventfd(struct iocb *iocb, int eventfd);

二、使用方法

1、初使化io_context
2、open文件取得fd
3、根据fd，buffer offset等息建立iocb
4、submit iocb到context
5、io_getevents取得events状态
6、回到3步

三、例子

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <error.h>
#include <errno.h>

#include <fcntl.h>
#include <libaio.h>

int main(int argc, char *argv[])
{
	// 每次读入32K字节
	const int buffer_size = 0x8000;

	// 最大事件数 32
	const int nr_events   = 32;
	int rt;

	io_context_t ctx = {0};

	// 初使化 io_context_t
	rt = io_setup(nr_events, &ctx);
	if ( rt != 0 )
		error(1, rt, "io_setup");

	// 依次读取参数作为文件名加入提交到ctx
	int pagesize = sysconf(_SC_PAGESIZE);
	for (int i=1; i<argc; ++i) {
		iocb *cb = (iocb*)malloc(sizeof(iocb));
		void *buffer;
		// 要使用O_DIRECT, 必须要对齐
		posix_memalign(&buffer, pagesize, buffer_size);
		io_prep_pread(cb, open(argv[i], O_RDONLY | O_DIRECT), buffer, buffer_size, 0);
		rt = io_submit(ctx, 1, &cb);
		if (rt < 0)
			error(1, -rt, "io_submit %s", argv[i]);;
	}

	io_event events[nr_events];
	iocb     *cbs[nr_events];

	int remain = argc - 1;
	int n      = 0;

	// 接收数据最小返回的请求数为1，最大为nr_events
	while (remain && (n = io_getevents(ctx, 1, nr_events, events, 0))) {
		int nr_cbs = 0;
		for (int i=0; i<n; ++i) {
			io_event &event = events[i];
			iocb     *cb    = event.obj;
			// event.res为unsigned
			//printf("%d receive %d bytes\n", cb->aio_fildes, event.res);
			if (event.res > buffer_size) {
				printf("%s\n", strerror(-event.res));
			}
			if (event.res != buffer_size || event.res2 != 0) {
				--remain;
				// 释放buffer, fd 与 cb
				free(cb->u.c.buf);
				close(cb->aio_fildes);
				free(cb);
			} else {
				// 更新cb的offset
				cb->u.c.offset += event.res;
				cbs[nr_cbs++] = cb;
			}
		}

		if (nr_cbs) {
			// 继续接收数据
			io_submit(ctx, nr_cbs, cbs);
		}
	}
	return 0;
}

运行

$ truncate foo.txt -s 100K
$ truncate foo2.txt -s 200K
$ g++ -O3 libaio_simple.cc -laio && ./a.out foo.txt foo2.txt
3 received 32768 bytes
4 received 32768 bytes
3 received 32768 bytes
4 received 32768 bytes
3 received 32768 bytes
4 received 32768 bytes
3 received 4096 bytes
3 done.
4 received 32768 bytes
4 received 32768 bytes
4 received 32768 bytes
4 received 8192 bytes
4 done.

四、其它

这里有个问题，因为O_DIRECT跳过系统缓存，直接从磁盘读取，对于读写来讲是个大问题。要自已实现缓存，需要一堆东西要啃，而且还不一定写得好。

nodejs V8 Persistent句柄与GC

JiangMiao — Sun, 24 Jul 2011 01:36:01 +0800

在nodejs中，常常会遇到ObjectWrap的C++ Module，即用一个Persistent句柄引用一个携带C/C++指针的对象，并设定该Persistent句柄的WeakCallback，当Persistent被孤立时，删除指针，并Dispose句柄。一般来说凡是C++/Native的Module（如PostgreSQL，Memcache等等)的都会有Persistent释放问题。

测试发现，因为GC的延迟常常会使得有效的指针堆积如山，由heap.cc可以得知V8的在台式机上的GC策略为

      reserved_semispace_size_(16*MB),
      max_semispace_size_(16*MB), //GC最大阈值为16M
      initial_semispace_size_(1*MB), //初使的GC的阈值为1M
      max_old_generation_size_(1*GB), //最大内存消耗
      max_executable_size_(256*MB),
      code_range_size_(512*MB),

1. 测试代码1

对于如下C++0x测试代码 1

#include <v8.h>
#include <stdio.h>
#include <sys/time.h>

using namespace v8;
class Foo
{
    public:
	static int total;
	static int number;
	static int last;

	Foo();
	~Foo();
};

int Foo::total  = 1;
int Foo::number = 1;
int Foo::last = 1;

Foo::Foo()
{
	if (last > number) {
		printf("creating from id %d\n", number);
	}
	last = number;
	++number;
	++total;
	// 加上下面这条似乎更合理，不过对于没有成员变量的类来说有没有都无感觉。
	// 2011-08-13 补充，使用sizeof(Foo) 1字节，并不正确，详见文尾补充
	V8::AdjustAmountOfExternalAllocatedMemory(sizeof(Foo));
}

Foo::~Foo()
{
	if (last<number) {
		printf("sweeping from id %d\n", number);
	}
	last = number;
	--number;
	V8::AdjustAmountOfExternalAllocatedMemory(-sizeof(Foo));
}

long long microtime()
{
	timeval tv;
	gettimeofday(&tv, NULL);
	return (long long)tv.tv_sec * 1000 + tv.tv_usec / 1000;
}

int main(int argc, char *argv[])
{
	V8::SetFlagsFromCommandLine(&argc, argv, true);

	HandleScope scope;
	auto context = Context::New();
	Context::Scope context_scope(context);

	auto object_template = ObjectTemplate::New();
	object_template->SetInternalFieldCount(1);

	auto start = microtime();
	int times = 2e8;
	for (int i=0; i<times; ++i) {
		HandleScope scope;
		auto object = object_template->NewInstance();
		auto foo = new Foo();

		// 把foo可入到object，使得在任何时候都可能通过对象object得到foo的指针。
		// 这句也可简写成object->SetPointerInInternalField(0, foo);
		object->SetInternalField(0, External::New(foo));

		// 创建一个Persistent句柄监视object的引用状况，
		// 当object不被任何对象引用时，删除foo与该句柄。
		Persistent<Object>::New(object).MakeWeak(foo, [](Persistent<Value> value, void *data) {
			delete (Foo*)data;
			value.Dispose();
		});
		if (i%(int)1e6 == 0) {
			int speed = i / (microtime() - start);
			printf("Speed: %d\n", speed);
		}
	}

	context.Dispose();
	return 0;
}

编译

$ g++ -std=c++0x -O3 gc_test.cc -lv8

2. 使用默认策略

max-semispace-size 16M
max-old-generation-size 1G
如果使用默认策略，输出结果

$ ./a.out  --trace-gc
Speed: 0
Scavenge 0.9 -> 0.8 MB, 5 ms.
Scavenge 1.2 -> 1.2 MB, 6 ms.
Scavenge 1.6 -> 1.6 MB, 6 ms.
Scavenge 2.3 -> 2.3 MB, 13 ms.
sweeping from id 114428
Mark-sweep 3.1 -> 3.0 MB, 35 / 74 ms.
creating from id 1
Scavenge 5.0 -> 5.0 MB, 25 ms.
...
...
Scavenge 46.4 -> 46.4 MB, 89 ms.
Speed: 186
Scavenge 52.4 -> 52.4 MB, 103 ms.
Scavenge 58.4 -> 58.4 MB, 112 ms.
...
...
Scavenge 106.4 -> 106.4 MB, 170 ms.
sweeping from id 3233110
Mark-sweep 112.4 -> 74.4 MB, 998 / 1999 ms.
creating from id 1
Speed: 182
Scavenge 82.4 -> 82.4 MB, 89 ms.
Scavenge 88.4 -> 88.4 MB, 94 ms.
Scavenge 94.4 -> 94.4 MB, 104 ms.

可以发现，运行不多时，需积压了323万个Persistent才进行一次Mark-sweep，耗时2s，如果对于服务器让其挂起2S进行GC，显然是不行的。而且会不断的消耗内存，直到默认的1GB为止，但奇怪的是在1GB后Mark sweep释放也不会使物理占用内存下降。

3. 限制max-old-generation-size为20

max-old-generation-size的参数在命令行下为max-old-space-size，单位M
加入参数 –max-old-space-size=20 限制space的大小为20M

$ ./a.out --trace-gc --max-old-space-size=20
Speed: 0
Scavenge 0.9 -> 0.8 MB, 5 ms.
Scavenge 1.2 -> 1.2 MB, 6 ms.
Scavenge 1.6 -> 1.6 MB, 6 ms.
Scavenge 2.3 -> 2.3 MB, 13 ms.
sweeping from id 114428
Mark-sweep 3.1 -> 3.0 MB, 35 / 75 ms.
creating from id 1
Scavenge 5.0 -> 5.0 MB, 26 ms.
Scavenge 6.5 -> 6.5 MB, 24 ms.
Scavenge 9.5 -> 9.5 MB, 52 ms.
Scavenge 12.5 -> 12.5 MB, 54 ms.
sweeping from id 677206
Mark-sweep 18.5 -> 15.9 MB, 213 / 458 ms.
creating from id 1
Speed: 190
sweeping from id 349526
Mark-sweep 23.9 -> 8.4 MB, 111 / 304 ms.
creating from id 1
sweeping from id 349526
Mark-sweep 16.4 -> 8.4 MB, 116 / 284 ms.
creating from id 1
sweeping from id 349526
Mark-sweep 16.4 -> 8.4 MB, 111 / 277 ms.
creating from id 1
Speed: 190
sweeping from id 349526
Mark-sweep 16.4 -> 8.4 MB, 108 / 273 ms.
creating from id 1

发现当使用超过20M后就进行了global GC模式。每次sweep 200ms也到了可接受范围。

4. 设置–gc-global强制MarkSweep与max-semispace-size为2048K

max-semispace-size对应的命令行设置参数为–max-new-space-size，单位K
测试2、通过设置参数–gc-global 强制每次都执行Mark-sweep 与 –max-new-space-size 缩小最大阈值

$ ./a.out --trace-gc --max-new-space-size=2048 --gc-global
Speed: 0
sweeping from id 16124
Mark-sweep 0.7 -> 0.7 MB, 6 / 15 ms.
creating from id 1
sweeping from id 21846
Mark-sweep 1.2 -> 0.8 MB, 8 / 20 ms.
creating from id 1
sweeping from id 21846
Mark-sweep 1.3 -> 0.8 MB, 8 / 20 ms.
creating from id 1
sweeping from id 43692
Mark-sweep 1.8 -> 1.3 MB, 17 / 39 ms.
creating from id 2
sweeping from id 43692
Mark-sweep 2.3 -> 1.3 MB, 17 / 39 ms.
creating from id 1
sweeping from id 43692
Speed: 186

从配合–gc-global情况来看，内存和GC时间都控制在一个很不错的水平，但尚不清楚，低semispace-size会有何影响，

但对于C/C++程序员来说，对于Persistent对象不交给GC而手动进行及时释放是最好的选择，避免了这样那样的GC问题。可惜nodejs缺少标准，而且不规范的native module过份依赖GC，与C++对象关联的ObjectWrap无法得到很好的释放，如果光占用内存还好，要是还占用描述符等系统资源，那等积压了数十万个才到GC时释放就晚了。

5. 其它测试

另外打算测试下小窥nodejs 一文中的md5代码，竟发现代码在0.4.9中卡壳。升到git最新的0.5.3-pre也一样，

var crypto = require('crypto');
var mymd5 = function(str, encoding){
  return crypto
  .createHash('md5')
  .update(str)
  .digest(encoding || 'hex');
};

while(1){
  console.info(mymd5("" + parseInt(Math.random() * 100000)));
}

但用d8代替nodejs运行，一切正常。
对于代码

if(typeof(print)=='undefined') {
  print = console.info

}

i = 0;
while(true){
  ++i;
  print(i);
}

也会卡壳，似乎是过由快的输出函数调用导致。
修改代码至

if(typeof(print)=='undefined') {
  print = console.info

}

i = 0;
while(true){
  ++i;
  if (i%100 ==0)
    print(i);
}

就不再卡壳了。
原代码修改为

if(typeof(print)=='undefined') {
  print = console.info

}

var crypto = require('crypto');
var mymd5 = function(str, encoding){
  return crypto
  .createHash('md5')
  .update(str)
  .digest(encoding || 'hex');
};

i=0;
while(1){
  mymd5("" + parseInt(Math.random() * 100000));
  ++i;
  if (i%100000 == 0) {
    print(i);
  }
}

若用max-new-space-size配gc-global参数，的确能把内存控制在一个合理的范围。

$ node --trace-gc --max-new-space-size=2048 --gc-global md5.js
Mark-sweep 1.5 -> 1.2 MB, 7 ms.
Mark-sweep 1.9 -> 1.5 MB, 1 / 11 ms.
...
...
Mark-sweep 2.9 -> 1.9 MB, 4 / 20 ms.
100000
Mark-sweep 2.9 -> 1.9 MB, 4 / 20 ms.
...
...
Mark-sweep 2.9 -> 1.9 MB, 4 / 19 ms.
200000
Mark-sweep 2.9 -> 1.9 MB, 4 / 19 ms.
Mark-sweep 2.9 -> 1.9 MB, 4 / 18 ms.
Mark-sweep 2.9 -> 1.9 MB, 4 / 18 ms.
Mark-sweep 2.9 -> 1.9 MB, 4 / 20 ms.
Mark-sweep 2.9 -> 1.9 MB, 4 / 19 ms.

再对照没有Persistent句柄的脚本

if(typeof(print)=='undefined') {
  print = console.info
}

i=0;
while(1){
  str = "hello world" + i
  ++i;
  if (i%1000000 == 0) {
    print(i);
  }
}

虽然同样产生了大量的string对象，但因为对象都是Local对象，因此内存很好的得到了回收。

$ node --trace-gc md5.js
Scavenge 1.5 -> 1.3 MB, 2 ms.
Scavenge 1.8 -> 1.6 MB, 2 ms.
Scavenge 2.0 -> 1.8 MB, 2 ms.
...
...
Scavenge 5.8 -> 2.1 MB, 2 ms.
Scavenge 5.8 -> 2.1 MB, 2 ms.
Scavenge 5.8 -> 2.1 MB, 2 ms.
1000000
Scavenge 5.8 -> 2.1 MB, 2 ms.
Scavenge 5.8 -> 2.1 MB, 2 ms.
...
...
Scavenge 5.8 -> 2.1 MB, 2 ms.
Scavenge 9.8 -> 2.1 MB, 2 ms.
2000000
Scavenge 9.8 -> 2.1 MB, 2 ms.
Scavenge 9.8 -> 2.1 MB, 2 ms.
...
...
Scavenge 9.8 -> 2.1 MB, 2 ms.
3000000
Scavenge 9.8 -> 2.1 MB, 2 ms.
...
...
Scavenge 9.8 -> 2.1 MB, 2 ms.
5000000
Scavenge 9.8 -> 2.1 MB, 2 ms.
Scavenge 9.8 -> 2.1 MB, 2 ms.
Scavenge 9.8 -> 2.1 MB, 2 ms.

对比string很明显，crypto制造的大量Persistent句柄，且没有手动释放，要等到GC Mark-sweep才能回收，就如测试代码一一样产生了越来越多的对象，V8又看到对象多多，不断的加大内存需求，直到默认的1G。
另外，新版的crypto似乎修正了不断侵食内存的问题。

6. 小结

要解决Persistent问题，方法有3
1、如本文所述，限制阈值，强制global gc
2、规范nodejs module，及时释放Persistent相关对象。
3、改进V8 GC策略

方法1,2可行性比较高。
如果遇到不断侵食内存的问题module，那只能使用方法1了。

7. 其它问题：

暂时不知道原因的问题，等路过的高人指点：
问题：使用默认策略测试代码1 Mark Sweep为什么物理内存还是占有950M以上。是V8内存策略还是Persistent的MakeWeak调用方法不正确？

===2011-08-13 补充==
知道了，即使是空对象也是有大小的，包括一些内存分配信息等，如果像文中例子使用sizeof(Foo) 1字节，是不正确的。分配new一个对象将占多少内存，不用深究具体数值，一定不大，用最大可能占用额然内存128字节限定，就能把内存控制在一个合理的范围。

	// 加上下面这条似乎更合理，不过对于没有成员变量的类来说有没有都无感觉。
-	V8::AdjustAmountOfExternalAllocatedMemory(sizeof(Foo));
+	V8::AdjustAmountOfExternalAllocatedMemory(128);  

-	V8::AdjustAmountOfExternalAllocatedMemory(-sizeof(Foo));
+	V8::AdjustAmountOfExternalAllocatedMemory(-128);

输出

sweeping from id 124978
Mark-sweep 11.2 -> 3.2 MB, 85 / 149 ms.
creating from id 2
Speed: 167
sweeping from id 349436
Mark-sweep 11.2 -> 8.4 MB, 235 / 474 ms.
creating from id 1
sweeping from id 124985
Mark-sweep 11.2 -> 3.2 MB, 84 / 147 ms.
creating from id 2

锁定到了 11.2M

== 2011-08-16 补充 ==
在程序中可以通过函数 V8::LowMemoryNotification 进行强行GC

javascript V8惊人的性能

JiangMiao — Wed, 20 Jul 2011 01:18:02 +0800

今天测试了一下V8，虽然一直听说和感觉到V8快，但测试后发现性能超过C++ STL，甚至超过了C函数。着实惊人。

一、测试代码：

1. C++：test.cc

#include <sys/time.h>

#include <cstdlib>
#include <cstdio>

#include <vector>
#include <list>
#include <string>
#include <map>
#include <unordered_map>
#include <boost/asio/detail/hash_map.hpp>
#include <string.h>
using namespace std;

long long microtime()
{
	timeval tv;
	gettimeofday(&tv, NULL);
	return (long long)tv.tv_sec * 1000 + tv.tv_usec / 1000;
}

#define START() long long start = microtime();
#define FINISH(title) printf("%s %lld\n", title, times / (microtime() - start));
#define BENCHMARK for(int i=0; i<times; ++i)

#define BIG_INTERVAL 60 * 60 * 1000
#define SMALL_INTERVAL 1 * 1000
inline char *my_itoa(int n)
{
	bool is_neg = false;
	if (n<0) {
		is_neg = true;
		n = -n;
	}
	static char buf[16];
	char * last = buf + 15;
	*last = 0;
	do {
		*(--last) = '0' + n % 10;
		n /= 10;
	} while(n);
	if (is_neg) {
		*(--last) = '-';
	}
	return last;
}

int main(int argc, char *argv[])
{
	int times = 1e6;
	{
		START();
		char buf[64];
		BENCHMARK {
			sprintf(buf, "%da", i);
		}
		FINISH("i+a");
	}

	{
		START();
		char buf[64];
		BENCHMARK {
			sprintf(buf, "%sa", my_itoa(i));
		}
		FINISH("sprintf without locale");
	}

	{
		START();
		char buf[64];
		BENCHMARK {
			char *dest = buf;
			dest = stpcpy(dest, "a");
			dest = stpcpy(dest, my_itoa(i));
		}
		FINISH("strpcpy");
	}

	{
		START();
		vector<int> vs;
		BENCHMARK {
			vs.push_back(i);
		}
		FINISH("array int");

	}

	{
		START();
		vector<int> vs;
		BENCHMARK {
			vs.push_back(9999);
		}
		FINISH("array int static");

	}

	{
		START();
		list<int> ls;
		BENCHMARK {
			ls.push_back(9999);
		}
		FINISH("array list static");

	}

	{
		START();
		vector<string> vs;
		char buf[64];
		BENCHMARK {
			sprintf(buf, "%d", i);
			vs.push_back(buf);
		}
		FINISH("array string");

	}

	{
		START();
		vector<string> vs;
		char buf[64];
		BENCHMARK {
			vs.push_back("hello world");
		}
		FINISH("array string static");

	}

	{
		START();
		string a = "hello";
		string b = "world";
		string c;
		BENCHMARK {
			c = a + b;
		}
		FINISH("string a+b");
	}

	unordered_map<int, int> um;
	{
		START()
		BENCHMARK {
			um[i] = i;
		}
		FINISH("unordered map");
	}

	boost::asio::detail::hash_map<int, int> hm;
	{
		START()
		BENCHMARK {
			hm.insert(make_pair(i, i));
		}
		FINISH("asio hash map");
	}

	map<int, int> m;
	{
		START()
		BENCHMARK {
			m[i] = i;
		}
		FINISH("map");
	}
	return 0;
}

2. CoffeeScript：test.coffee

benchmark = (title, callback) ->
  start = Date.now()
  times = 1e6
  for i in [1..times]
    callback(i)
  console.info title, times / (Date.now() - start)

benchmark 'i+a', (i)->
  i+'a'

a=[]
benchmark 'array int', (i)->
  a.push i

a=[]
benchmark 'array int static', (i)->
  a.push 9999

a=[]
benchmark 'array string', (i)->
  a.push i+''

a=[]
benchmark 'array string static', (i)->
  a.push 'hello world'

benchmark 'string a+b', (i)->
  c = 'hello'+'world'

a={}
benchmark 'map', (i)->
  a[i] = i

二、测试环境

Linux myhost 2.6.36-ARCH
#1 SMP PREEMPT Mon Jan 24 18:34:55 UTC 2011 i686
Intel(R) Atom(TM) CPU D510 @ 1.66GHz GenuineIntel GNU/Linux

node v0.4.9
gcc 版本 4.6.1 (GCC)
v8 3.2.10.2

三、测试过程

C++：

$ g++ -O3   -c -o test.o test.cc
$ g++   test.o   -o test
i+a 1642
array int 52631
array static 58823
array string 881
array string static 2272
string a+b 1594
map 1109

javascript：

$ coffee test.coffee
i+a 1937.984496124031
array int 14492.753623188406
array int static 16393.44262295082
array string 1564.9452269170579
array string static 11111.111111111111
string a+b 7042.2535211267605
map 8928.57142857143

四、测试结果

单位：次数/毫秒

	C++	V8
i+a	1642	1937 – 117%
sprintf without locale	1834	1937 – 105%
strpcpy	9615	1937 – 20%
array int	52631	14492 – 27%
array int static	58823	16393 – 27%
array string	881	1564 – 177%
array string static	2272	11111 – 489%
string a+b	1594	7042 – 441%
map	1109	8928 – 805%
unordered_map	2941	8928 – 306%
asio hash map	2525	8928 – 354%

五、测试总结

V8的字符串转换居然超过了C函数sprintf性能。
STL的vector性能依然强劲，
但string与map性能远不及V8，本次测试中拖了后腿。

从测试来看，如果不打算用原生代码C/C++写nodejs扩展，还是用javascript来得实惠，若用STL说不定性能不升反降。

六、其它

The Computer Language Benchmarks Game提供了各种语言的性能大小等比较，但该网站的测试代码质量和注重方向参差不齐，总得来看V8的性能约为C的1/3。内存使用为5倍，代码量为1/3，作为最快的动态语言，比起PHP，Python，Ruby等可谓是相当出众。

七、相关链接

V8官网
 V8设计元素
 为什么V8这么快.pdf

备注：因为内存管理模型不同，V8是由垃圾回收控制，而C++是立即是放，所以含有内存释放相关的测试结果并非完全精确，仅供参考。

江淼的Blog

Linux下的数据统计

一、基本统计

二、图形化统计结果

三、相关链接

node.js成也异步，败也异步，评node.js的异步特性

一、 异步在http服务器上表现

1. 充分利用等待时间的谎言

2. 无法出众的http性能

3. 艰难的异步之路

二、 node异步的用武之地

三、 一组hello world的测试

四、 小结

node.js异步数据库连接，事务查询思考

一、解决方法

1. 通过vm

2. 通过建立model后赋于变量

3. Model模版

4. 资源池

二、小结

ToffeeScript – 支持异步语法的CoffeeScript

一、 特性一览

1. 异步语法支持

a. 原理

2. Symbol语法的字串

3. 正则运算符 =~

4. 正则Magic标识符 \& \~ \1..9

二、 安装

三、 相关链接

Dart试用手记 – 2、语法与评论

1. 注释

2. 变量

3. 函数

4. 闭包

5. 类

6. 数组与Hash

7. 循环

静观其变

Dart评论

Dart试用手记 – 1、编译与安装

一、安装

1. 准备

2. 安装Depot_tools

3. 配置gclient

4. 同步代码

5. 修改一个gcc的小问题

6. 编译

7. 测试

二、介绍

1. Dart的基本特性

三、Hello World

四、相关链接

CoffeeScript 功能加强

1. Ruby Symbol like

2. 正则表达示运算符

3. Links

Linux libaio

一、基本函数与结构

1. libaio函数

2. 结构

3. 内联函数

二、使用方法

三、例子

四、其它

nodejs V8 Persistent句柄与GC

1. 测试代码1

2. 使用默认策略

3. 限制max-old-generation-size为20

4. 设置–gc-global强制MarkSweep与max-semispace-size为2048K

5. 其它测试

6. 小结

7. 其它问题：

javascript V8惊人的性能

一、测试代码：

1. C++：test.cc

2. CoffeeScript：test.coffee

二、测试环境

三、测试过程

四、测试结果

五、测试总结

一、异步在http服务器上表现

三、一组hello world的测试

四、小结

一、特性一览

二、安装

三、相关链接