Clojure 为什么这个主筛的实现比较慢？

我只是在尝试一种新的编程语言：clojure。我编写了一个相当幼稚的“筛”实现，然后尝试对其进行一些优化

但奇怪的是（至少对我来说），新的实现速度并不快，但要慢得多

有人能提供一些见解来解释为什么这要慢得多吗

我还对如何改进此算法的其他技巧感兴趣

致以最良好的祝愿

阿尔诺·古德

; naive sieve. 
(defn sieve
  ([max] (sieve max (range 2 max) 2))
  ([max candidates n]
    (if (> (* n n) max)
      candidates
      (recur max (filter #(or (= % n) (not (= (mod % n) 0))) candidates) (inc n)))))

; Instead of just passing the 'candidates' list, from which I sieve-out the non-primes,
; I also pass a 'primes' list, with the already found primes
; I hoped that this would increase the speed, because:
; - Instead of sieving-out multiples of 'all' numbers, I now only sieve-out the multiples of primes.
; - The filter predicate now becomes simpler.
; However, this code seems to be approx 20x as slow.
; Note: the primes in 'primes' end up reversed, but I don't care (much). Adding a 'reverse' call makes it even slower :-(
(defn sieve2 
  ([max] (sieve2 max () (range 2 max)))
  ([max primes candidates]
    (let [n (first candidates)]
      (if (> (* n n) max)
        (concat primes candidates)
        (recur max (conj primes n) (filter #(not (= (mod % n) 0)) (rest candidates)))))))

; Another attempt to speed things up. Instead of sieving-out multiples of all numbers in the range,
; I want to sieve-out only multiples of primes.. I don't like the '(first (filter ' construct very much...
; It doesn't seem to be faster than 'sieve'.
(defn sieve3
  ([max] (sieve max (range 2 max) 2))
  ([max candidates n]
    (if (> (* n n) max)
      candidates
      (let [new_candidates (filter #(or (= % n) (not (= (mod % n) 0))) candidates)]
        (recur max new_candidates (first (filter #(> % n) new_candidates)))))))

(time (sieve 10000000))
(time (sieve 10000000))
(time (sieve2 10000000))
(time (sieve2 10000000))
(time (sieve2 10000000))
(time (sieve 10000000)) ; Strange, speeds are very different now... Must be some memory allocation thing caused by running sieve2
(time (sieve 10000000))
(time (sieve3 10000000))
(time (sieve3 10000000))
(time (sieve 10000000))

---

这类数字密集型数学的一些优化技巧：

使用clojure 1.3
clonjure 1.3允许未装箱的检查算术，所以您不会将所有内容都转换为整数

键入函数参数的提示 否则，您将为每个函数调用将所有整数/长整数转换为整数。（您没有调用任何可提示的函数，因此我只是将其列在这里作为一般建议）

不要调用任何高阶函数。 目前（1.3）lambda函数#（…）不能编译为^static，因此它们只接受对象作为参数。因此，对

filter

的调用需要对所有数字进行装箱

---

在装箱/取消装箱整数/整数时可能会浪费足够的时间，这将使您很难真正判断不同的优化。如果您键入hint（并使用Clojure1.3），那么您可能会得到更好的数字来判断您的优化

我有好消息和坏消息。好消息是你的直觉是正确的

(time (sieve 10000)) ; "Elapsed time: 0.265311 msecs"

(2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199 211 223 227 229 233 239 241 251 257 263 269 271 277 281 283 293 307 311 313 317 331 337 347 349 353 359 367 373 379 383 389 397 401 409 419 421 431 433 439 443 449 457 461 463 467 479 487 491 499 503 509 521 523 541 547 557 563 ...)

(time (sieve2 10000)) ; "Elapsed time: 1.028353 msecs"

(2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199 211 223 227 229 233 239 241 251 257 263 269 271 277 281 283 293 307 311 313 317 331 337 347 349 353 359 367 373 379 383 389 397 401 409 419 421 431 433 439 443 449 457 461 463 467 479 487 491 499 503 509 521 523 541 547 557 563 ...)

坏消息是，两者的速度都比你想象的慢得多

(time (count (sieve 10000))) ; "Elapsed time: 231.183055 msecs"
1229

(time (count (sieve2 10000))) ; "Elapsed time: 87.822796 msecs"
1229

发生的事情是，因为过滤器是惰性的，所以在需要打印答案之前，过滤是不会完成的。第一个表达式计算的是将序列包装到过滤器负载中的时间。输入计数意味着序列实际上必须在计时表达式中进行计算，然后您可以看到它实际需要多长时间

我认为在没有计数的情况下，sive2需要更长的时间，因为它在构建过滤序列时做了一些工作

当你把计数加进去时，sive2更快，因为它是更好的算法

---

另外，当我尝试（time（sieve 10000000））时，我的机器因堆栈溢出而崩溃，可能是因为它正在生成大量嵌套的过滤器调用。它为什么会为您运行？

我无法复制源代码，它在行尾被截断。很抱歉。。。现在代码应该已经完成了。速度的显著提高可能是由于多次运行后JIT编译器的启动。。。。。为了避免出现这种情况，您需要确保在实际计时之前，运行计划对其进行基准测试的任何代码几次effect@Arnaud：是原始代码中的

sieve3

调用

sieve

，还是打字错误？@Arnaud：检查链接到的答案中的注释（带有锚文本）在我之前的评论中，我喜欢你们的优化技巧，但这并不能回答为什么我的sieve2比sieve2慢这么多。这就是我想知道的。谢谢你的解释。这正好解释了我所看到的！关于堆栈溢出：如果没有“count”调用，我就无法理解。。。但当我加上它的时候，我就明白了。