Mnesia最大的缺陷是存储限制。这不是数据库系统的错误，因为Mnesia能够控制虚拟数据的大小。主要的问题在于过时的Erlang DETS存储引擎，速度慢并且使用的32位偏移量（限制单文件大小为2GB）。

思路？

    超乎想象的 mnesia 补丁包 mnesiaex 。这个东西解除了加在 mnesia 数据库系统上所有的限制(虽说上面已经提到，实际上 mnesia 代码本身没有什么真正的限制)——你现在可以用 SleepyCat/BerkeleyDB/MySQL/Amazon S3/Tokyo Cabinet/… 甚至是你自己喜欢的某种东西来当作 mnesia 的后端，就像 ets/dets 一样。而访问的接口仍保持不变——继续沿用 mnesia 的接口，一行也不用改。 DIY 这种扩展也变得相当容易，写一个 behavior 就成了。

实现过程

1：与从源代码编译的方式安装Erlang

tar xvf otp_src_R12B-5.tar.gz

cd otp_src_R12B-5

./configure & make & make install

注意：我的系统是RHEL 5.3，默认安装目录为/usr/local/erlang

2：安装Mnesiaex

tar xvf mnesia-4.4.7.6.tar.gz

cd mnesia-4.4.7.6

./configure --prefix=/usr/local

make

make check

make install

注意：这里一定要指定prefix，不然就装到/usr目录去了

3：安装Tokyo Cabinet

tar xvf  tokyocabinet-1.4.10.tar.gz

cd tokyocabinet-1.4.10

./configure --prefix=/usr

make & make install

3：安装tcerl

tar xvf tcerldrv-1.3.1e.tar.gz

cd tcerldrv-1.3.1e

./configure --prefix=/usr

make & make install

tar xvf tcerl-1.3.1e.tar.gz

cd tcerl-1.3.1e

./configure --prefix=/usr/local

make & make install

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/jimmychou/archive/2009/03/13/3988468.aspx

http://shiningray.cn/some-facts-about-erlang-and-smp.html

原文：http://groups.google.com/group/erlang-questions/browse_thread/thread/7827f5e32681ca8e

by.Kenneth Erlang/OTP team, Ericsson
译：ShiningRay

以下是一些Erlang SMP实现的细节和与性能与伸缩性相关一些简单介绍。

几周之内还有有一个关于多核如何运作以及未来如何发展的更详细的介绍。我打算将一些内容放在我的报告中，将于9月27日的ICFP2008，Erlang Workshop在Victoria BC展示给大家。

没有SMP支持的Erlang VM只有1个运行在主处理线程中的调度器。该调度器从运行队列（run-queue）中取出可以运行的Erlang进程以及IO任务，而且因为只有一个线程访问他们所以无须锁定任何数据。

而带有SMP支持的Erlang VM可以有一个或多个调度器，每个运行在一个线程中。调度器从同一个公共运行队列中取出可运行的Erlang进程和IO任务。在SMP VM中所有的共享数据结构都会由锁进行保护，运行队列就是这样一个由锁保护的数据结构。

从OTP R12B开始，如果操作系统报告有多于1个的CPU（或者核心）VM的SMP版本会自动启动，并且根据CPU或者核心的数量启动同样数量的调度器。

你可以从“erl”命令打印出来的第一行看到它选择了哪些参数。例如：

Erlang (BEAM) emulator version 5.6.4 [source] [smp:4] [asynch-threads:0] …..
其中“[smp:4]”表示SMP VM运行了4个调度器。

默认值可以用“-smp [enable|disable|auto]”来替换，auto是默认的。如果smp被启用了（-smp enable），要设置调度器的数量可以使用“+S Number”其中Number是调度器的数量（1到1024）

注意1：运行多于CPU或核心总数的调度器不会有任何提升。

注意2：在某些操作系统中一个进程可使用的CPU或者核心的数量可以被限制。例如，在Linux中，命令“taskset”就可以实现这个功能。 Erlang VM目前还只能探测CPU或者核心的总数，不会考虑“taskset”所设置的掩码。正因如此，例如可能会出现（已经出现过了）即使Erlang VM运行了4个调度器，也只使用了2个核心。OS会进行限制因为它要考虑“taskset”所设置的掩码。

每个Erlang VM的调度器都运行于一个OS线程上，是OS来决定线程是否执行在不同的核心上。一般来说OS会很好地处理这个问题并且会保证线程在执行期间运行于同一个核心上。

