博客分类 ‘编程语言’

Dart语言性能测试

在我之前的这篇文章中,将一个计算密集型的例子移植到了Go语言。这里,将同样的代码移植到了Dart语言,并与一些语言的结果进行了比较。

Dart是由Google开发的语言平台,主要用于编写web应用,它可以运行在服务器端和浏览器端(目前直接支持的只有Dartium:支持Dart VM的Chromium)。之所以称其为平台,是因为Dart包括了语言、基础库、一个编辑器(Dart Editor),一个可以运行在浏览器和服务器端的虚拟机,还包括一个将Dart语言编译至JavaScript的编译器(dart2js)。

Dart对开发人员还是比较友好的,拥有比较傻瓜式的开发环境;从语法的层面来说,Dart看上去是个语法糖版本的Java,所以,一个从事后端的Java程序员能够较快地上手。Dart推出的目的,是弥补JavaScript的一些不足,不过就目前来说,Dart想挑战大红大紫的JS,有很大难度。不过,在我看来,在Dart VM成熟以后,Google可以考虑将Dart移植到Android平台,这样,Chrome和Android就可以有统一的编程语言,Android平台本地程序也就可以容易地切换到web化,不过这一切的前提都是Dart取得一定成功,具体结果如何,还是让我们拭目以待吧。

现在还是回到测试上来,实验中,生成了256×256像素图片,每个像素点默认100次采样。

由于目前Dart处在早期开发阶段,所以随着时间的变化,本文结果可能有较大的变化。本文所使用的Dart SDK版本为10597。本实验Dart的代码托管在这里

实验环境是Visual studio2010/.net framwork 4.0编译,Intel core2 P7570(2.26GHz主频)。VC++编译器选项参照了原作者,而chrome浏览器版本为21.0.1180.60 m,Java版本为1.7.0_03,Go版本为1.0.2。

最终的实验结果如下:

语言运行时长(秒)比例
VC++(基准) 57.513 1.00x
Java 65.719 1.14x
C# 127.765 2.22x
JsChrome 266.616 4.64x
Go 310.695 5.40x
Dart 2819.643 49.03x

从表格中可以看到Dart的性能让人大跌眼镜,不过,Dart还处在早期阶段,在语法还没完全成型的阶段,对性能的要求就有些太苛刻了。无论如何,本文对Dart的性能的测试也只是一个参考,没有什么实际意义。很多时候,性能的瓶颈并不都在计算这块上。

最后,关于Google的另一个语言Go,可以看到在Go1发布了以后,性能方面还没有明显提高。不过和Dart不同,大家对Go的性能的期许会高很多,相信Go1后的Golang会越来越好吧。

Update:在最新版build 16323版下花费2319.813秒,还是比较慢的,不过有了一些改进。另外,由于Dart API发生了一些变化,所以代码做了些修正。

Go语言性能测试

