Question

我刚刚阅读了Go的一些简短教程，并编写了一个简单的程序筛。 Sieve使用sieve算法来打印所有小于10000的质数，这会创建许多go例程。我得到了正确的结果，但是程序非常慢（在我的计算机上为5秒）。我还编写了实现相同算法的lua脚本和python脚本，并且运行速度更快（两者在我的计算机上均为1秒左右）。

请注意，这样做的目的是要了解go例程与其他语言（例如lua）中的协程相比的性能。该实现效率很低，一些评论指出，这不是实现Eratosthenes筛网的正确方法。是的，这是故意的。其他一些答复指出，速度慢是由打印I / O引起的。所以我注释了打印行。

我的问题是，为什么我在Go中实现的筛分程序这么慢？这是代码：

package main

import (
  "fmt"
  "sync"
)


type Sieve struct {
  id int;
  msg_queue chan int;
  wg *sync.WaitGroup;
}


func NewSieve(id int) *Sieve {
  sieve := new(Sieve)
  sieve.id = id
  sieve.msg_queue = make(chan int)
  sieve.wg = new(sync.WaitGroup)
  sieve.wg.Add(1)
  return sieve
}


func (sieve *Sieve) run() {
  defer sieve.wg.Done()

  myprime := <-sieve.msg_queue
  if myprime == 0 {
    return
  }
  // fmt.Printf("Sieve (%d) is for prime number %d.\n", sieve.id, myprime)

  next_sieve := NewSieve(sieve.id + 1)
  go next_sieve.run()
  for {
    number := <-sieve.msg_queue
    if number == 0 {
      next_sieve.msg_queue <- number;
      next_sieve.wg.Wait()
      return
    } else if number % myprime != 0 {
      // fmt.Printf("id: %d, number: %d, myprime: %d, number mod myprime: %d\n", sieve.id, number, myprime, number % myprime)
      next_sieve.msg_queue <- number
    }
  }
}


func driver() {
  first := NewSieve(2)
  go first.run()
  for n := 2; n <= 10000; n++ {
    first.msg_queue <- n
  }
  first.msg_queue <- 0
  first.wg.Wait()
}


func main() {
  driver()
}

作为比较，这是sieve.lua的代码

function sieve(id)
  local myprime = coroutine.yield()
  // print(string.format("Sieve (%d) is for prime number %d", id, myprime))

  local next_sieve = coroutine.create(sieve)
  coroutine.resume(next_sieve, id + 1)

  while true do
    local number = coroutine.yield()
    if number % myprime ~= 0 then
      // print(string.format("id: %d, number: %d, myprime: %d, number mod myprime: %d", id, number, myprime, number % myprime))
      coroutine.resume(next_sieve, number)
    end
  end
end


function driver()
  local first = coroutine.create(sieve)
  coroutine.resume(first, 2)
  local n
  for n = 2, 10000 do
    coroutine.resume(first, n)
  end
end

driver()

Answer 1

无意义的微基准测试将产生毫无意义的结果。

您正在定时打印I / O。

您要花少量时间去执行例行程序和通道开销。

这是Go中的质数筛选程序。

输出：

$ go version
go version devel +46be01f4e0 Sun Oct 13 01:48:30 2019 +0000 linux/amd64
$ go build sumprimes.go && time ./sumprimes
5736396
29.96µs   
real    0m0.001s
user    0m0.001s
sys     0m0.000s

sumprimes.go：

package main

import (
    "fmt"
    "time"
)

const (
    prime    = 0x00
    notprime = 0xFF
)

func oddPrimes(n uint64) (sieve []uint8) {
    sieve = make([]uint8, (n+1)/2)
    sieve[0] = notprime
    p := uint64(3)
    for i := p * p; i <= n; i = p * p {
        for j := i; j <= n; j += 2 * p {
            sieve[j/2] = notprime
        }
        for p += 2; sieve[p/2] == notprime; p += 2 {
        }
    }
    return sieve
}

func sumPrimes(n uint64) uint64 {
    sum := uint64(0)
    if n >= 2 {
        sum += 2
    }
    for i, p := range oddPrimes(n) {
        if p == prime {
            sum += 2*uint64(i) + 1
        }
    }
    return sum
}

func main() {
    start := time.Now()

    var n uint64 = 10000
    sum := sumPrimes(n)
    fmt.Println(sum)

    fmt.Println(time.Since(start))
}

Answer 2

大部分时间都花在fmt.Printf中。

得出结论：

fmt.Printf("id: %d, number: %d, myprime: %d, number mod myprime: %d\n", sieve.id, number, myprime, number%myprime)

在我进行的一项测试中，运行时间从约5.4秒减少到了约0.64秒。

排除不必要的sync.WaitGroup可以将时间进一步减少到〜0.48秒。 See the version without sync.WaitGroup here.您仍在执行许多通道操作，而那些使用协程收益率值的运算符的语言则不需要（尽管它们有自己的问题）。这不是实施素数测试的好方法。

为什么这个Go程序这么慢？

2 个答案: