M-OSCAR

static AS3_Val myfun(void *self, AS3_Val args){
    int buffer[4] = {1, 2, 3, 4};
    return AS3_Array("IntType, AS3ValType", AS3_Int(4), AS3_Ptr(buffer));
}

var loader:CLibInit = new CLibInit();
var clib:Object = loader.init();

var rs:Array = clib.myfun();
var len:init = rs[0];
var ptr:uinit = rs[1];

var ns:Namespace = new Namespace("cmodule.ModuleName");
var memory:ByteArray = (ns::gstate).ds;
memory.position = ptr;

var i:int;
for(i = 0; i < len; i ++){
    trace(memory.readInt());
}

//讀取AS傳入的ByteArray類型數據
static AS3_Val readByteArray(void *self, AS3_Val args)
{
    //提取ByteArray
    AS3_Val data = AS3_Undefined();
    AS3_ArrayValue(args, "AS3ValType", &data);

    //獲取ByteArray長度
    AS3_Val prop = AS3_String("length");
    int length = AS3_IntValue(AS3_Get(data, prop));
    
    int i, tmp;
    char buffer[128];
    for (i = 0; i < length; i ++){
        //讀取ByteArray裡的值並輸出到終端顯示
        tmp = AS3_IntValue(AS3_Get(data, AS3_Int(i)));
        sprintf(buffer, "[%d] : %d", i, tmp);
        sztrace(buffer);
    }
    
    return AS3_Null();
}

//初始化Alchemy
var loader:CLibInit = new CLibInit();
var lib:Object = loader.init();

//創建一個ByteArray並寫入點數據
var bytes:ByteArray = new ByteArray();
bytes.writeByte(10);
bytes.writeByte(20);
bytes.writeByte(255);

//調用C函數
lib.readByteArray(bytes);

unsigned char rs;
AS3_ByteArray_seek(data, 0, SEEK_SET);
AS3_ByteArray_readBytes(&rs, data, 1);
傳說中這樣比較高效～～

#include <stdlib.h>
#include <stdio.h>
#include "AS3.h"

//供AS調用的函數，args即為AS傳入給C函數的參數
static AS3_Val myfun(void *self, AS3_Val args)
{ 
    //提取參數
    int a, b;
    AS3_ArrayValue(args, "IntType, IntType", &a, &b);
    
    //計算a, b之和，轉換為AS裡的Int數據類型並返回之
    return AS3_Int(a+b);
}

int main()
{
    //定義一個公開給AS調用的函數
    AS3_Val myMethod = AS3_Function(NULL, myfun);

    //創建一個持有該函數引用的Object
    AS3_Val result = AS3_Object("myfun:AS3ValType", myMethod);

    //Release
    AS3_Release(myMethod);

    //告知初始化完成，此方法不會返回
    AS3_LibInit(result);

    //永遠不會執行到這裡
    return 0;
}

package{

    import flash.display.Sprite;
    import flash.utils.ByteArray;
    import cmodule.test.CLibInit;

    public class Test extends Sprite
    {
        public function Test()
        {
            var loader:CLibInit = new CLibInit();
            var lib:Object = loader.init();
            trace(lib.myfun(10, 20));
        }
    }
}

为了证实Erlang传说中“Crazy Fast”的进程创建速度，今天特意在自己机上（AMD 3600+ 双核，1G内存，Ubuntu 8.10操作系统）测试了一下Erlang创建进程的时间，所用代码如下：

-module(test).

-export([start/1]).

%记录开始时间并开始生成指定数量进程

start(Num) ->

statistics(wall_clock),

spawnProcesses(Num).

%所有进程生成完后输出所耗时间

spawnProcesses(0) ->

{_,Time}=statistics(wall_clock),

io:fwrite(”Total Time : ~p\n”,[Time]);

%生成进程

spawnProcesses(Num) ->

spawn(fun() -> doSomething(Num) end),

spawnProcesses(Num-1).

%什么都不做的进程～～

doSomething(Num) -> Num.

运行Erlang虚拟机编译＆运行：

1> c(test).

{ok,test}

2> test:start(1000000).

4768

….

统计结果表明Erlang生成一百万个进程约需4.7秒，亦即平均下来生成一个进程仅需4.7us，确实是很短的时间了～～但没有对比说明不了什么，与C生成线程的速度比哪个更快些呢？马上写段C代码看看：

#include

#include

#include

//什么都不干的线程～～

void thread(){}

//主函数

int main(){

int i;

clock_t start,end;

//记录开始时间

start=clock();

//生成很多很多线程

for(i=0;i<100000;i++){

pthread_t id;

pthread_create(&id,NULL,(void *)thread,NULL);

}

//记录结束时间

end=clock();

double time=(double)((end-start)/CLOCKS_PER_SEC);

printf(”Total Time : %f\n”,time);

}

编译运行命令如下：

gcc test.c -lpthread

./a.out

统计表明C生成十万进程就已经需要接近4秒了，比Erlang慢了接近10倍，看来Erlang疯快的轻量级进程不是浪的虚名的～～不过有好长时间没写C了，如果上面代码或测试方式有任何问题，欢迎留言提出大家讨论讨论～～

Port相关命令如下：

打开端口：Port=open_port(PortName,PortSettings).

发送数据：Port ! {PidC, {command, Data}}.

转换连接进程：Port ! {PidC, {connect, Pid}}.

关闭端口：Port ! {PidC, close}.

接收数据：receive {Port,{data,Data}} -> …. end.

例如下面的代码，Erlang先打开一个端口，传送一串字符串给外部的C++程序，外部程序原样返回该字符串：

#include <iostream>
using namespace std;

int main(){
    char str[128];
    cin.getline(str,128);
    cout << "Data receive in C : " << str << endl;
}

-module(test).
-export([start/0]).

start() ->
    %打开端口并接收数据
    Port=open_port({spawn,”./ctest”},[{line,1024}]),
    Port!{self(),{command,“I am Oscar! 123456\n”}},
    receive
        {Port,{data,{eol,Msg}}} ->
            io:fwrite(”Receive : ~s\n”,[Msg])
    end,
    
    %关闭端口
    Port!{self(),close}.

Erlang中生成随机数要使用random模块，首先讲讲主要用到的函数：

seed(A1, A2, A3) -> ran()

Seeds random number generation with integer values in the process dictionary, and returns the old state.One way of obtaining a seed is to use the BIF now/0:

…
{A1,A2,A3} = now(),
random:seed(A1, A2, A3),
…

uniform()-> float()

uniform(N) -> int()

Given an integer N >= 1, uniform/1 returns a random integer uniformly distributed between 1 and N, updating the state in the process dictionary.

例子：

-module(test).

-export([start/0]).

%设定状态并开始生成随机数

start() ->

{A1,A2,A3}=now(),

random:seed(A1,A2,A3),

generateRandom(4).

%生成N个随机数

generateRandom(0) -> ok,

generateRandom(N) ->

io:fwrite(”~p/n”,[random:uniform(10)]),

generateRandom(N-1).

另附一段C生成随机数的代码：

#include

#include

#include

int main(){

int i;

srand(time(NULL));

for(i=0;i<4;i++){

printf(”%d : %d\n”,i,rand());

}

}

感觉和Erlang大同小异～～