Erlang进程会被不同的调度器运行，因为他们是从一个公共运行队列中被取出，由首先可用的调度器运行。

性能和伸缩性

只有一个调度器的SMP VM要比非SMP的VM稍微慢那么一点点。SMP VM内部需要用到各种锁，不过只要不存在锁的争用，那么由锁引起的开销不会非常大（就是锁争用上面需要花时间）。这也解释了为何在某些情况下，运行多个只有一个调度器的SMP VM要比包含多个调度器的单一SMP VM更加高效。当然运行多个VM要求应用可以按照多个并行任务的方式运行并且之间没有或者几乎不通讯。

一个程序是否能在多核上的SMP VM中良好地进行提升很大程度上取决于程序的性质，某些程序可以保持线性提升至8核甚至16核，同时其他某些程序基本不能提升，连2核都不行。实际应用中很多程序都能在主流市场的核心数上得到提升，见下文。

若并行的持续“通话”由每个核心一个或多个Erlang进程来表示，实际的支持大量通话的电信产品已经先现出在双核和四核处理器上不俗的伸缩性。注意，这些产品是在SMP VM和多核处理器出现很久以前按照普通的Erlang风格来写的，他们也能无须任何修改甚至不需重新编译代码就能从Erlang SMP VM中获益。

SMP性能得到持续改进

SMP实现正被不断改进以便能得到更好的性能和伸缩性。在每个服务发布版R12B-1,2,3,4,5…,R13B等等中，你都能发现新的优化。

一些已知的瓶颈

单一的常见运行队列随着CPU或核心的数量的增加会成为一个显著的瓶颈。

这从4核开始往上就会显现出来，不过4核仍然可以为多数应用程序提供不错的性能。我们正在从事一个每个调度器一个运行队列的解决方法作为目前最重要的改进。

Ets表格会引入锁。在R12B-4之前在每次对一个ets-table的访问中会用到两个锁，但是在R12B-4中meta-table的锁被优化过，可以显著减少争用（前面已经提到争用是有很大代价的）。如果很多Erlang进程访问同一个表格，就会有很多锁争用造成性能降低尤其当这些进程主要工作是访问ets-table。锁存在于表级而非记录级。注意！这也会影响到Mnesia因为Mnesia用到了很多ets-table。

我们关于SMP的策略

当我们开始实现SMP VM的最初，我们就确定了策略：“首先让它可以运行，然后测量，然后优化”。自从2006年五月我们发布了第一个稳定的SMP VM（R11B）以来，我们一直遵循着这个策略。

还有更多已知的东西可以改进，我们会按照性能的收益大小先后各个击破。

我们将主要的精力放在多核（大于4）上更好的连续伸缩性上。

卓越典范

即使SMP系统有还有一些已知的瓶颈不过已经有不错的整体性能和伸缩性，同时我相信在让程序员利用多核机器事半功倍方面，我们是一个卓越的典范。

然后要用新立得装如下库：
libc6
unixodbc
unixodbc-dev
gcj

freeglut3-dev
libwxgtk2.8-dev
g++

然后下载源代码
tar -xvf otp-src-R12B-0.tar.gz  
cd otp-src-R12B-0 
sudo ./configure --prefix=/otp/erlang  
sudo make  
sudo make install 

安装完毕，可以rm -fr opt-src-R12B-0删除源代码

然后改改/etc/profile
export PATH=/opt/erlang/bin:$PATH
alias ls='ls -color=auto'
alias ll='ll -lht'

可以source /etc/profile一下，及时修改PATH

在没有使用包协议的时候，遇到好多粘包问题，实在恼火

查阅了相关资料：

Flash Socket 的 writeUTF() 会自动增加包头长度的协议，刚好对应了
Erlang的Socket选项 {packet,2}

这使得两者的通信非常完美，再也不用担心粘包什么的问题了

下面是我写的一个Flash Socket 接口：SocketBridge.as

