基于托管指针字节码的线程间数据传输

原创于 2012-02-08 20:55:59 发布 · 1.1k 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

AAuto语言及快手集成开发环境

本文通过对比实验证明了使用托管指针字节码进行线程间数据传输的效率优势，并提供了具体的代码实现。

本代码演示了如何用托管指针的字节码进行线程间数据传输的。不知何故，直接用AAuto原生的数值数组传输比用托管指针字节码慢了很多，请大家斧正，在此不胜感激！话不多说，各位看了如下代码自会明白。
先把如下代码（文件名nb.aau）编译成用户库，便于在main.aau中调用：

namespace nb
import raw
class DOUBLE{
double v=0
}
class INT32{
int v=0
}
//数值数组转化为托管指针字节码，数值默认类型为double
num2byte=function(numarr,numtype='double'){
  var len
  var ele
  if numtype=='double'{
      ele=DOUBLE()
      len=8
}
  else{
      ele=INT32()
      len=4
}
  var bytearr=raw.malloc(len*#numarr)
  for i=1;#bytearr;len{
      ele.v=numarr[(i+len-1)/len]
      var tmp=raw.malloc(ele)
      for j=0;len-1
         bytearr[i+j]=tmp[j+1]
}
  return bytearr
}
//托管指针字节码转化为数值数组，数值默认类型为double
byte2num=function(bytearr,numtype='double'){
  var len
  var ele
  if numtype=='double'{
      ele=DOUBLE()
      len=8
}
  else{
      ele=INT32()
      len=4
}
  var numarr={}
  for j=1;#bytearr/len
      numarr[j]=raw.convert(bytearr,ele,len*(j-1)).v
  return numarr
}

主调程序main.aau:

import time.performance
import nb
//托管指针字节码与数值数组的相互转化
io.open()
io.print("==========================================")
io.print("* 托管指针字节码与数值数组的相互转化示例 *")
io.print("==========================================")
io.print("示例 1: 小规模，验证一下结果")
var numarr={1;2;255;256;257}
io.print("原始数值数组：")
for j=1;#numarr
io.stdout.write(numarr[j],' ')
io.print()
var bytearr=nb.num2byte(numarr,'int')
io.print("数值数组 --> 字节码：")
for j=1;#bytearr
io.stdout.write(bytearr[j],' ')
io.print()
io.print("字节码 --> 数值数组：")
var numarr2=nb.byte2num(bytearr,'int')
for j=1;#numarr2
io.stdout.write(numarr2[j],' ')
io.print('\n')
io.print("示例 2: 大规模，测一下运行效率")
numarr={}
for j=1;200000
numarr[j]=j
io.print("数组数组长度",#numarr)
var tk=time.performance.tick()
bytearr=nb.num2byte(numarr,'int')
io.print("数值数组 --> 字节码：",time.performance.tick()-tk,'毫秒')
tk=time.performance.tick()
numarr2=nb.byte2num(bytearr,'int')
io.print("字节码 --> 数值数组：",time.performance.tick()-tk,'毫秒')
io.print('\n')
io.print("========================")
io.print("*  线程间数值数据传输  *")
io.print("========================")
fnum=function(numarr){
  var s=0
  for j=1;#numarr
      s+=numarr[j]
io.print("  数组元素之和：",s)
}
fbyte=function(bytearr){
  import nb
  var numarr=nb.byte2num(bytearr,'int')
  var s=0
  for j=1;#numarr
      s+=numarr[j]
io.print("  数组元素之和：",s)
}
numarr={}
for j=1;10000
numarr[j]=j
io.print("数组数组长度",#numarr)
io.print('利用数值数组：')
tk=time.performance.tick()
handle=thread.create(fnum,numarr)
thread.wait(handle)
io.print("耗时：",time.performance.tick()-tk,'毫秒')
io.print('利用字节码：')
tk=time.performance.tick()
bytearr=nb.num2byte(numarr,'int')
handle=thread.create(fbyte,bytearr)
thread.wait(handle)
io.print("耗时：",time.performance.tick()-tk,'毫秒')
execute("pause")
io.close()
某次运行结果：

==========================================
* 托管指针字节码与数值数组的相互转化示例 *
==========================================
示例 1: 小规模，验证一下结果原始数值数组：
1 2 255 256 257
数值数组 --> 字节码：
1 0 0 0 2 0 0 0 -1 0 0 0 0 1 0 0 1 1 0 0
字节码 --> 数值数组：
1 2 255 256 257
示例 2: 大规模，测一下运行效率
数组数组长度 200000
数值数组 --> 字节码： 1531.6426094919 毫秒
字节码 --> 数值数组： 100.48708815128 毫秒

========================
*  线程间数值数据传输  *
========================
数组数组长度 10000
利用数值数组：
数组元素之和：       50005000
耗时：    352.52849365026 毫秒
利用字节码：
数组元素之和：       50005000
耗时：    19.031126827002 毫秒
注：系统配置 WinXP SP3，intel core2 CPU Quad Q8300 2.50GHz，内存金士顿两条共4GB。

标签

#function #byte