大概在一年前,看到一个作者写了两篇文章,使用计算密集型的例子来比较了各个语言的性能(C# vs C++ 全局照明渲染性能比试C++/C#/F#/Java/JS/Lua/Python/Ruby渲染比试)。由于最近在使用Go,且想了解Go语言的性能,于是想起来这篇文章,并把文章中所提到的C++代码移植到了Go语言上。通过对几种语言实现的结果的比试,来了解Go目前的性能。

大概说一下作者所做的事。作者使用蒙地卡罗路径追踪来进行全局光照渲染。效果大致如下:

smallpt

这个图片是512×512像素,每个像素点10000个采样。在实验中,考虑执行时间问题,只生成了256×256像素图片,每个像素点默认100次采样。

移植后的Go代码在这里。在基本上直译了C++代码之后,由于每个像素点之间是计算无关的,所以,我使用了goroutine来对每个像素点进行计算,以利用多核的计算能力。

本人的实验环境是Visual studio2010/.net framwork 4.0编译,Intel core2 P7570(2.26GHz主频)。VC++编译器选项参照了原作者,Go使用8g编译。结果如下:

语言运行时长(秒)比例
VC++(基准) 56.269 1.00x
C# 215.545 3.83x
JsChrome 247.231 4.39x
GO 325.000 5.78x
GO(goroutine) 172.000 3.06x

参照原作者,C++用OpenMP库可以取得极大提升,本文没有测试。可以看到,Go在单线程情况下性能还不尽如人意,在利用双核基础上,性能相对单线程有了接近一倍的提升。考虑到go进程调度和上下文切换的原因,goroutine的效果还是很不错的。

考虑到Go发布到现在才两年的时间,有着目前的性能还是可圈可点的。但是,Go语言还有很长的路要走,在编程范式相对稳定之后,我相信Go在性能方面会有较大优化。期待明年年初GO 1的正式发布!

从生产者消费者问题看GO的并发机制

Go语言诞生已经两周年了。最近由于参加ECUG的缘故,我学习了一下Go语言的语法,就立刻被Go语言的特性所吸引。

Go语言一些背景就不介绍了,大家可以自行到Go主页进行查看(可能要准备梯子,和python.org一样悲催的命运)。Go的优点很多,最重要的特点之一是其第一个在语言层面对并发进行了支持。正如Go设计的主旨之一,就是现在的语言都没有对多核进行优化,对并发支持很不好。

Java,C#,Python这些语言对多线程编程有一样的模型。本文就生产者消费者问题对Java和Go进行对比。

生产者消费者模型大家应该很熟了,在操作系统的一些概念中经常提到,简单地说,就是生产者生产一些数据,然后放到buffer中,同时消费者从buffer中来取这些数据。这样就让生产消费变成了异步的两个过程。当buffer中没有数据时,消费者就进入等待过程;而当buffer中数据已满时,生产者则需要等待buffer中数据被取出后再写入。

Go语言中提出了channel的概念,它实际上就是一个管道,也可以理解为消息队列。Go线程(这里要注意,Go线程不同意一般的系统线程,而是类似于协程的概念,Go中称为goroutine)之间可以通过channel来进行通信,而channel本身是同步的。Go当中不鼓励通过加锁的方式来进行共享内存操作,而是鼓励通过管道通信来共享内存。我们来看具体的实现就明白了。

首先给出传统的Java中实现生产者消费者问题的代码。我们先写一个Mixin类,来进行对buffer中数据的取出和放入的操作。

public class Mixin {
	private int BUFFERSIZE = 0;
	private int[] Buffer;
	private int index = -1;
	
	public Mixin(int BufferSize) {
		this.BUFFERSIZE = BufferSize;
		this.Buffer = new int[this.BUFFERSIZE];
	}
	
	public synchronized void put(int item) {
		while(this.index >= this.BUFFERSIZE - 1) {
			try{
				wait();
			}
			catch(InterruptedException e) {
			}
		}
		this.Buffer[++this.index] = item;
		notifyAll();
	}
	
	public synchronized int get() {
		while(this.index < 0) {
			try{
				wait();
			}
			catch(InterruptedException e) { }
		}
		int result = this.Buffer[this.index--];
		notifyAll();
		return result;
	}
}

put和get操作都需要加上synchronized关键字来保证同步,代码很好理解就不讲了。接着,我们分别实现Producer和Consumer类,它们都继承了Thread类,并实现了run方法。

Producer类:

public class Producer extends Thread {
	private Mixin m = null;
	private int thisId;
	
	public Producer(Mixin m, int id) {
		this.m = m;
		this.thisId = id;
	}
	
	public synchronized void run() {
		for(int i=0; i<10; i++) {
			this.m.put(i);
			System.out.println("Producer " + this.thisId + " produces data: " + i);
			try {
				sleep(10);
			} catch (InterruptedException e) { }
		}
	}
}

Consumer类:

public class Consumer extends Thread {
	private Mixin m = null;
	private int thisId;
	
	public Consumer(Mixin m, int id) {
		this.m = m;
		this.thisId = id;
	}
	
	public synchronized void run() {
		for(int i=0; i<20; i++) {
			int item = this.m.get();
			System.out.println("Cosumer " + this.thisId + " get data: " + item);
			try {
				sleep(10);
			} catch (InterruptedException e) { }
		}
	}
}

Producer就是简单地把一些数放入buffer中。Java中通过wait方法来阻塞当前线程,而通过notifyAll来唤起所有阻塞的线程。最后我们写一个类来运行main函数,我们起了两个Producer线程和一个Cosumer线程。

public class ProducerConsumer {

	public static void main(String[] args) {
		Mixin m = new Mixin(6);
		Producer p1 = new Producer(m, 1);
		Producer p2 = new Producer(m, 2);
		Consumer c = new Consumer(m, 1);
		
		p1.start();
		p2.start();
		c.start();
	
	}

}

在Go中,这个问题变得异常简单。我们实现两个函数来分别表示Producer和Consumer,通过go关键字+函数名的方式,来启动goroutine。而由于channel的支持,我们可以在Producer和Consumer之间直接通过channel来进行通信。代码如下:

package main

import (
	"fmt"
	"time"
)

func Producer(id int, item chan int) {
	for i:=0; i<10; i++ {
		item <- i
		fmt.Printf("Producer %d produces data: %d\n", id, i)
		time.Sleep(10 * 1e6)
	}
}

func Consumer(id int, item chan int) {
	for i:=0; i<20; i++ {
		c_item := <-item
		fmt.Printf("Consumer %d get data: %d\n", id, c_item)
		time.Sleep(10 * 1e6)
	}
}

func main() {
	item := make(chan int, 6)
	go Producer(1, item)
	go Producer(2, item)
	go Consumer(1, item)
	
	time.Sleep(1 * 1e9)
}

channel的创建通过内建的make函数,第二个参数是channel通道的大小。通过item<-i,Producer把i放入item这个channel中,而Consumer通过<-item操作来从channel中取数据。当channel中的数据超过了其负荷值时,Producer这个goroutine就简单地阻塞,同样,当channel中没有数据时,Consumer也相应会阻塞。

可以看到,在语言级别上对并发的支持让Go中的多线程编程和异步编程变得很简单,也很易懂。