package {   
    import flash.display.Sprite;   
    import flash.events.*;   
    import flash.net.Socket;   
    import flash.utils.*;   
    import flash.external.ExternalInterface;   
    import flash.system.*;   
    public class SocketBridge extends Sprite {   
        Socket.prototype.timeout    =3000;   
        private var socket:Socket;   
        public function SocketBridge()   
        {   
            socket = new Socket();   
            socket.addEventListener( Event.CONNECT, onConnect );   
            socket.addEventListener( ProgressEvent.SOCKET_DATA, onDataRecevice);   
            socket.addEventListener( Event.CLOSE, onClose);   
            socket.addEventListener( IOErrorEvent.IO_ERROR, onError);    
               
            if(ExternalInterface.available)   
            {   
                   
                ExternalInterface.addCallback("socket_connect",socket_connect);   
                ExternalInterface.addCallback("socket_send",socket_send);   
                ExternalInterface.addCallback("load_policy",load_policy);   
            }   
        }   
        public function onError(e):void  
        {   
            ExternalInterface.call("sb_onerror",e.text);   
            socket.close();   
        }   
        public function load_policy(host:String,port):void  
        {   
            Security.loadPolicyFile("xmlsocket://"+host+":"+port);     
        }   
           
        public function socket_connect(host:String,port):void  
        {   
            try{   
                socket.connect(host,port);   
            }catch(e){   
                ExternalInterface.call("sb_onerror",e.text);   
            }   
        }   
           
        public function socket_send(msg:String)   
        {      
            socket.writeUTF(msg);   
            socket.flush();   
        }   
           
        private function onConnect(event:Event):void    
        {   
            ExternalInterface.call("sb_onconnect",true);   
        }   
           
        private function onClose(event:Event):void    
        {   
            socket.close();   
            ExternalInterface.call("sb_onclose",true);   
        }   
  
        private function onDataRecevice( eventrogressEvent ):void  
        {   
            var sdata:String;   
            while(socket.bytesAvailable){   
                sdata = socket.readUTF();   
                ExternalInterface.call("sb_ondata",sdata);   
            }   
        }   
  
    }   
}  

• -module(stress_test).  
• 
  
• -export([start/0, tests/1]).  
• 
  
• start() ->  
• 
  tests(12345).  
• 
  
• tests(Port) ->  
• 
  io:format("starting~n"),  
• 
  spawn(fun() -> test(Port)
  end),  
• 
  spawn(fun() -> test(Port)
  end),  
• 
  spawn(fun() -> test(Port)
  end),  
• 
  spawn(fun() -> test(Port)
  end).  
• 
  
• test(Port) ->  
• 
  case
  gen_tcp:connect("192.168.0.217", Port, [binary,{packet, 0}])
  of
  
•     {ok, _} ->  
• 
  test(Port);  
• 
  _ ->  
• 
  test(Port)
  
• 
  end.

• $./configure --enable-kernel-poll

• $echo 1024 65535 > ip_local_port_range

• $export ERL_MAX_PORTS=102400

• $erl -noshell  +P 102400 +K true +S 2 -smp -s echo_server start

• $erl -noshell  +P 102400 +K true +S 2 -smp -s stress_test start

after and andalso band begin bnot bor bsl bsr bxor case catch cond div end fun if let not of or orelse query receive rem try when xor

try Expr
catch
    throw:Term -> Term;
    exit:Reason -> {'EXIT',Reason}
    error:Reason -> {'EXIT',{Reason,erlang:get_stacktrace()}}
end

不仅如此，try还可以与after结合使用，类似java中的try..finally，用于进行清除作用，比如：
termize_file(Name) ->
{ok,F} = file:open(Name, [read,binary]),
try
{ok,Bin} = file:read(F, 1024*1024),
binary_to_term(Bin)
after
file:close(F)
end.


5.列表推断（List Comprehensions），函数式语言特性之一，Erlang中的语法类似：
[Expr || Qualifier1,...,QualifierN]
Expr可以是任意的表达式，而Qualifier是generator或者filter。还是各举例子说明下。
1>  [X*2 || X <- [1,2,3]].
[2,4,6]

2> L=[1,2,3,4,5,6,7].
[1,2,3,4,5,6,7]


3> [X|X<-L,X>=3].
[3,4,5,6,7]


