当前位置:首页 > 开发 > 编程语言 > 多线程 > 正文

Erlang/Java/Go threadring benchmark

发表于: 2012-01-16   作者:bookjovi   来源:转载   浏览次数:
摘要: shootout指通过一系列算法对language performance进行比较,具体可看:http://shootout.alioth.debian.org/ 里面包含了很多算法:   [root@localhost bench]# ls ackermann except harmonic knucleotide message

shootout指通过一系列算法对language performance进行比较,具体可看:http://shootout.alioth.debian.org/

里面包含了很多算法:

 

[root@localhost bench]# ls
ackermann       except          harmonic     knucleotide   message      nsievebits   raytracer   reversefile   tcpecho
ary             fannkuch        hash         LICENSE       messagering  objinst      README      robots.txt    tcprequest
binarytrees     fannkuchredux   hash2        license.txt   meteor       partialsums  recursive   sieve         tcpsocket
chameneos       fasta           health       lists         methcall     pidigits     regexdna    spectralnorm  tcpstream
chameneosredux  fastaredux      heapsort     magicsquares  moments      primes       regexmatch  spellcheck    threadring
discovery       fibo            hello        mandelbrot    nbody        process      regexsub    strcat        wc
dispatch        flyweightstate  implicitode  matrix        nestedloop   prodcons     regsub      sumcol        wordfreq
echo            gifdeanim       Include      matrixnorm    nsieve       random       revcomp     takfp

 基本上通用的语言都包含了(这里也是比较各语言语法差异的一个好地方)

shootout官方测试的机器是ubuntu,kernel是3.0,arch包含x86 one-core/x86 quad-core/x86-64 one-core/x86-64 quad-core,每种arch下的测试结果排名上略有不同,但纵观所有测试结果,可以发现一些特点:

1)编译型语言往往比虚拟机语言速度更快,但也不完全是。如Java 7比Go在某些测试中速度更好(Javay有JIT)。

2)函数型语言综合排名一般都在中间,没有太差,也没有太好。

3)Fortran Intel是最快的,比C/C++更快,我想这是因为后面的Intel的缘故,Intel的c编译器比gcc也快。

4)P系列语言(Perl/Python/Ruby)往往是最慢的。我测试了一下nbody在GoJavaPython的耗时,Go耗时1m,Python耗时46m,Java耗时最短40sec。

 

以上的结论是综合排名,在实际中影响测试结果的因素很多,同一种语言的不同算法实现也影响排名,

在threadring的测试,Erlang Hipe排名第一,haskell排名第二,Go排名第三。threadring算法其实很简单,这里就看看Go/Erlang/Java的threadring实现:

 

package main

import (
        "flag"
        "fmt"
        "os"
)

var n = flag.Int("n", 1000, "how many passes")

const Nthread = 503

func f(i int, in <-chan int, out chan<- int) {
        for {
                n := <-in
                if n == 0 {
                        fmt.Printf("%d\n", i)
                        os.Exit(0)
                }
                out <- n - 1
        }
}

func main() {
        flag.Parse()

        one := make(chan int) // will be input to thread 1
        var in, out chan int = nil, one
        for i := 1; i <= Nthread-1; i++ {
                in, out = out, make(chan int)
                go f(i, in, out)
        }
        go f(Nthread, out, one)
        one <- *n
        <-make(chan int) // hang until ring completes
}

 在Go中thread用goroutine模拟,把503个thread组成一个环ring,向第一个thread中发送一个数字1000,每个thread收到数字减一后传递给下一个thread,直到数字减为0。

这个go程序耗时28sec(time ./8.out -n 50000000)

这里的go版本threadring并不是shootout官方版本,这里的是google的go实现中的版本,shootout版本在这里

 

再看Erlang的threadring:

 

-module(threadring).
-export([main/1, roundtrip/2]).

-define(RING, 503).

start(Token) ->
   H = lists:foldl(
      fun(Id, Pid) -> spawn(threadring, roundtrip, [Id, Pid]) end,
      self(),
      lists:seq(?RING, 2, -1)),
   H ! Token,
   roundtrip(1, H).

roundtrip(Id, Pid) ->
   receive
      1 ->
         io:fwrite("~b~n", [Id]),
         erlang:halt();
      Token ->
         Pid ! Token - 1,
         roundtrip(Id, Pid)
   end.

main([Arg]) ->
   Token = list_to_integer(Arg),
   start(Token).

Erlang版本的threadring plain耗时17sec,比go版本还要少,erlang smp耗时就多到1m左右(由于threadring算法设计,导致在runqueue中只有一个running process,所以此场景下smp没有发挥优势,反而由于lock contention导致性能下降)。

 

 

[root@localhost threadring]# time erl -smp disable -noshell -run threadring main 50000000                                           
292

real    0m17.290s
user    0m0.517s
sys     0m16.768s
[root@localhost threadring]# time erl -noshell -run threadring main 50000000             
292

