博客园_回头再说坚强2002的博客

[Erlang 0062] Erlang Unicode 两三事

2012-05-31T14:55:00Z

不少人和我一样在Erlang实践过程中都会遇到中文的问题,其中有中文显示的问题有正则表达式匹配的问题等等;今天请教立涛之后梳理了一下,整理于此.

概念Unicode UTF-8

《深入理解计算机系统》里面提到过"信息=数据位+上下文",同样的数据在不同的上下文环境有不同的解读方式; 同样的二进制数据按照不同的编码规范去解析得出的结果也不尽相同,如果使用错误的编码方式去解读数据就会出现所谓的乱码问题.看看下面的例子:<<123,231>>.可以被输出为可打印字符{?,也可以按照不同的数据位规则进行分割.可以看到不同规则下,解读出来的变量值是完全不同的.

Eshell V5.8.2 (abort with ^G)
1> <<123,231>>.
<<"{?>>
2> <<A:1,B:7,C:8>> = v(1).
<<"{?>>
3> b().
A = 0
B = 123
C = 231
ok
4> <<D:5,E:3,F:7,G:1>> = v(1).
<<"{?>>
5> b().
A = 0
B = 123
C = 231
D = 15
E = 3
F = 115
G = 1
ok
6>

数字123,231在EShell中输出为字符"{?",也就是数字和字符之间有对应关系,这就是编码.所谓编码就是定义了字符和数字之间的对应关系,比如ASCII编码中a字符对应数值97;在ASCII字符集中就不包含中文字符和数值之间的对应关系; 一个理想的解决方案就是采用一种统一的编码规范.Unicode就为解决这个问题而生,Unicode编码用以统一地体现和处理世界上大部分的文字系统,并为其编码,在Unicode相关资料中频繁出现的名词codepoint实际上就是数字;

Unicode编码系统包含两部分的内容:编码方式和实现方式.Unicode会使用几个字节表示字符呢?这属于实现方式(或者说表达方式),Unicode只规定符号的编码,不规定如何表达.一个字符的Unicode编码是确定的,但是在实际传输过程中,由于不同系统平台的设计不一定一致,以及出于节省空间的目的,对Unicode编码的实现方式有所不同.Unicode的实现方式称为Unicode转换格式(Unicode Transformation Format,简称为UTF),UTF-8就是转换格式之一.UTF-8采用变长字节存储Unicode,如果一个仅包含基本7位ASCII字符的Unicode文件,如果每个字符都使用2字节的原Unicode编码传输,其第一字节的8位始终为0.这就造成了比较大的浪费,对于这种情况可以使用UTF-8编码,这是一种变长编码,它将基本7位ASCII字符仍用7位编码表示,占用一个字节(首位补0).而遇到与其他Unicode字符混合的情况,将按一定算法转换,每个字符使用1-3个字节编码,并利用首位为0或1进行识别.这样对以7位ASCII字符为主的西文文档就大大节省了编码长度.

一个字符的用两个字节表示16位的编码空间,也就是每个字符占用2个字节.理论换上有65535个字符,实际应用中并没有完全使用这16位编码,而是保留了大量空间作为特殊使用或者扩展,比如 16#D800 - 16#DFFF 就是保留区域;其中16#FEFF被用作BOM(byte-order mark)即字节顺序记号,不建议在其它场景使用.
维基百科:Unicode 编码：http://zh.wikipedia.org/wiki/Unicode UTF-8编码：http://zh.wikipedia.org/wiki/UTF-8

Erlang & Unicode

Erlang的string实际上就是整数项组成的list,注意string的编解码使用是使用ISO-latin-1字符集,即:每8字节当成一个整体进行解读;这个字符集是Unicode的子集.Erlang list编解码很容易扩展到整个unicode编码:由于编码是整数和字符的对应关系,只要list中的整函数是有效的Unicode codepoint就可以找到对应的字符;二进制数据处理起来就麻烦一些了,二进制数据是紧凑排列的:一个字节代表一个字符,而不是两个字(word)一个字符,这里如果存在疑问可以查看erlang官方文档中关于内存消耗的列表:http://www.erlang.org/doc/efficiency_guide/advanced.html .平时我们使用的erlang:list_to_binary,常规的Erlang string(ISO-latin编码的string)可以逐字节逐字符顺利转成binary.但是超出ISO-latin编码范围就会出错了,看下面的例子:

Eshell V5.9 (abort with ^G)
1> L=[10,12,23,45].
[10,12,23,45]
2> list_to_binary(L).
<<10,12,23,45>>
3> L2= "中国".
[20013,22269]
4> list_to_binary(L2).
** exception error: bad argument
in function list_to_binary/1
called as list_to_binary([20013,22269])
5> unicode:characters_to_list(L2).
[20013,22269]
6> unicode:characters_to_binary(L2). %%注意"中国"用二进制占用了6个字节
<<228,184,173,229,155,189>>

之前我在[Erlang 0024]Erlang二进制数据处理的时候提到过,UTF-8是Erlang二进制处理的标准编码形式,一旦出现需要处理Unicode二进制数据的场景,默认就会选择UTF8编码.比特语法支持使用其它的编解码方式,但是erlang类库中处理二进制都是使用UTF-8编码.字符串可以接受Unicode字符,但是Erlang的语言元素编写还是限制在ISO-latin-1的范围内.Erlang编译过程依然是使用ISO-latin-1编码,这样的影响是什么呢?代码中出现的Unicode字符会有部分无法在ISO-latin-1找到对应的字符,那怎么办呢?没关系,找不到对应的字符就按照整形数去处理就好了.

Erlang Shell对unicode的支持要强一些,但是也并不完善,下面我们通过一系列实验来看上面的问题,在test模块里面我们准备两条测试数据:

data()->
"hello 中国 ren".
data2()->
<<"hello 中国 ren">>.

启动Erlang Shell,我们对比一下数据之间的差异:

Eshell V5.9 (abort with ^G)
1> "hello 中国 ren". %%在shell中输入包含中文的string,可以看到它就是一个List,注意中文字符对应的数值
[104,101,108,108,111,32,20013,22269,32,114,101,110]
2> test:data(). %%注意下面的数据,中文部分数值已经被切割成两组数据
[104,101,108,108,111,32,228,184,173,229,155,189,32,114,101,
110]
3> <<"hello 中国 ren">>. %%而这样的数据在shell中直接出错了 (注意:windows下可能是正常的)
** exception error: bad argument
4> test:data2(). %%看看这里二进制的输出,数值上是和v(2)的数值上是一致的
<<104,101,108,108,111,32,228,184,173,229,155,189,32,114,
101,110>>
5> unicode:characters_to_binary(v(1)). %%把v(1)的结果转成二进制,为什么不用list_to_binary?往下看
<<104,101,108,108,111,32,228,184,173,229,155,189,32,114,
101,110>>
6> io:format("~ts~n",[v(1)]). %%注意这里格式化的时候使用的修饰符是~ts
hello 中国 ren
ok
7> io:format("~ts~n",[v(2)]). %%v(2)输出的内容并不是我们期望的
hello ä¸å½ ren
ok
8> io:getopts(). %%是不是觉得少检查了点什么?是的看看环境编码
[{expand_fun,#Fun<group.0.33302583>},
{echo,true},
{binary,false},
{encoding,unicode}]
9> list_to_binary(v(1)). %%看到了吧,这样会异常的
** exception error: bad argument
in function list_to_binary/1
called as list_to_binary([104,101,108,108,111,32,20013,22269,32,114,101,110])
10> list_to_binary(v(2)).
<<104,101,108,108,111,32,228,184,173,229,155,189,32,114,
101,110>>
14>

进行到这里,下面这个问题就有答案了,我们在Shell中执行下面的语句:

14> re:run("hello 中国 ren", "[\x{4e00}-\x{9fff}]+", [unicode]).
{match,[{6,6}]}
15>
然后我们把这条语句放在模块代码中执行:
re() ->
re:run("hello 中国 ren", "[\x{4e00}-\x{9fff}]+", [unicode]).
执行结果:
15> test:re().
nomatch
16>

答案就是:在模块文件进行编译的时候使用的是ISO-latin-1,其中的中文并不在其字符集中,所以转成了两组数字!被转成两组数字之后,也就无法被正则表达式命中了.而在Erlang Shell中,中文字符可以被正确编码,所以会被正则命中.而仔细关注一下正则表达式,其实就是大致上覆盖了中文字符在unicode字符集中对应的数值区间.

对于这种情况只要让unicode避开编译阶段就可以了,比如把这类文本放在外部文本中,下面立涛给的这份代码样例中演示了从外部文件读取文本内容,并匹配中文. https://gist.github.com/2768621
方法二:在源代码中使用Unicode有一个语法糖可以用 \x{400} 的形式:

3> $\x{400}.
1024
4> 16#400.
1024
5> erl_scan:string("\"\x{400}\".").
{ok,[{'[',1},{integer,1,1024},{']',1},{dot,1}],1}
6> erl_scan:string("\"16#400\".").
{ok,[{string,1,"16#400"},{dot,1}],1}

注意正则表达式中\x{4e00}就使用了这样的表达方式

Eshell V5.9 (abort with ^G)
1> "中国".
[20013,22269]
2> integer_to_list(20013,16).
"4E2D"
3> $\x{4E2D}.
20013
4> list_to_binary([20013]).
** exception error: bad argument
in function list_to_binary/1
called as list_to_binary([20013])
5> unicode:charaters_to_binary([20013]).
** exception error: undefined function unicode:charaters_to_binary/1
6> unicode:characters_to_binary([20013]).
<<"ä¸">>
7> io:getopts().
[{expand_fun,#Fun<group.0.33302583>},
{echo,true},
{binary,false},
{encoding,unicode}]
8>

一个细节"~ts" 修饰符
The Erlang compiler will interpret the code as ISO-8859-1 encoded text, which limits you to Latin characters."translation modifier" when working with Unicode texts. The modifier is "t". When applied to the "s" control character in a formatting string, it accepts all Unicode codepoints and expect binaries to be in UTF-8.

Eshell V5.9 (abort with ^G)
1> io:format("~ts",[unicode:characters_to_binary([20013])]).
中ok
2> io:format("~ts",[unicode:characters_to_binary([20013,22269])]).
中国ok
3> L=[229,136,157,231,186,167], io:format("~ts", [list_to_binary(L)]).
初级ok

unicode & mochiwebuft8

Erlang unicode模块提供了基本的转换功能,上面的测试代码中已经有应用,该模块暴露出来的方法有:characters_to_list/1,2 characters_to_binary/1,2,3 bom_to_encoding/1 encoding_to_bom/1;mochiwebuft8中提供了专门的模块,方便处理UTF8相关的转换,看下例子:

Eshell V5.9 (abort with ^G)
1> mochiutf8:codepoint_to_bytes(20320).
<<"ä½ ">>
2> io:format("~ts",[v(1)]).
你ok
3> mochiutf8:codepoint_to_bytes(22909).
<<"å¥½">>
4> io:format("~ts",[v(3)]).
好ok
5> mochiutf8:codepoint_to_bytes([20320,22909]).
** exception error: no function clause matching mochiutf8:codepoint_to_bytes([20320,22909]) (src/mochiutf8.erl, line 20)
6> mochiutf8:codepoints_to_bytes([20320,22909]).
<<"ä½ å¥½">>
7> io:format("~ts",[v(6)]).
你好ok

最后:Windows下不省心啊

在官方文档中,对于windows环境中Erlang shell的描述是"The interactive Erlang shell, when started towards a terminal or started using the werl command on windows, can support Unicode input and output."即:如果是在windows中启动werl可以支持Unicode的输入输出,

Eshell V5.9 (abort with ^G)
1> "国家".
[22269,23478]
2> io:format("~p~n",["国家"]).
[22269,23478]
ok
3> io:format("~w~n",["国家"]).
[22269,23478]
ok
4>
4> io:format("~ts~n",["国家"]).
国家
ok
5>
5> lists:keyfind(encoding,1,io:getopts()).
{encoding,unicode}
6>

类似的代码在Centos中执行:

同样的代码在Centos中:
Eshell V5.9 (abort with ^G)
1> "你好".
[20320,22909]
2> list_to_binary(v(1)).
** exception error: bad argument
in function list_to_binary/1
called as list_to_binary([20320,22909])
3>

貌似,在windows中unicode的问题解决的看上去很美啊,好吧,看下面的这张图:

2012-6-1 12:09:49更新: 关于上面的截图,我还是误解了,看下面的讨论

深圳-燕尘(6108770) 11:45:04
Shell
在 unicode 环境下，中文会被编译为 [20013,22269,20154] 这样的双字节数字，
在 latin1 环境下，中文会被编译为 [228,184,173,229,155,189,228,186,186] 这样的单字节数字，
所以在 unicode 环境下需要用 [\x{4e00}-\x{9fff}] 来匹配，是双字节的表达式，
latin 环境下需要用 [\x81-\xfe][\x40-\xfe] 来匹配，是单字节的表达式。
然后 windows 下面，cmd 默认是 latin1 环境，werl.exe 默认是 unicode 环境。

深圳-燕尘(6108770) 11:47:01
windows 的默认字符集是各国的本地语言，像中文是 GBK ，都会被 erlang 视为 latin1 环境。
北京-坚强2002 11:47:58
windows里面的事情就诡异了看上面的截图
深圳-燕尘(6108770) 11:48:11
然后在 unicode 环境下，不能用 list_to_binary 来转换 unicode 字符，
要用 list_to_binary(unicode:character_to_list())
doc 里面的 unicode 文档讲了这个问题。

北京-坚强2002 11:49:14
深圳-燕尘(6108770) 11:45:04
在 unicode 环境下，中文会被编译为 [20013,22269,20154] 这样的双字节数字，
在 latin1 环境下，中文会被编译为 [228,184,173,229,155,189,228,186,186] 这样的单字节数字
这个是在shell还是在module?

深圳-燕尘(6108770) 11:50:05
shell
在 module 环境下，估计是会跟文件的编码有关。
北京-坚强2002 11:51:34
shell中这样说是对的
深圳-燕尘(6108770) 11:51:58
我用的默认 ANSI 格式保存，所以无论在 unicode 或者在 latin1 的 shell 下调用，它们都能正确运行。
北京-坚强2002 11:52:40
我们都是使用UTF-8

深圳-燕尘(6108770) 11:52:46
如果文件是 UTF-8 格式，估计就会把中文给编译成双字节的数字了。
就是这样，如果实在 Module 里用，跟你的文件编码相关，挑选不同的表达式。
你自己测试测试好了，另存为 ANSI 看看
深圳-燕尘(6108770) 11:54:14
调用 MODULE 的时候，结果跟 shell 的语言环境无关。
北京-坚强2002 11:54:53
不会的和文件编码没有关系 erlang编译器编译的时候使用latin编码中文会编译成单字节数字
广州-ErLang低手(119684825) 11:55:21
那就好
呵呵
深圳-燕尘(6108770) 11:55:48
测试测试啊
深圳-燕尘(6108770) 11:57:06
哟，我测试了。不管文件是啥编码，latin1 那个表达式都能用
北京-坚强2002 11:57:21
是的
北京-坚强2002 11:58:39
不去管windows下的怪异情况一切都能理顺了
深圳-燕尘(6108770) 11:59:16
无论shell是什么字符集，结果都是能匹配：
但是可以从匹配的位置看到，erlang把“中国人”三字编译成不同的长度了。
4> test:run().
{match,[{0,12},{8,4}]}

6> test:run().
{match,[{0,16},{12,4}]}
北京-坚强2002 11:59:36
是的是的
深圳-燕尘(6108770) 11:59:49
windows 下不怪异啊。 windows 下就是，cmd 是 latin1 字符集， werl 是 unicode 字符集
深圳-燕尘(6108770) 12:01:37
我装了一个 latin1 的 suse 和 unicode 的 arch ，虚拟机。
北京-坚强2002 12:02:34
明白我被表面忽悠了对的
1> "中国人".
"中国人"
2> hd(v(1)).
214
3>
对的

附录

附录一 正则表达式相关的测试代码

测试数据:

Rec = "^[\x{4e00}-\x{9fff}]+$", % 中文正则1
Rec = "^([\x81-\xfe][\x40-\xfe])+$", % 中文正则2

re() ->
re:run("hello 中国 ren", "[\x{4e00}-\x{9fff}]+", [unicode]).

re1(C) ->
re:run(C,"[\x{4e00}-\x{9fff}]+", [unicode]).

re3()->
re:run("中国人", "([\x81-\xfe][\x40-\xfe])+", [unicode]).

re4(C)->
re:run(C, "([\x81-\xfe][\x40-\xfe])+", [unicode]).

环境1:Centos {encoding,unicode}

Eshell V5.9 (abort with ^G)
1> text:re3().
{match,[{0,16},{12,4}]}
2> L="中国人".
[20013,22269,20154]
3> text:re4(L).
nomatch
4> io:getopts().
[{expand_fun,#Fun<group.0.33302583>},
{echo,true},
{binary,false},
{encoding,unicode}]
5>
5> text:re1(L).
{match,[{0,9}]}
6>
7> text:re().
nomatch
8>

环境2 :Centos {encoding,unicode}
启动命令: LC_CTYPE=en_US.ISO-8859-1 erl
Eshell V5.9 (abort with ^G)
1>
1> L="中3". %%L的内容是"中国人" 显示问题
[228,184,173,229,155,189,228,186,186]
2> text:re3().
{match,[{0,16},{12,4}]}
3> text:re4(L).
{match,[{0,4},{0,4}]}
4> io:getopts().
[{expand_fun,#Fun<group.0.33302583>},
{echo,true},
{binary,false},
{encoding,latin1}]
5> text:re1(L).
nomatch
6> text:re().
nomatch
7>

附录二 数据类型内存分配对照表

参考资料

[1] Erlang binary strings by default http://stackoverflow.com/questions/9984428/erlang-binary-strings-by-default

[2] Erlang and binary with cyrillic http://stackoverflow.com/questions/10596193/erlang-and-binary-with-cyrillic

[3] yaws unicode symbols in {html, …} http://stackoverflow.com/questions/9513623/yaws-unicode-symbols-in-html

[4] Erlang, io_lib and unicode http://stackoverflow.com/questions/8622694/erlang-io-lib-and-unicode

[5] erlang对中文支持的问题地址

[6] Erlang的Unicode支持 http://erlangdisplay.iteye.com/blog/364389

[7] EEP10 http://www.erlang.org/eeps/eep-0010.html

[8] GB2312 http://zh.wikipedia.org/wiki/GB2312

[9] 如何从一个字符串中匹配出里面的中文地址

晚安!

本文链接

The Matrix Revolutions

2012-05-24T15:36:00Z

一个负责运行虚拟现实（VR）系统的主机（Main Frame），长期运行，抛出了6次异常，前5次异常触发自动更新程序AutoUpdater完成自身软件升级，触发需要使用密钥（Key Maker）通过验证。第六次异常处理执行没有按照之前的异常处理方式，一个影响就是VR中的垃圾清理程序不断的使用VR数据进行深拷贝（Deep Copy），结果VR中的天气虚拟系统、动力系统甚至包括自动更新程序的守护进程全部被结束掉了。主机通过所构建的另外一个虚拟现实系统再次抛出该异常（rethrow）,这一次导致整个运行时重构升级，完成了第六次升级。

这不是系统升级报告,这是当年我看"黑客帝国"三部曲之后的笔记; 最近在读KK的"科技要什么",经常会想到这部很久以前的电影,翻出来以前的笔记看一下;之前看KK的"失控",感觉第一章就是黑客帝国开场的情景,一起重温一下吧:

我被关闭在密不透气的玻璃小屋里。在这里，我吸入的是自己呼出的气体，不过，在风扇的吹动下，空气依然清新。由众多的导管、线缆、植物和沼泽微生物构成的系统回收了我的尿液和粪便，并将其还原成水和食物供我食用。说真的，食物的味道不错，水也很好喝。

    昨夜，外面下了雪。玻璃小屋里却依然温暖、湿润而舒适。今天早上，厚厚的内窗上挂满了凝结的水珠。小屋里到处都是植物。大片大片的香蕉叶环绕在我的四周，那鲜亮的黄绿色暖人心房。纤细的青豆藤缠绕着，爬满了所有的墙面。屋内大约一半的植物都可食用，而我的每一顿大餐都来源于它们。

    这个小屋实际上是一个太空生活试验舱。我周边大气的循环再利用完全依赖于植物及其扎根的土壤，以及那些在树叶间穿来穿去的、嗡嗡作响的管道系统。不管是这些绿色植物，还是那些笨重的机器，单靠它们自己，都不足以保证我在这个空间的生存。确切地说，是阳光供养的生物和机油驱动的机械共同确保了我的生存。在这个小屋内，生物和人造物已经融合成为一个稳定的系统，其目的就是养育更高级的复杂物——当下而言，就是我。

    在这个千年临近结束的时候，发生在这个玻璃小屋里的事情，也正在地球上大规模地上演着——只不过不那么明晰。造化所生的自然王国和人类建造的人造国度正在融为一体。机器，正在生物化；而生物，正在工程化。

    这种趋势正验证着某些古老的隐喻——将机器比喻为生物，将生物比喻为机器。那些比喻由来已久，古老到第一台机器诞生之时。如今，那些久远的隐喻不再只是诗意的遐想，它们正在变为现实——一种积极有益的现实。
    人造与天生的联姻正是本书的主题。技术人员归纳总结了生命体和机器之间的逻辑规律，并一一应用于建造极度复杂的系统；他们正在如魔法师一般召唤出制造物和生命体并存的新奇装置。从某种程度上来说，是现有技术的局限性迫使生命与机械联姻，为我们提供有益的帮助。由于我们自己创造的这个世界变得过于复杂，我们不得不求助于自然世界以了解管理它的方法。这也就意味着，要想保证一切正常运转，我们最终制造出来的环境越机械化，可能越需要生物化。我们的未来是技术性的，但这并不意味着未来的世界一定会是灰色冰冷的钢铁世界。相反，我们的技术所引导的未来，朝向的正是一种新生物文明。

人类在创造复杂机械的进程中，一次又一次地回归自然去寻求指引。因此自然绝不仅仅是一个储量丰富的生物基因库，为我们保存一些尚未面世的救治未来疾患的药物。自然还是一个“文化基因库”，是一个创意工厂。在丛林中的每一个蚁丘中都隐藏着鲜活的、后工业时代的壮丽蓝图。那些飞鸟鸣虫，那些奇花异草，还有那些从这些生命中汲取了能量的原生态的人类文化，都值得我们去呵护——不为别的，就为那些它们所蕴含着的后现代隐喻。对新生物文明来说，摧毁一片草原，毁掉的不仅仅是一个生物基因库，还毁掉了一座蕴藏着各种启示、洞见和新生物文明模型的宝藏。
向机器中大规模地植入生物逻辑有可能使我们满怀敬畏。当人造与天生最终完全统一的时候，那些由我们制造出来的东西将会具备学习、适应、自我治愈，甚至是进化的能力。这是一种我们还很难想象的力量。数以百万计的生物机器汇聚在一起的智能，也许某天可以与人类自己的创新能力相匹敌。人类的创造力，也许总是属于那种华丽绚烂的类型，但还有另外一种类型的创造力值得一提——一种由无数默默无闻的“零件”通过永不停歇的工作而形成的缓慢而宽广的创造力。
在将生命的力量释放到我们所创造的机器中的同时，我们就丧失了对他们的控制。他们获得了野性，并因野性而获得一些意外和惊喜。之后，就是所有造物主都必须面对的两难窘境：他们将不再完全拥有自己最得意的创造物。
人造世界就像天然世界一样，很快就会具有自治力、适应力以及创造力，也随之失去我们的控制。但在我看来，这却是个最美妙的结局。

本文链接

[Erlang 0061] Erlang Code Snippet Ⅱ

2012-05-22T14:05:00Z

整理了最近一段时间记录的Erlang代码片段,还有大量简短的代码都已经整理在官方文档的PDF中.从开始学习Erlang,写的测试代码都会整理到PDF中,从这个习惯中得益匪浅.可以在PDF上做批注,图形的工具我用的是:PDF-XChange Viewer

上一次代码片段整理:[Erlang 0043] Erlang Code Snippet

record 转 proplist

%% @spec record_to_proplist(Record, Fields) -> proplist()
%% @doc calls record_to_proplist/3 with a default TypeKey of '__record'
record_to_proplist(Record, Fields) ->
record_to_proplist(Record, Fields, '__record').

%% @spec record_to_proplist(Record, Fields, TypeKey) -> proplist()
%% @doc Return a proplist of the given Record with each field in the
%% Fields list set as a key with the corresponding value in the Record.
%% TypeKey is the key that is used to store the record type
%% Fields should be obtained by calling record_info(fields, record_type)
%% where record_type is the record type of Record
record_to_proplist(Record, Fields, TypeKey)
when tuple_size(Record) - 1 =:= length(Fields) ->
lists:zip([TypeKey | Fields], tuple_to_list(Record)).

测试代码:

Eshell V5.9 (abort with ^G)
1> rd(person,{name,id,age}).
person
2> mochiweb_util:record_to_proplist(#person{}, record_info(fields, person)).
[{'__record',person},
{name,undefined},
{id,undefined},
{age,undefined}]
3> mochiweb_util:record_to_proplist(#person{age=12,name=zen,id=2396}, record_info(fields, person)).
[{'__record',person},{name,zen},{id,2396},{age,12}]
4>

保证应用程序已经启动

%% @spec ensure_started(App::atom()) -> ok
%% @doc Start the given App if it has not been started already.
ensure_started(App) ->
case application:start(App) of
ok ->
ok;
{error, {already_started, App}} ->
ok
end.

解析IP地址是否支持IP V6

%%判断是否支持IPV6
ipv6_supported() ->
case (catch inet:getaddr("localhost", inet6)) of
{ok, _Addr} ->
true;
{error, _} ->
false
end.

6> inet_parse:address("192.168.0.1").
{ok,{192,168,0,1}}

整形幂运算

%% @spec int_pow(X::integer(), N::integer()) -> Y::integer()
%% @doc Moderately efficient way to exponentiate integers.
%% int_pow(10, 2) = 100.
int_pow(_X, 0) ->
1;
int_pow(X, N) when N > 0 ->
int_pow(X, N, 1).

int_pow(X, N, R) when N < 2 ->
R * X;
int_pow(X, N, R) ->
int_pow(X * X, N bsr 1, case N band 1 of 1 -> R * X; 0 -> R end).

测试代码:

2> math:pow(2,3).
8.0
3> test:int_pow(2,3).
8

向上取整

%% @spec int_ceil(F::float()) -> integer()
%% @doc Return the ceiling of F as an integer. The ceiling is defined as
%% F when F == trunc(F);
%% trunc(F) when F < 0;
%% trunc(F) + 1 when F > 0.
int_ceil(X) ->
T = trunc(X),
case (X - T) of
Pos when Pos > 0 -> T + 1;
_ -> T
end.

在Erlang Shell中生成随机字符串

2> F=fun(Len, AllowedChars) -> lists:foldl(fun(_, Acc) -> [lists:nth(random:uniform(length(AllowedChars)), AllowedChars)] ++ Acc end, [], lists:seq(1, Len)) end.
#Fun<erl_eval.12.111823515>
3> F(4,"0123456789abcdefghijklmnopqrstuvwxyz").
"iyqf"
4> F(4,"0123456789abcdefghijklmnopqrstuvwxyz").
"owlb"
5> F(4,"0123456789abcdefghijklmnopqrstuvwxyz").
"75lh"
6> F(4,"0123456789abcdefghijklmnopqrstuvwxyz").
"7k5p"
7> F(4,"0123456789abcdefghijklmnopqrstuvwxyz").
"k0fg"

产生GUID

random_token() ->
Term = term_to_binary({node(), make_ref()}),
Digest = erlang:md5(Term),
binary_to_hex(Digest).

binary_to_hex(Bin) when is_binary(Bin) ->
[oct_to_hex(N) || <<N:4>> <= Bin].

oct_to_hex(0) -> $0;
oct_to_hex(1) -> $1;
oct_to_hex(2) -> $2;
oct_to_hex(3) -> $3;
oct_to_hex(4) -> $4;
oct_to_hex(5) -> $5;
oct_to_hex(6) -> $6;
oct_to_hex(7) -> $7;
oct_to_hex(8) -> $8;
oct_to_hex(9) -> $9;
oct_to_hex(10) -> $a;
oct_to_hex(11) -> $b;
oct_to_hex(12) -> $c;
oct_to_hex(13) -> $d;
oct_to_hex(14) -> $e;
oct_to_hex(15) -> $f.

测试代码:

1> test:random_token().
"db6f50cc40d54e338b0362c05d1b0295"
2> test:random_token().
"98b784e379dee8fa68ff863ba6c02cff"
3> test:random_token().
"7bc7db7cbab45025adaa02e28cc3972d"
4> test:random_token().
"0f794a8aed063184393bc5bb883f53bf"
5> test:random_token().
"4e18f2879d8d05e86445082bf4a46f19"

YA生成随机字符串

-define(SAFE_CHARS, {$a, $b, $c, $d, $e, $f, $g, $h, $i, $j, $k, $l, $m,
$n, $o, $p, $q, $r, $s, $t, $u, $v, $w, $x, $y, $z,
$A, $B, $C, $D, $E, $F, $G, $H, $I, $J, $K, $L, $M,
$N, $O, $P, $Q, $R, $S, $T, $U, $V, $W, $X, $Y, $Z,
$0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $_}).

rngchars(0) ->
"";
rngchars(N) ->
[rngchar() | rngchars(N - 1)].

rngchar() ->
rngchar(crypto:rand_uniform(0, tuple_size(?SAFE_CHARS))).

rngchar(C) ->
element(1 + C, ?SAFE_CHARS).

测试代码:

10> test:rngchars(6).
"vlrLnt"
11> test:rngchars(6).
"y_fvQ_"
12> test:rngchars(6).
"VpOg8w"
13> test:rngchars(6).
"YzTnps"

好代码,一次擦肩而过可能就再也见不到了哦

本文链接

[Erlang 0060] Joe Armstrong 论文《面向软件错误构建可靠的分布式系统》笔记

2012-05-20T07:14:00Z

周末读了两篇论文"On Designing and Deploying Internet-Scale Services"和Joe Armstrong的论文"面对软件错误构建可靠的分布式系统",这两篇论文实战内容相当多,整理笔记于此,备忘.

On Designing and Deploying Internet-Scale Services [HTML]

英文版"Making reliable distributed systems in the presence of sodware errors" [PDF]

中文版《面向软件错误构建可靠的分布式系统》 [PDF]

架构的定义

An architecture is the set of signiﬁcant decisions about the organization of a sodware system, the selection of the structural elements and their interfaces by which the system is composed, together with their behaviour as speciﬁed in the collaborations among those elements, the composition of these structural and behavioural elements into progressively larger subsystems, and the architectural style that guides this organization—these elements and their interfaces, their collaborations, and their composition.
Booch, Rumbaugh, and Jacobson [19]

在我接触到的架构定义中,Joe Armstrong论文中提到的定义相当务实,相当具有实践指导价值;首先和Martin Fowler等人对架构的共识是架构是一组系统组织方式的重要决策;决策包含系统有哪些构成元素,元素之间的接口,元素之间的协作方式;是一种把这些结构和行为元素构建为更大子系统的的合成方式;也是一种构建风格,在其指导下把元素,元素接口,元素协作和合成方式组织起来.

把架构的抽象概念映射到具体实践过程,可以从六个具体方面去考量,这时候我们已经从万里高空下降到陆地上了.

1．问题领域——我们的架构是为解决什么类型的问题而设计的?软件架构一定不是通用的,而是为解决某一类特定问题而设计的.缺少了关于用来解决哪类问题的描述的架构是不完整的.

笔记:同样的,缺少上下文描述的编程语言比较也只是一场关公战秦琼的乱斗而已;遇到过一些"技术牛人"身居要位,硬是把之前项目的设计方案强制应用在当前的项目上,这都不是偷懒那样简单,而是缺少对项目负责的专业态度.而更为糟糕的是一旦项目做失败了,就甩手走人,留下一个烂尾的工程留给团队;对团队的伤害,需要更长时间进行修复.

2．哲学—— 软件构造方法背后的原理是什么?架构的核心思想是什么?

笔记:在解决了问题或者完成了一个设计之后,我们一定要回顾一下解决问题的思路和设计的原理;具体的技术细节可能无法服用,但是思维方式和设计方法都是可以复用的.在阅读开源项目时,学习语言技巧是一方面,更为重要的是看这个项目是解决了什么问题,如何解决的,整体思路是怎样的.

3．软件构造指南——我们如何来规划一个系统?我们需要一个明确的软件构造指南集.我们的系统将由一个程序员团队来编写和维护——所以对所有的程序员和系统设计者来说,理解系统的架构和它的潜在哲学是很重要的.从实用性的角度来讲,这些知识以软件构造指南的方式表现出来更便于维持.一个完整的软件构造指南集包括编程规则集,例子程序和培训资料等等.

笔记:这个还是深有感触的,现在有一些项目比如PlayStation®Suite SDK把C#当作脚本使用,但是你会发现在这些项目里面虽然同是C#语言但无论是类库组织还是命名规范都是有自己的规则和风格的.

4．预先定义好的部件——以“从一组预先定义好的部件中选择”的方式进行设计远比“从头设计”的方式要来得容易.Erlang 的OTP库包含了一个完整的现成部件集(称之 behaviour 库),一些常用的系统都可以使用这些部件构建起来.例如 gen_server 这种 behaviour 就可以用来构建client-server 系统,gen_event 这种 behaviour 可以用来构建基于事件(event-based)的程序.

笔记:学习语言,其中一个重要的部分就是掌握这个语言所提供的类库;一方面是不重复造轮子,能够直接使用高质量类库;另一方面从类库中可以学习这种语言的编程风格.

5．描述方式——我们如何描述某一部件的接口?我们如何描述系统中两个部件之间的通信协议?我们如何来描述系统中的静态和动态结构?为了回答这些问题,我们将介绍一些专门的符号.其中一些用来描述程序的API,而其他的则用来描述协议和系统结构。

笔记:学习一种新知识,其中的门槛一方面是来自于概念,另一方面就是来自于符号系统;这两种都是对信息进行了简化,背后包含了较大的信息量,没有额外的信息支持难以理解.在最初接触一种新知识的时候,由于不了解这个领域的术语和概念,我们甚至都不能正确的描述遇到的问题.

6．配置方式——我们如何来启动,停止和配置我们的系统?我们可以在系统工作过程中进行重配置吗?

笔记:编程完成业务功能并没有万事大吉,还要考虑到配置,部署,这些问题的考虑时机甚至在设计之初就要考虑;针对不同的硬件设备,配置也有所不同;考虑到日常维护,还要准备一些给运维使用的脚本.

Erlang 故障隔离

为了构建出在软件存在错误的时候仍具有合理行为的可容错软件系统,Erlang的解决问题的思路是:

1.任务层次化,尽力完成顶层任务

2.如果完成任务过程中出现错误,如果无法纠正错误,就立即取消重新启动新的任务

这其中最本质的问题就是故障隔离,操作系统通过进程的概念实现了故障隔离,进程提供了保护区域,一个进程出错,不会影响到其他进程的运行.不同程序员编写的不同应用程序分别跑在不同的进程中; 一个应用程序的错误不会对系统中运行的其他应用程序产生副作用.这种选择当然满足了初步的要求.然而因为所有进程使用同一片 CPU,同一块物理内存,所以当不同进程争抢 CPU 资源或者使用大量内存的时候,还是可能对系统中的其他进程产生负面影响. 进程间的相互冲突程度取决于操作系统的设计特性.

Erlang进程和并发编程是语言的一部分,而不是由宿主操作系统提供的,Erlang应用程序是通过大量互相通信的并行进程构建起来的,这样做的原因是:

架构基础设施——我们可以用一组相互通信的进程组织起我们的系统,并定义出进程间消息传递的通道,我们就可以很方便地把系统划分成定义良好的子部件,并可以对这些子部件进行单独实现和测试.

巨大的潜在效率——设计成以许多独立的并行进程来实现的系统,可以很方便地实现在多处理器上,或者运行在分布式的处理器网络上. 注意这种效率的提升只是潜在的,只有当应用程序可以被分解成许多真正独立的任务时,才能产生实效.如果任务之间有很强的数据依赖,这种提升往往是不可能的.

故障隔离——没有共享数据的并发进程提供了一种强大的故障隔离方法.一个并发进程的软件错误不会影响到系统中其他进程的运行.

在并发的这三种用法中,前两条并不是其本质特性,可以由某种内置的调度程序通过在进程间提供不同的伪并行(pseudo-parallel)时分方式来获得.第三个特性对于编写可容错系统的软件来说,则是本质性的.每一项独立的活动都在一个完全独立的进程中来执行.这些进程没有共享数据,进程之间只通过消息传递的方式进行通信,这就限制了软件错误造成的影响.

一旦进程之间共享有任何公共资源,譬如内存,或指向内存的指针,或互斥体等等,一个进程中的一个软件错误破坏共享资源的可能性就存在.因为消除大型软件系统中的这类软件错误仍然是一个未解的难题,所以我认为构建大型的可靠系统的唯一现实的方法就是把系统分解成许多独立的并行进程, 并为监控和重启这些进程提供一些机制,

从某种意义上讲，操作系统提供了“被编程语言设计者遗忘了的东西”.但是在 Erlang 这样的编程语言中, 操作系统是几乎不需要的.OS真正提供给 Erlang的只是一些设备驱动程序,而 OS提供的诸如进程,消息传递,调度,内存管理等等机制都不需要.

面向并发编程语言COPL

COPL编写这样的并发程序相当容易,它有三个步骤:
1．从真实世界中的活动中识别出真正的并发活动
2．识别出并发活动之间的所有消息通道
3．写下能够在不同的消息通道中流通的所有消息

值得注意的是,COPL 提供的并发性一定是真正的并发性，因此以进程的形式存在的对象都是真正并发的,进程间的消息传递也是真正的异步消息,而不像许多面向对象语言中一样是通过远程过程调用(remote procedure call)来冒充.

Erlang世界观概览

• Everything is a process.
• Processes are strongly isolated.

• Process creation and destruction is a lightweight operation.

• Message passing is the only way for processes to interact.
• Processes have unique names.
• If you know the name of a process you can send it a message.
• Processes share no resources.
• Error handling is non-local.

• Processes do what they are supposed to do or fail.

思维导图

Erlang

View more documents from ligaoren

本文链接

[Erlang 0059] Erlang日期与时间处理

2012-05-17T14:49:00Z

在开发过程中,有两个概念是和地区区域相关的:字符编码和时间;编码和时间的规范演变过程中有文化的冲突有历史的遗留,是软件开发中充满人文气息的一角;关于字符编码我之前整理过一篇文章, [Erlang 0024]Erlang二进制数据处理这部分知识很有意思,特别是格列佛游记所引出的大端小端概念,妙趣横生;平时笔记中也零零散散记录了一些和时间处理相关的内容,今天按图索骥把相关的资料整理汇集于此.

首先把时间相关的概念解释一下:

有关时间的概念

GMT时间

格林尼治标准时间(Greenwich Mean Time ,GMT)是指位于英国伦敦郊区的皇家格林尼治天文台的标准时间，因为本初子午线被定义在通过那里的经线.自1924年2月5日开始，格林尼治天文台每隔一小时会向全世界发放调时信息.
理论上来说，格林尼治标准时间的正午是指当太阳横穿格林尼治子午线时的时间.由于地球在它的椭圆轨道里的运动速度不均匀,这个时刻可能与实际的太阳时有误差,最大误差达16分钟.由于地球每天的自转是有些不规则的，而且正在缓慢减速,因此格林尼治时间已经不再被作为标准时间使用.现在的标准时间，是由原子钟报时的协调世界时(UTC).

UTC时间

UTC时间是 Universal Time, Coordinated的缩写;中文名为协调世界时,又称世界标准时间或世界协调时间;这个略显怪异的名字来由是这样的:国际电信联盟希望协调世界时能够在所有语言有单一的缩写.英语和法语区的人同时希望各自的语言缩写,CUT和TUC,能够成为国际标准.结果最后妥协使用UTC.

这套时间系统被应用于许多互联网和万维网的标准中,例如,网络时间协议就是协调世界时在互联网中使用的一种方式.在军事和航空中，协调世界时区会使用“Z”来表示.

在中国大陆,港澳台的本地时间比UTC快8小时，就会写作UTC+8，俗称东8区。如果是在本地时间比UTC时间慢的地区，例如夏威夷的时间是比UTC时间慢10小时，就会写作UTC-10，并俗称西10区。

时区
理论时区以被15整除的子午线为中心,向东西两侧延伸7.5度,即每15°划分一个时区,这是理论时区.理论时区的时间采用其中央经线(或标准经线)的地方时.所以每差一个时区,区时相差一个小时,相差多少个时区,就相差多少个小时.东边的时区比西边的时区时间来得早.为了避免日期的紊乱，提出国际日期变更线的概念。为了避开国界线，有的时区的形状并不规则，而且比较大的国家以国家内部行政分界线为时区界线，这是实际时区，即法定时区.

所有的时区都相对于UTC时设定.

UNIX时间戳

UNIX时间或称POSIX时间是UNIX或类UNIX系统使用的时间表示方式:从UTC时1970年1月1日0时0分0秒起至现在的总秒数.

2038年问题:现时大部分使用UNIX的系统都是32位元的,即它们会以32位二进制数字表示时间.但是它们最多只能表示至协调世界时间2038年1月19日3时14分07秒(二进制：01111111 11111111 11111111 11111111),在下一秒二进制数字会是10000000 00000000 00000000 00000000，这是负数，因此各系统会把时间误解作1901年12月13日20时45分52秒（亦有说回归到1970年）。这时可能会令软件发生问题，导致系统瘫痪。

目前解决方案是把系统由32位元转为64位元系统。在64位系统下，此时间最多可以表示到292,277,026,596年12月4日15时30分08秒。

是不是想到了很久以前的千年虫问题?

公历 Gregorian calendar

公历是现在国际通用的历法,又称格列历,通称阳历.“阳历”又名“太阳历”,系以地球绕行太阳一周为一年,为西方各国所通用,故又名“西历”.公历定义了月,闰月等计算方式;能够废掉帝号纪年法,是文化上的一大进步.除了帝号纪年我国还有干支纪年法,这个很有意思,即把十天干(甲,乙,丙,丁,戊,己,庚,辛,壬,癸)和十二地支(子,丑,寅,卯,辰,巳,午,未,申,酉,戌,亥)分别组合起来,共配成六十组,用来表示年月日的次序,周而复始,循环使用.

2012年是壬辰年,呵呵,明白为什么好多人选择在今年生孩子了吧?

夏令时 DST

电影《国家宝藏》里面有一个情节就是三个人看到美元背后的4:10以为来不及了,但是意识到夏时令之后,发现还有一个小时的时间,一切还来得及;那么什么是夏令时呢?

夏时制(Daylight Saving Time:DST)又称“日光节约时制”和“夏令时间”,是一种为节约能源而人为规定地方时间的制度,在这一制度实行期间所采用的统一时间称为“夏令时间”.一般在天亮早的夏季人为将时间提前一小时,可以使人早起早睡,减少照明量,以充分利用光照资源,从而节约照明用电.各个采纳夏时制的国家具体规定不同.目前全世界有近110个国家每年要实行夏令时. 自2011年3月27日开始俄罗斯永久使用夏令时,把时间拨快一小时,不再调回.

据称最早有夏令时构思的是本杰明·富兰克林夏令时的提出者本杰明·富兰克林（被印在100美元钞票上的人物）,他在任美国驻法国大使期间,由于习惯于当时美国农村贵族的早睡早起生活,早上散步时看到法国人10点才起床,夜生活过到深夜.于是他在1784年给《巴黎杂志》的编辑写了一封信,信上说法国人的生活习惯浪费了大好的阳光,建议他们早睡早起,说每年可以节约6千4百万磅蜡烛.但他当时并没有建议实行夏令时,只是建议人们应该早睡早起.直到1907年,一位英国建筑师威廉·维莱特（William Willett）才正式向英国议会提出夏时制的构思,主要是为了节省能源和提供更多的时间用来训练士兵,但议会经过辩论没有采纳.由于名声不及本杰明·富兰克林,所以人们很多都将本杰明·富兰克林当为夏时制的发明者而忽略了威廉·维莱特.

中国曾在1986-1991年推行夏时制,后停止原因是:1.区域辽阔大部分地区都没有必要实行2.中国大多数的平民都已习惯北京时间,实行夏令时对于他们来说难以接受,认为多此一举.3.夏时制使铁路和航班需要每年修改时间表,造成麻烦和不便.

公元纪元

"公历纪元"是国际通行的纪年体系.以传说中耶稣基督的生年为公历元年,产生于基督教盛行的六世纪,当时，为了扩大教会的统治势力,神父们把任何事情都附会在基督教上.

日期时间格式化表示

文化差异下日期的表示方式也各有不同,就英语而言英联邦国家和美国就在日期表示惯用法上有不同;要想流畅的沟通就要有日期时间的表示规范,ISO 8601对日期时间表示做了详细的描述,可以看一下维基百科的简介.

Erlang Calendar

了解了这些之后,我们回归到技术之上,看一下Erlang中有关时间的计算,这基本上集中在calendar模块. 平时我们调用的erlang:now()得到的是从 00:00 GMT, January 1, 1970起经过的时间,结果构成为:{MegaSecs, Secs, MicroSecs},对于公历计时的起点Erlang回溯到0年.若计算时间差,需转成世界时间之后再进行计算;时间运算基于下面的规则:

erlang:now() Returns the tuple {MegaSecs, Secs, MicroSecs} which is the elapsed time since 00:00 GMT, January 1, 1970 (zero hour) on the assumption that the underlying OS supports this. Otherwise, some other point in time is chosen. It is also guaranteed that subsequent calls to this BIF returns continuously increasing values. Hence, the return value from now() can be used to generate unique time-stamps, and if it is called in a tight loop on a fast machine the time of the node can become skewed.

It can only be used to check the local time of day if the time-zone info of the underlying operating system is properly configured.

• there are 86400 seconds in a day
• there are 365 days in an ordinary year
• there are 366 days in a leap year
• there are 1461 days in a 4 year period
• there are 36524 days in a 100 year period
• there are 146097 days in a 400 year period
• there are 719528 days between Jan 1, 0 and Jan 1, 1970.

以及闰年规则:

• Y is divisible by 4, but not by 100; or
• Y is divisible by 400.

calendar模块已经废弃或者不建议使用的模块:

local_time_to_universal_time({Date1, Time1}) -> {Date2, Time2}

time_difference(T1, T2) -> {Days, Time}

常用代码

erlang:now转本地时间

15> calendar:now_to_local_time(erlang:now()).
{{2012,5,17},{14,32,6}}

erlang:now转世界时间

16> calendar:now_to_universal_time(erlang:now()).
{{2012,5,17},{6,33,2}}
17>

验证合法的日期

20> calendar:valid_date({0,0,0}).
false
21> calendar:valid_date({0,1,0}).
false
22> calendar:valid_date({0,1,1}).

true

26> calendar:valid_date(90,1,10).

true

获得本地时间年月日小时分秒

1> {{Year,Month,Day},{Hour,Min,Second}}=calendar:local_time().
{{2012,5,17},{14,13,14}}
2> b().
Day = 17
Hour = 14
Min = 13
Month = 5
Second = 14
Year = 2012
ok

获得世界时间

3> calendar:universal_time().
{{2012,5,17},{6,16,27}}

本地时间转换到世界时间

10> calendar:local_time_to_universal_time_dst({{2012,3,12},{3,23,12}}).
[{{2012,3,11},{19,23,12}}]
11> calendar:local_time_to_universal_time_dst({{2012,3,12},{4,23,12}}).
[{{2012,3,11},{20,23,12}}]
12> calendar:local_time_to_universal_time_dst({{2012,3,12},{5,23,12}}).
[{{2012,3,11},{21,23,12}}]
13> calendar:local_time_to_universal_time_dst({{2012,3,12},{15,23,12}}).
[{{2012,3,12},{7,23,12}}]
14> calendar:local_time_to_universal_time_dst({{2012,3,12},{16,23,12}}).
[{{2012,3,12},{8,23,12}}]

世界时间转本地时间

12> calendar:universal_time_to_local_time({{2012,3,12},{3,23,12}}).
{{2012,3,12},{11,23,12}}
13> calendar:universal_time_to_local_time({{2012,3,12},{5,23,12}}).
{{2012,3,12},{13,23,12}}
14> calendar:universal_time_to_local_time({{2012,3,12},{20,23,12}}).
{{2012,3,13},{4,23,12}}

计算是星期几

13> calendar:day_of_the_week(1984,5,15).
2
14> calendar:day_of_the_week(2012,5,17).
4

计算是否闰年

5> calendar:is_leap_year(1990).
false
6> calendar:is_leap_year(2000).
true

计算某年某月有多少天

7> calendar:last_day_of_the_month(2000,2).
29
8> calendar:last_day_of_the_month(2000,3).
31
9> calendar:last_day_of_the_month(1990,2).
28

秒转时间

4> calendar:now_to_datetime(erlang:now()).
{{2012,5,17},{5,41,24}}
5> calendar:seconds_to_daystime(87400).
{1,{0,16,40}}
6> calendar:seconds_to_daystime(97400).
{1,{3,3,20}}
7> calendar:seconds_to_daystime(80400).
{0,{22,20,0}}

如果没有超过一天可以使用

8> calendar:seconds_to_time(80400).
{22,20,0}
9> calendar:seconds_to_time(86400).
** exception error: no function clause matching calendar:seconds_to_time(86400) (calendar.erl, line 357)

时间转到秒

10> calendar:time_to_seconds({22,20,0}).
80400
11> calendar:time_to_seconds({1,{22,20,0}}).
** exception error: no function clause matching calendar:time_to_seconds({1,{22,20,0}}) (calendar.erl, line 390)

计算Unix Timestamp

timestamp() ->
calendar:datetime_to_gregorian_seconds(erlang:universaltime()).

或者:

timestamp() ->
{M, S, _} = erlang:now(),
M * 1000000 + S.

日期时间格式化

16> test:now_to_local_string(erlang:now()).
"2012-05-17T16:14:42.195510+08:00"
17> test:now_to_utc_string(erlang:now()).
"2012-05-17T08:15:26.907466Z"
18> test:timestamp_to_iso(calendar:local_time()).
"20120517T16:27:18"

下面的代码实现上面的时间格式化效果:

timestamp_to_iso({{Year, Month, Day}, {Hour, Minute, Second}}) ->
lists:flatten(
io_lib:format("~4..0w~2..0w~2..0wT~2..0w:~2..0w:~2..0w",
[Year, Month, Day, Hour, Minute, Second])).

now_to_utc_string({MegaSecs, Secs, MicroSecs}) ->
{{Year, Month, Day}, {Hour, Minute, Second}} =
calendar:now_to_universal_time({MegaSecs, Secs, MicroSecs}),
lists:flatten(
io_lib:format("~4..0w-~2..0w-~2..0wT~2..0w:~2..0w:~2..0w.~6..0wZ",
[Year, Month, Day, Hour, Minute, Second, MicroSecs])).

now_to_local_string({MegaSecs, Secs, MicroSecs}) ->
LocalTime = calendar:now_to_local_time({MegaSecs, Secs, MicroSecs}),
UTCTime = calendar:now_to_universal_time({MegaSecs, Secs, MicroSecs}),
Seconds = calendar:datetime_to_gregorian_seconds(LocalTime) -
calendar:datetime_to_gregorian_seconds(UTCTime),
{{H, M, _}, Sign} = if
Seconds < 0 ->
{calendar:seconds_to_time(-Seconds), "-"};
true ->
{calendar:seconds_to_time(Seconds), "+"}
end,
{{Year, Month, Day}, {Hour, Minute, Second}} = LocalTime,
lists:flatten(
io_lib:format("~4..0w-~2..0w-~2..0wT~2..0w:~2..0w:~2..0w.~6..0w~s~2..0w:~2..0w",
[Year, Month, Day, Hour, Minute, Second, MicroSecs, Sign, H, M])).

% yyyy-mm-ddThh:mm:ss[.sss]{Z|{+|-}hh:mm} -> {MegaSecs, Secs, MicroSecs}
datetime_string_to_timestamp(TimeStr) ->
case catch parse_datetime(TimeStr) of
{'EXIT', _Err} ->
undefined;
TimeStamp ->
TimeStamp
end.

parse_datetime(TimeStr) ->
[Date, Time] = string:tokens(TimeStr, "T"),
D = parse_date(Date),
{T, MS, TZH, TZM} = parse_time(Time),
S = calendar:datetime_to_gregorian_seconds({D, T}),
S1 = calendar:datetime_to_gregorian_seconds({{1970, 1, 1}, {0, 0, 0}}),
Seconds = (S - S1) - TZH * 60 * 60 - TZM * 60,
{Seconds div 1000000, Seconds rem 1000000, MS}.

% yyyy-mm-dd
parse_date(Date) ->
[Y, M, D] = string:tokens(Date, "-"),
Date1 = {list_to_integer(Y), list_to_integer(M), list_to_integer(D)},
case calendar:valid_date(Date1) of
true ->
Date1;
_ ->
false
end.

% hh:mm:ss[.sss]TZD
parse_time(Time) ->
case string:str(Time, "Z") of
0 ->
parse_time_with_timezone(Time);
_ ->
[T | _] = string:tokens(Time, "Z"),
{TT, MS} = parse_time1(T),
{TT, MS, 0, 0}
end.

parse_time_with_timezone(Time) ->
case string:str(Time, "+") of
0 ->
case string:str(Time, "-") of
0 ->
false;
_ ->
parse_time_with_timezone(Time, "-")
end;
_ ->
parse_time_with_timezone(Time, "+")
end.

parse_time_with_timezone(Time, Delim) ->
[T, TZ] = string:tokens(Time, Delim),
{TZH, TZM} = parse_timezone(TZ),
{TT, MS} = parse_time1(T),
case Delim of
"-" ->
{TT, MS, -TZH, -TZM};
"+" ->
{TT, MS, TZH, TZM}
end.

parse_timezone(TZ) ->
[H, M] = string:tokens(TZ, ":"),
{[H1, M1], true} = check_list([{H, 12}, {M, 60}]),
{H1, M1}.

parse_time1(Time) ->
[HMS | T] = string:tokens(Time, "."),
MS = case T of
[] ->
0;
[Val] ->
list_to_integer(string:left(Val, 6, $0))
end,
[H, M, S] = string:tokens(HMS, ":"),
{[H1, M1, S1], true} = check_list([{H, 24}, {M, 60}, {S, 60}]),
{{H1, M1, S1}, MS}.

check_list(List) ->
lists:mapfoldl(
fun({L, N}, B)->
V = list_to_integer(L),
if
(V >= 0) and (V =< N) ->
{V, B};
true ->
{false, false}
end
end, true, List).

构造日期字符串

% a function to format date/time properly (e.g. 09 instead of 9)
return_2columns(X) ->
case length(X) of
1 ->
"0" ++ X;
_ ->
X
end.

%%% 显然这里可以直接使用 io_lib:format("~2..0B", [X])

% returns date/time as a properly formatted string (e.g. "01-01-2000 12:12:12")
get_current_time() ->
{{Y, M, D}, {H, Mi, S}} = calendar:local_time(),
L = lists:map(fun(X) ->
X2=integer_to_list(X),
return_2columns(X2)
end,
[Y, M, D, H, Mi, S]
),
[Y2, M2, D2, H2, Mi2, S2] = L,
Y2 ++ "-" ++ M2 ++ "-" ++ D2 ++ " " ++ H2 ++ ":" ++ Mi2 ++ ":" ++ S2.

当然下面的代码段也很有可能被用到:

day(1) -> "Mon";
day(2) -> "Tue";
day(3) -> "Wed";
day(4) -> "Thu";
day(5) -> "Fri";
day(6) -> "Sat";
day(7) -> "Sun".

month_to_list(1) -> "Jan";
month_to_list(2) -> "Feb";
month_to_list(3) -> "Mar";
month_to_list(4) -> "Apr";
month_to_list(5) -> "May";
month_to_list(6) -> "Jun";
month_to_list(7) -> "Jul";
month_to_list(8) -> "Aug";
month_to_list(9) -> "Sep";
month_to_list(10) -> "Oct";
month_to_list(11) -> "Nov";
month_to_list(12) -> "Dec".

list_to_month("Jan") -> 1;
list_to_month("Feb") -> 2;
list_to_month("Mar") -> 3;
list_to_month("Apr") -> 4;
list_to_month("May") -> 5;
list_to_month("Jun") -> 6;
list_to_month("Jul") -> 7;
list_to_month("Aug") -> 8;
list_to_month("Sep") -> 9;
list_to_month("Oct") -> 10;
list_to_month("Nov") -> 11;
list_to_month("Dec") -> 12.

Note:天(Day)这个概念是和时区有关的,使用Unix时间戳计算的时候要考虑到时区差异,比如两个Unix时间戳是否在同一天,一天的起始时间的时间戳,等等;软件多语言版本的时候这个问题特别要关注

晚安 !

[2] 国家授时中心网络服务器时间发布 http://www.time.ac.cn/stime.asp

[3] GMT时间 http://zh.wikipedia.org/wiki/GMT

[4] UTC时间 http://zh.wikipedia.org/wiki/%E5%8D%94%E8%AA%BF%E4%B8%96%E7%95%8C%E6%99%82

[5] UNIX时间 http://zh.wikipedia.org/wiki/UNIX%E6%97%B6%E9%97%B4

[6] 千年虫问题 http://zh.wikipedia.org/wiki/%E5%8D%83%E5%B9%B4%E8%99%AB

[7] 公历 http://en.wikipedia.org/wiki/Gregorian_calendar

[8] 夏时制 http://zh.wikipedia.org/wiki/%E5%A4%8F%E6%97%B6%E5%88%B6

[9] 日期格式化 http://en.wikipedia.org/wiki/ISO_8601

[10] $100 http://zh.wikipedia.org/wiki/100%E7%BE%8E%E5%85%83%E7%BA%B8%E5%B8%81

本文链接

Linux/Unix设计思想读书笔记

2012-05-08T16:04:00Z

初识Erlang时感觉怪异的方法命名,写Shell脚本时的恍然大悟，原来一切源头都在《Linux/Unix 设计思想》

下面是我的读书笔记,按照我自己的理解重新梳理了一下:

读书笔记

尽快建立原型,寻找90%的解决方案，先运行起来再说
保持程序的小巧，一次做好一件事情
站在巨人的肩膀上在原有软件的基础上进行加强和扩展
各部分之和大于整体
高效率和可移植性之间往往存在取舍
层次化思考

交互界面往往让我们距离问题的本质更远
尽可能自动化
让每一个程序都成为过滤器所有程序的共有特征就是修改数据而不创造数据
使用小写字母，并保持简短

不过书中类似于下面的文字请自行甄别,判断:

也许我们应该提及，大众汽车公司曾经围绕着"小即是美"的概念开展了一次成功的汽车营销活动，并借此销售了数以百万计的汽车；或者想一想主流Unix供应商Sun公司的事例，它的商业战略基于"集中所有资源推出最好的拳头产品"这一思想，或者换句话说，也就是"只做好一件事"的理念。那么，人们对于掌上电脑、无线网络访问和手持视频的兴趣是否与可移植性有关呢？

对操作系统来说，华丽的图形界面没有任何意义，除非它能为用户提供所需要的功能。换句话说，内容为王。

人们之所以涌向互联网和万维网是为了获得文本内容。

参考资料:
[1] 《思维之火》之如何识破他在扯蛋（上）
[2] 《思维之火》之如何识破他在扯蛋（中）
[3] 《思维之火》之如何识破他在扯蛋（下）
[4] 《思维之火》之如何成为一个自由的思考者

本文链接

[Erlang 0058] Erlang Function调用效率

2012-05-06T00:51:00Z

Erlang方法调用有m:f(a),M:F(a),fun,f(),apply/3几种方法,调用效率如何呢?《Erlang/OTP in Action》一书中有一个总结我们看下：

即模块内调用和模块间的方法调用速度差异不大;要关注一下元编程方式调用(apply调用)要慢的多,除此之外除非是在性能要求特别高的场景否则不必过于在意这点性能差异;这个在官方文档中有大致相同的结果:

Here is an intentionally rough guide to the relative costs of different kinds of calls. It is based on benchmark figures run on Solaris/Sparc:
Calls to local or external functions (foo(), m:foo()) are the fastest kind of calls.
Calling or applying a fun (Fun(), apply(Fun, [])) is about three times as expensive as calling a local function.
Applying an exported function (Mod:Name(), apply(Mod, Name, [])) is about twice as expensive as calling a fun, or about six times as expensive as calling a local function.
DocLink: http://www.erlang.org/doc/efficiency_guide/functions.html

概念明确

对于上面的结论,明确一下上面表中跨模块调用这个概念在Erlang中常用的表达方式:

In the first form of function calls, ExprM:ExprF(Expr1,...,ExprN), each of ExprM and ExprF must be an atom or an expression that evaluates to an atom. The function is said to be called by using the fully qualified function name. This is often referred to as a remote or external function call.
DocLink: http://www.erlang.org/doc/reference_manual/expressions.html#id76190

速度差异因何而来

fun包含或者间接包含了实现了该方法的指针调用不涉及hash-table的查询,apply/3必须要在HashTable中查找funtion对应的Code实现，所以通常比直接调用或者fun调用速度要慢.

编译时优化

在参数个数确定的时候，apply/3的调用会在编译时被优化为m:f(a)形式的external function call.通过一段代码看一下：

a() ->
M=erlang,
F=now,
apply(M,F,[]).

b(M,F,A) ->
apply(M,F,A).

c(M,F) ->
apply(M,F,[a,b,c]).

d(M)->
apply(M,do_something,[]).

我们添加to_core参数,看一下编译出来的Core Erlang代码:

'a'/0 =
%% Line 33
fun () ->
%% Line 36
call 'erlang':'now'
()
'b'/3 =
%% Line 38
fun (_cor2,_cor1,_cor0) ->
%% Line 39
call 'erlang':'apply'
(_cor2, _cor1, _cor0)
'c'/2 =
%% Line 41
fun (_cor1,_cor0) ->
%% Line 42
call _cor1:_cor0
('a', 'b', 'c')
'd'/1 =
%% Line 44
fun (_cor0) ->
%% Line 45
call _cor0:'do_something'
()

可以看到在参数个数确定的情况下,apply/3的调用已经都被优化为mfa的调用方式.

Erlang代码加载自后的调用方式细节需要找资料深入研究一下,估计是在Code Server相关的代码中,待续

本文链接

[Erlang 0057] Erlang 排错利器: Erlang Crash Dump Viewer

2012-04-28T10:02:00Z

Erlang Crash Dump Viewer真的是排错的天兵神器,还记得我们之前曾经讨论过[Erlang 0013]抓取Erlang进程运行时信息 [Erlang 0012]Erlang Process input queue ,下面是我梳理的"How to interpret the Erlang crash dumps"的文档;

官方地址是:http://www.erlang.org/doc/apps/erts/crash_dump.html

思维导图地址:http://d.yun.io/Q5fY7b

PDF地址:http://d.yun.io/Q5fY7b

Erlang crash dump

View more documents from ligaoren

本文链接

[Erlang 0056] 用fun在Erlang Shell中编写尾递归 Ⅱ

2012-04-28T04:08:00Z

之前研究了一个问题"[Erlang 0050]用fun在Erlang Shell中编写尾递归",一直对这个问题保持着关注;最近在搜索引擎里找到同一个问题,题目足够清晰calling fun() from fun() 它提供了另外一种解决解决方案:Y-combinator!

%%That's easy, you need the Y-combinator!

y(M) ->
G = fun (F) -> M(fun(A) -> (F(F))(A) end) end,
G(G).

and then you define you fun with a fun wrapper like so:

Fac -> fun (F) ->
fun (0) -> 1;
(N) -> N * F(N-1)
end
end.

and call it like:

(y(Fac))(5)
120

不错吧,不过我们的目标是在shell里面直接实现尾递归,所以要动手简单改造一下

Eshell V5.9 (abort with ^G)
1> Y=fun(F) ->
1> G = fun(T) ->
1> F(fun(X) -> (T(T))(X) end)
1> end,
1> G(G) end.
#Fun<erl_eval.6.111823515>
2>
2> Fac = fun (F) ->
2> fun (0) -> 1;
2> (N) -> N * F(N-1)
2> end
2> end.
#Fun<erl_eval.6.111823515>
3>
3> (Y(Fac))(5).
120
4> Fib = fun(F) ->
4> fun(0) -> 0;
4> (1) -> 1;
4> (N) -> F(N-1) + F(N-2)
4> end
4> end.
#Fun<erl_eval.6.111823515>
5>
5> (Y(Fib))(8).
21
6>

问题还没有结束,对于两个参数的怎么办呢?Y函数比较直观,可以修改为:

6> Y2=fun(F) ->
6> G = fun(T) ->
6> F(fun(Y, Z) -> (T(T))(Y, Z) end)
6> end,
6> G(G) end.
#Fun<erl_eval.6.111823515>
7> Func2=fun(F)->
7> fun(X,Y) when Y<1000 ->io:format("~p,",[X+Y]), F(Y,X+Y);
7> (X,Y) -> done
7> end
7> end.
#Fun<erl_eval.6.111823515>
8>
8> (Y2(Func2))(0,1).
1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,done

当然多个参数我们可以使用apply mfa的方式来处理多个参数的情况.同时Y方法也可以放在user_default里面方便后续使用.实践之后说一点理论吧,这种解决方案是使用了Y combinator可能最近你已经频繁接触到这个名字,比如在IT新闻,比如在<<黑客与画家>>,它本身是一个数学概念,那么我们从维基百科开始:

英文维基

Fixed-point combinator http://en.wikipedia.org/wiki/Fixed-point_combinator

Y combinator: http://rosettacode.org/wiki/Y_combinator

中文维基

不动点组合子 http://zh.wikipedia.org/wiki/%E4%B8%8D%E5%8A%A8%E7%82%B9%E7%BB%84%E5%90%88%E5%AD%90

不动点 http://zh.wikipedia.org/wiki/%E4%B8%8D%E5%8A%A8%E7%82%B9

λ演算 http://zh.wikipedia.org/wiki/%E6%97%A0%E7%B1%BB%E5%9E%8B_lambda_%E6%BC%94%E7%AE%97

我们理顺一下里面的逻辑关系,从不动点开始:

在数学中，函数的不动点或定点是指被这个函数映射到其自身一个点.例如,定义在实数上的函数f,f(x)=x²-3x+4则2是函数f的一个不动点，因为f(2)=2.也不是每一个函数都具有不动点。例如定义在实数上的函数,f(x)=x+1就没有不动点。因为对于任意的实数，x永远不会等于x+1。用画图的话来说，不动点意味着点(x,f(x))在直线y=x上，或者换句话说，函数f的图像与那根直线有共点。上例f(x)=x+1的情况是，这个函数的图像与那根直线是一对平行线.

我用wolframalpha.com绘制了f(x)=x²-3x+4的函数图:

接下来我们看不动点组合子(Fixed-point combinator,或不动点算子)是计算其他函数的一个不动点的高阶函数.函数 f 的不动点是一个值 x 使得 f(x) = x.例如,0 和 1 是函数 f(x) = x2 的不动点,因为 02 = 0 而 12 = 1.鉴于一阶函数(在简单值比如整数上的函数)的不动点是个一阶值,高阶函数 f 的不动点是另一个函数 g 使得 f(g) = g.那么,不动点算子是任何函数 fix 使得对于任何函数 f 都有f(fix(f)) = fix(f).不动点组合子允许定义匿名的递归函数.

然后接下来是Y combinator(Y组合子)在无类型 lambda 演算中众所周知的(可能是最简单的)不动点组合子叫做 Y 组合子.它是 Haskell B. Curry 发现的,定义为

Y = λf.(λx.f (x x)) (λx.f (x x)) %%用一个例子函数g来展开它，我们可以看到上面这个函数是怎么成为一个不动点组合子的

Y g = (λf.(λx . f (x x)) (λx . f (x x))) g

Y g = (λx. g (x x)) (λx . g (x x)) %%λf 的 β-归约 - 应用主函数于 g

Y g = (λy. g (y y)) (λx . g (x x)) %%α-转换 - 重命名约束变量

Y g = g ((λx. g (x x)) (λx . g (x x))) %%λy 的 β-归约 - 应用左侧函数于右侧函数

Y g = g (Y g) %%Y 的定义

这个!?在编程语言里面怎么实现呢?看一下http://rosettacode.org/wiki/Y_combinator 这里罗列了大多数语言对Y combinator的实现,比如C#版本:

delegate Func<int , int > Recursive(Recursive recursive);
void Main()
{
        Func<Func<Func<int, int>, Func< int, int>>, Func< int, int>> Y =
            f => ((Recursive)(g => (f(x => g(g)(x)))))((Recursive)(g => f(x => g(g)(x))));
        var fac = Y(f => x => x < 2 ? 1 : x * f(x - 1));
        var fib = Y(f => x => x < 2 ? x : f(x - 1) + f(x - 2));

        Console.WriteLine(fac(6));
        Console.WriteLine(fib(6));
}

不过注意一下Erlang版本的实现,上面提供了另外一种实现方式(只不过在下面这种实现中,怎么使用多个参数呢?):

Eshell V5.9 (abort with ^G)
1> Y = fun(M) -> (fun(X) -> X(X) end)(fun (F) -> M(fun(A) -> (F(F))(A) end) end) end.
#Fun<erl_eval.6.111823515>
2> Fac = fun (F) ->
2> fun (0) -> 1;
2> (N) -> N * F(N-1)
2> end
2> end.
#Fun<erl_eval.6.111823515>
3> (Y(Fac))(5).
120
4>
4> Fib = fun(F) ->
4> fun(0) -> 0;
4> (1) -> 1;
4> (N) -> F(N-1) + F(N-2)
4> end
4> end.
#Fun<erl_eval.6.111823515>
5> (Y(Fib))(8).

沿着Y Combinator这个线索,可以找到更多的资料,
[PDF] The Why of Y - Dreamsongs

[1] Y Combinator in Erlang

[2] Deriving the Y Combinator in Erlang (原文已经被墙,这是我拷贝出来的副本)

本文链接

Disk is Tape, Flash is Disk

2012-04-27T16:04:00Z

今天遇到一副来自Google的图罗列了常见操作的时间损耗,见高清大图:

这张图让我想到之前在使用Redis时看到Jim Gray那句被坊间流传许久的话:"Tape is Dead, Disk is Tape, Flash is Disk, RAM Locality is King".(磁带已死,磁盘是新磁带,闪存是新磁盘,随机存储器局部性是为王道.) 这句话的原始出处在此: http://www.signallake.com/innovation/Flash_is_Good.pdf

这里有一篇中文解读: http://www.infoq.com/cn/news/2008/07/ram-is-disk

Jim Gray在过去40年中对技术发展有过巨大的贡献，“内存是新的硬盘，硬盘是新的磁带”是他的名言。“实时”Web应用不断涌现，达到海量规模的系统越来越多，这种后浪推前浪的发展模式对软硬件又有何影响？

Tim Bray早在网格计算成为热门话题之前，就讨论过以RAM和网络为中心的硬件结构的优势，可以用这种硬件建立比磁盘集群速度更快的RAM集群。
对于数据的随机访问，内存的速度比硬盘高几个数量级（即使是最高端的磁盘存储系统也只是勉强达到1,000次寻道/秒）。其次，随着数据中心的网络速度提高，访问内存的成本更进一步降低。通过网络访问另一台机器的内存比访问磁盘成本更低。就在我写下这段话的时候，Sun的 Infiniband产品线中有一款具备9个全互联非阻塞端口交换机，每个端口的速度可以达到30Gbit/sec！Voltaire产品的端口甚至更多；简直不敢想象。（如果你想了解这类超高性能网络的最新进展，请关注Andreas Bechtolsheim在Standford开设的课程。）
Tim还指出Jim Gray的名言中后半句所阐述的真理：“对于随机访问，硬盘慢得不可忍受；但如果你把硬盘当成磁带来用，它吞吐连续数据的速率令人震惊；它天生适合用来给以RAM为主的应用做日志（logging and journaling）。”

时间闪到几年之后的今天，我们发现硬件的发展趋势在RAM和网络领域势头不减，而在硬盘领域则止步不前。Bill McColl提到用于并行计算的海量内存系统已经出现：

内存是新的硬盘！硬盘速度提高缓慢，内存芯片容量指数上升，in-memory软件架构有望给各类数据密集的应用带来数量级的性能提升。小型机架服务器（1U、2U）很快就会具备T字节、甚至更大量的内存，这将会改变服务器架构中内存和硬盘之间的平衡。硬盘将成为新的磁带，像磁带一样作为顺序存储介质使用（硬盘的顺序访问相当快速），而不再是随机存储介质（非常慢）。这里面有着大量的机会，新产品的性能有望提高10倍、100倍。

Dare Obsanjo指出如果不把这句真言当回事，会带来什么样的恶劣后果—— 也就是Twitter正面临的麻烦。论及Twitter的内容管理，Obsanjo说，“如果一个设计只是简单地反映了问题描述，你去实现它就会落入磁盘 I/O的地狱。不管你用Ruby on Rails、Cobol on Cogs、C++还是手写汇编都一样，读写负载照样会害死你。”换言之，应该把随机操作推给RAM，只给硬盘留下顺序操作。

下面是来自slideshare的两份资料(不显示多刷几遍):

Redis -- Memory as the New Disk
View more presentations from Tim Lossen

What every data programmer needs to know about disks
View more PowerPoint from iammutex

深入理解计算机系统

回顾一下计算机的经典教材《深入理解计算机系统》中对高速缓存的讲解,书中是从最简单的hello程序切入的:

hello程序的机器指令最初是存放在磁盘上的,当程序加载时,它们被复制到主存;当处理器运行程序时,指令又从主存复制到处理器.相似地,数据串“hello, world\n”初始时在磁盘上,然后复制到主存,最后从主存上复制到显示设备.根据机械原理,较大的存储设备要比较小的存储设备运行得慢,而快速设备的造价远高于同类的低速设备.例如,一个典型系统上的磁盘驱动器可能比主存大1000倍,但是对处理器而言,从磁盘驱动器上读取一个字的时间开销要比从主存中读取的开销大1000万倍.针对这种处理器与主存之间的差异,系统设计者采用了更小,更快的存储设备,即高速缓存存储器(简称高速缓存),作为暂时的集结区域,用来存放处理器近期可能会需要的信息.

在处理器和一个又大又慢的设备(例如主存)之间插入一个更小更快的存储设备(例如高速缓存)的想法已经成为了一个普遍的观念.实际上,每个计算机系统中的存储设备都被组织成了一个存储器层次结构,上图所示.在这个层次结构中,从上至下,设备变得访问速度越来越慢,容量越来越大,并且每字节的造价也越来越便宜.寄存器文件在层次结构中位于最顶部,也就是第0级或记为L0.这里我们展示的是三层高速缓存L1到L3,占据存储器层次结构的第1层到第3层.主存在第4层,以此类推存储器层次结构的主要思想是一层上的存储器作为低一层存储器的高速缓存.因此,寄存器文件就是L1的高速缓存,L1是L2的高速缓存,L2是L3的高速缓存,L3是主存的高速缓存,而主存又是磁盘的高速缓存.在某些具有分布式文件系统的网络系统中,本地磁盘就是存储在其他系统中磁盘上的数据的高速缓存.

晚安!

本文链接

博客园_回头再说 坚强2002的博客

[Erlang 0062] Erlang Unicode 两三事

The Matrix Revolutions

[Erlang 0061] Erlang Code Snippet Ⅱ

[Erlang 0060] Joe Armstrong 论文《面向软件错误构建可靠的分布式系统》笔记

[Erlang 0059] Erlang日期与时间处理

Linux/Unix设计思想 读书笔记

参考资料:[1] 《思维之火》之如何识破他在扯蛋（上） [2] 《思维之火》之如何识破他在扯蛋（中） [3] 《思维之火》之如何识破他在扯蛋（下） [4] 《思维之火》之如何成为一个自由的思考者 本文链接

[Erlang 0058] Erlang Function调用效率

[Erlang 0057] Erlang 排错利器: Erlang Crash Dump Viewer

[Erlang 0056] 用fun在Erlang Shell中编写尾递归 Ⅱ

Disk is Tape, Flash is Disk

博客园_回头再说坚强2002的博客

Linux/Unix设计思想读书笔记

参考资料:
[1] 《思维之火》之如何识破他在扯蛋（上）
[2] 《思维之火》之如何识破他在扯蛋（中）
[3] 《思维之火》之如何识破他在扯蛋（下）
[4] 《思维之火》之如何成为一个自由的思考者

本文链接