再看几个比较酷的例子，来自Programming Erlang，
比如快速排序：
-module(qsort).
-export([qsort/1]).
qsort([])->[];
qsort([Pivot|T])->
  qsort([X||X<-T,X




6.宏，定义常量或者函数等等，语法如下：

-define(Const, Replacement).

-define(Func(Var1,...,VarN), Replacement).



使用的时候在宏名前加个问号？，比如?Const，Replacement将插入宏出现的位置。系统预定义了一些宏:

?MODULE   表示当前模块名



?MODULE_STRING 同上，但是以字符串形式

?FILE    当前模块的文件名

?LINE    调用的当前代码行数

?MACHINE  机器名



Erlang的宏与C语言的宏很相似，同样有宏指示符，包括：

-undef(Macro). 
取消宏定义

-ifdef(Macro). 
当宏Macro有定义的时候，执行以下代码

-ifndef(Macro). 
同上，反之

-else. 
接在ifdef或者ifndef之后，表示不满足前者条件时执行以下代码



-endif. 
if终止符
假设宏-define(Square(X),X*X).用于计算平方，那么??X将返回X表达式的字符串形式，类似C语言中#arg



一个简单的宏例子：

ruby 代码

 

    
-module(macros_demo).  
    
-ifdef(debug).  
    
-define(LOG(X), io:format("{~p,~p}: ~p~n", [?MODULE,?LINE,X])).  
    
-else.  
    
-define(LOG(X), true).  
    
-endif.  
    
-define(Square(X),X*X).  
    
-compile(export_all).  
    
test()->  
    
    A=3,  
    
    ?LOG(A),  
    
    B=?Square(A),  
    
    io:format("square(~w) is ~w~n",[A,B]).   




当编译时不开启debug选项的时候：

17> c(macros_demo).

{ok,macros_demo}

18> macros_demo:test().

square(3) is 9



当编译时开启debug之后：



19> c(macros_demo,{d,debug}).

{ok,macros_demo}

20> macros_demo:test().

{macros_demo,11}: 3

square(3) is 9

ok



可以看到LOG的输出了，行数、模块名以及参数



7、Process Dictionary，每个进程都有自己的process dictionary，用于存储这个进程内的全局变量，可以通过下列

BIFs操作：

put(Key, Value)

get(Key)

get()

get_keys(Value)

erase(Key)

erase()



8、关于分布式编程，需要补充的几点

1）节点之间的连接默认是transitive，也就是当节点A连接了节点B，节点B连接了节点C，那么节点A也与节点C互相连接

可以通过启动节点时指定参数-connect_all false来取消默认行为



2）隐藏节点，某些情况下，你希望连接一个节点而不去连接其他节点，你可以通过在节点启动时指定-hidden选项

来启动一个hidden node。在此情况下，通过nodes()查看所有连接的节点将不会出现隐藏的节点，想看到隐藏的节点

可以通过nodes(hidden)或者nodes(connected)来查看。



完整的erl选项如下：




    

        

            
-connect_all false 
            
上面已经解释。 
        
        

            
-hidden 
            
启动一个hidden node

        
        

            
-name Name 
            
启动一个系统成为节点，使用long name. 
        
        

            
-setcookie Cookie 
            
与Erlang:set_cookie(node(), Cookie).相同，设置magic cookie

        
        

            
-sname Name 
            
启动一个Erlang系统作为节点，使用short name 

        
    





注意,short name启动的节点是无法与long name节点通信的。



.一个小细节，在Erlang中小于等于是用=<表示，而不是一般语言中的<=语法，我犯过错误的地方，同样，不等于都是用/号，而不是
!,比如/=、=/=。

10.and or 和andalso orelse的区别

and和or会计算两边的表达式，而andalso和orelse的求值采用短路机制，比如exp1 andalso exp2，当exp1返回false之后，就不会去求值
exp2，而是直接返回false，而exp1 and exp2会对exp1和exp2都进行求值，or与orelse也类似。

二进制存储的101就是10进制的5了
2）$Char表示字符Char的ascii编码，比如$A表示65

2.比较难以翻译的概念——atom，可以理解成常量，它可以包含任何字符，以小写字母开头，如果不是以小写字母开头或者是字母之外的符号，需要用单引号包括起来，比如abc,'AB'

3.另一个概念——Tuple,有人翻译成元组，可以理解成定长数组，是Erlang的基础数据结构之一：

内置函数size求长度，元组可以嵌套元组或者其他结构。下面所讲的列表也一样。

4.另外一个基础数据结构就是各个语言都有的list（列表），在[]内以,隔开，可以动态改变大小，

可以使用内置函数length求列表大小。以""包含的ascii字母代表一个列表，里面的元素就是这些字母的ascii值，比如"abc"表示列表[97,98,99]。

5.通过这两个数据结构可以组合成各种复杂结构，与Lisp的cons、list演化出各种结构一样的奇妙。

6.Erlang中变量有两个特点：
1）变量必须以大写字母开头
2）变量只能绑定一次，或者以一般的说法就是只能赋值一次，其实Erlang并没有赋值这样的概念,=号也是用于验证匹配。

7.模式匹配——Pattern Matching，Erlang的模式匹配非常强大，看了buaawhl的《Erlang语法提要》的介绍，模式匹配的功能不仅仅在课程中介绍的数据结构的拆解，在程序的分派也扮演重要角色，或者说Erlang的控制的流转是通过模式匹配来实现的。具体功能参见链接，给出书中拆解列表的例子：

 
下面会给出更多模式匹配的例子，给出一个模块用来计算列表等

8.Erlang中函数的定义必须在一个模块内（Module），并且模块和函数的名称都必须是atom，函数的参数可以是任何的Erlang类型或者数据结构，函数要被调用需要从模块中导出，函数调用的形式类似：
moduleName:funcName(Arg1,Arg2,...).
写我们的第一个Erlang程序，人见人爱的Hello World：

存为helloWorld.erl，在Erlang Shell中执行：

打印出来了，现在解释下程序构造，

这一行声明了模块helloWorld，函数必须定义在模块内，并且模块名称必须与源文件名相同。

而这一行声明导出的函数，run/1指的是有一个参数的run函数，因为Erlang允许定义同名的有不同参数的多个函数，通过指定/1来说明要导出的是哪个函数。
接下来就是函数定义了：

大写开头的是变量Name，调用io模块的format方法输出，~w可以理解成占位符，将被实际Name取代，~n就是换行了。注意，函数定义完了要以句号.结束。然后执行c(helloWorld).编译源代码，执行：

9.内置的常用函数：

10.常见Shell命令：
1）h(). 用来打印最近的20条历史命令
2）b(). 查看所有绑定的变量
3) f(). 取消（遗忘）所有绑定的变量。
4) f(Val).  取消指定的绑定变量
5) e(n).   执行第n条历史命令
6) e(-1).  执行上一条shell命令