real    1m9.036s
user    0m4.266s
sys     1m4.759s
 

下面是Java的threadring:

 

import java.util.LinkedList;
import java.util.Queue;


public class threadring {
    public static void main(String[] args) {
        Node[] ring = new Node[503];
        for (int i=0; i<ring.length; i++) {
            ring[i] = new Node(i+1);
        }
        for (int i=0; i<ring.length; i++) {
            int nextIndex = (ring[i].label % ring.length);
            ring[i].next = ring[nextIndex];
        }
        int nHops = Integer.parseInt(args[0]);
        new Thread(new Consumer()).start();
        ring[0].sendMessage(nHops);
    }

    private static Queue<Node> q = new LinkedList<Node>();

    static class Consumer implements Runnable {

        public void run() {
            while (true) {
                try {
                    Node node;
                    node = q.poll();
                    if (node == null) {
                        //ignore, wait for some element
                        Thread.sleep(100);
                    } else {
                        node.run();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    static class Node implements Runnable {
        private final int label;
        private Node next;
        private int message;

        public Node(int label) {
            this.label = label;
        }

        public void sendMessage(int message) {
            this.message=message;
            q.add(this);
        }

        public void run() {
            //                System.out.println("after lock");
            if (message == 0) {
                System.out.println(label);
                System.exit(0);
            } else {
                next.sendMessage(message - 1);
            }
        }
    }
}

 

这个Java版本的threadring实现过于简单,一个Consumer线程执行所有的Node,类似于Actor模式,所以此Java程序耗时极短,约2sec。

由于Java没有coroutine之类的设计,所以Java用真实的thread来模拟threadring更有说服力:

 

/**
 * The Computer Language Benchmarks Game
 * http://shootout.alioth.debian.org/
 * contributed by Klaus Friedel
 */

import java.util.concurrent.locks.LockSupport;

public class threadring {
  static final int THREAD_COUNT = 503;

  public static class MessageThread extends Thread {
    MessageThread nextThread;
    volatile Integer message;

    public MessageThread(MessageThread nextThread, int name) {
      super(""+name);
      this.nextThread = nextThread;
    }

    public void run() {
      while(true) nextThread.enqueue(dequeue());
    }

    public void enqueue(Integer hopsRemaining) {
      if(hopsRemaining == 0){
        System.out.println(getName());
        System.exit(0);
      }
      // as only one message populates the ring, it's impossible
      // that queue is not empty
      message = hopsRemaining - 1;
      LockSupport.unpark(this); // work waiting...
    }

    private Integer dequeue(){
      while(message == null){
        LockSupport.park();
      }
      Integer msg = message;
      message = null;
      return msg;
    }
  }

  public static void main(String args[]) throws Exception{
    int hopCount = Integer.parseInt(args[0]);

    MessageThread first = null;
    MessageThread last = null;
    for (int i = THREAD_COUNT; i >= 1 ; i--) {
      first = new MessageThread(first, i);
      if(i == THREAD_COUNT) last = first;
    }
    // close the ring:
    last.nextThread = first;

    // start all Threads
    MessageThread t = first;
    do{
      t.start();
      t = t.nextThread;
    }while(t != first);
    // inject message
    first.enqueue(hopCount);
    first.join(); // wait for System.exit
  }
}

 这个Java程序则耗时非常长(time java -server threadring 50000000 )。

 

Erlang/Java/Go threadring benchmark

  • 0

    开心

    开心

  • 0

    板砖

    板砖

  • 0

    感动

    感动

  • 0

    有用

    有用

  • 0

    疑问

    疑问

  • 0

    难过

    难过

  • 0

    无聊

    无聊

  • 0

    震惊

    震惊

编辑推荐
C++ vs. Java 1.6 - A fair Benchmark <!----> For one of my small private projects, I wan
以前碰到更多的是WEB APP的性能测试,也许用得最多的是Loadrunner, Web Stress tool之类的常态化工
一、PHP Benchmark实现思路 在看Redis慢查询日志实现的过程中,觉得这个功能很有用,能够帮助快速分
  Sort Benchmark是一个专门从事排序基准评估的非盈利机构,该机构每年都会举办一次排序基准评估
The original link can be found at : http://www.javalobby.org/articles/guice-vs-spring/ At the
The original link can be found at : http://www.javalobby.org/articles/guice-vs-spring/ At the
The original link can be found at : http://www.javalobby.org/articles/guice-vs-spring/ At the
STREAM Benchmark及其操作性能分析 文/raywill STREAM 是业界广为流行的综合性内存带宽实际性能 测
STREAM Benchmark及其操作性能分析 文/raywill STREAM 是业界广为流行的综合性内存带宽实际性能 测
STREAM Benchmark及其操作性能分析 文/raywill STREAM 是业界广为流行的综合性内存带宽实际性能 测
版权所有 IT知识库 CopyRight © 2009-2015 IT知识库 IT610.com , All Rights Reserved. 京ICP备09083238号