11.又一个不知道怎么翻译的概念——Guard。翻译成约束？呵呵。用于限制变量的类型和范围，比如：

为了方便比较，Erlang规定如下的比较顺序：

12.忘了介绍apply函数，这个函数对于熟悉javascript的人来说很亲切，javascript实现mixin就得靠它，它的调用方式如下：

apply(Mod, Func, Args),三个参数分别是模块、函数以及参数列表，比如调用我们的第一个Erlang程序：

java 代码


    
apply(helloWorld,run,[dennis]).  



13.if和case语句，if语句的结构如下：

java 代码

 

    
if  
    
   Guard1 ->  
    
        Sequence1 ;  
    
   Guard2 ->  
    
        Sequence2 ;  
    
...  
    
end  



而case语句的结构如下：

java 代码

 

    
case Expr of  
    
   Pattern1 [when Guard1] -> Seq1;  
    
   Pattern2 [when Guard2] -> Seq2;  
    
  
    
   PatternN [when GuardN] -> SeqN  
    
end  

if和case语句都有一个问题，就是当没有模式匹配或者Grard都是false的时候会导致error，这个问题case可以增加一个类似java中default的：

通过_指代任意的Expr，返回true,而if可以这样：

一样的道理。case语句另一个需要注意的问题就是变量范围，每个case分支中定义的变量都将默认导出case语句，也就是在case语句结束后可以被引用，因此一个规则就是每个case分支定义的变量应该一致，不然算是非法的，编译器会给出警告，比如：

如果执行true分支，变量A和变量B都被定义，而如果执行的false分支，只有变量B被引用，可在case语句执行后，h(A)调用了变量A，这是不安全的，因为变量A完全可能没有被定义，编译器将给出警告
variable 'A' unsafe in 'case' (line 10)



14.给出一些稍微复杂的模型匹配例子，比如用于计算数字列表的和、平均值、长度、查找某元素是否在列表中，我们把这个模块定义为list:

细细体会，利用递归来实现，比较有趣。_用于指代任意的变量，当我们只关注此处有变量，但并不关心变量的值的时候使用。用分号;来说明是同一个函数定义，只是不同的定义分支，通过模式匹配来决定调用哪个函数定义分支。
另一个例子，计算各种图形的面积，也是课程中给出的例子：

执行一下看看：

Erlang使用%开始单行注释。