Question

我的空间泄漏发生在我的一个个人项目中。但我不希望有人在我的项目中解决它。我想了解它。

我通过编写这个算法来重现我的空间泄漏：

u是由：

定义的序列

u（0）= 1
u（1）= 2
u（2）= 1
u（4）= 3
...
u（19）= 11

之后定义：u（n）= u（n-5）+ u（n-10） - u（n-15）

在haskell中易于实现吗？

valve.notes = "#{valve.notes}\nDirection: North"

valve.changed?                      
#=> true

不幸的是，这个空间泄漏了：

import System.Environment (getArgs)

u = [1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 1, 7, 1, 8, 1, 9, 1, 10, 1, 11]
        ++ zipWith3 go u' u'' u'''
    where u' = drop 15 u
          u'' = drop 10 u
          u''' = drop 5 u
          go a b c = a + b - c

main = do
    args <- getArgs
    let n = read $ args !! 0
    putStrLn $ show $ u !! n

似乎haskell正在缓存整个列表，我希望它只缓存最后20个元素。

例如，这是我在C中的实现：

$ time ./algo 9999999
Stack space overflow: current size 8388608 bytes.
Use `+RTS -Ksize -RTS' to increase it.
1.17user 0.19system 0:01.37elapsed 100%CPU (0avgtext+0avgdata 865124maxresident)k
0inputs+0outputs (0major+215695minor)pagefaults 0swaps

#include <stdint.h>
#include <stdio.h>

int main(int argc, char **argv)
{
    size_t cursor;
    int64_t buffer[20] = {1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 1, 7, 1, 8, 1, 9, 1, 10, 1, 11};
    int n = atoi(argv[1]);

    for (cursor = 20; cursor <= n; cursor++) {
        buffer[cursor%20] = buffer[(cursor+20-5)%20] + buffer[(cursor+20-10)%20] - buffer[(cursor+20-15)%20];
    }

    printf("%d\n", buffer[n%20]);
    return 0;

}

我的C实现使用O（n）时间和O（1）空间。但看起来我的haskell实现正在使用O（n）空间。

为什么Haskell能够为fibonnacci计算出来，但不能用于我的编组序列？我做错了什么？你将如何在Haskell中实现这个算法？

Answer 1

这是一个堆栈溢出，但你也有空间泄漏，这很容易解释。

执行索引u !! n时，u看起来像

1 : 2 : 1 : ... : 11 : <go thunk> : ... : <go thunk> : <zipWith3 thunk>

并提取列表<go thunk>中索引n的最后一个u。此时，每个<go thunk>都引用了u的早期元素，因此（几乎）u的整体必须保留在内存中（实际上不需要前五个元素））。

堆栈溢出是为了评估u的9999999th元素，首先必须评估9999994th元素，并且为了评估您首先必须评估9999989th元素，等等。之后怎么办，比如说，评估9999994th元素以完成对9999999th元素的评估进入堆栈，并且存在堆栈溢出（我想这也是一种空间泄漏）。

这两个问题都可以通过强制列表u的元素来解决，无论是在构造它时还是在遍历它时。既然你说你不希望有人解决空间泄漏问题，我会把这部分留作练习，尽管有一种特别光滑且可能不那么明显的方法。

编辑添加：我想到的光滑但可能太聪明的修复只是将最后一行更改为

    putStrLn $ show $ foldr ((:) $!) [] u !! n

可能理解它的工作原理本身就是一个充分的练习。

更直接的方法是在max taldykin的答案中，或者编写一个自定义索引函数，在丢弃它们之前强制它跳过的元素。

Answer 2

以下是Reid Barton回答的代码：

{-# LANGUAGE BangPatterns #-}
import System.Environment (getArgs)

u :: [Int]
u = [1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 1, 7, 1, 8, 1, 9, 1, 10, 1, 11]
        ++ go u' u'' u'''
    where u' = drop 15 u
          u'' = drop 10 u
          u''' = drop 5 u
          go ((!a):as) ((!b):bs) ((!c):cs)
            = a + b - c
            : go as bs cs

它使用BangPatterns扩展来强制评估thunk。（我还添加了类型注释来使用Int而不是Integer，这有点快。）

您可以看到它在恒定空间中运行（1M in use是输出的相关部分）：

$ ./xx 99999999 +RTS -t
50000001
<<ghc: 8000065016 bytes, 15319 GCs, 36596/44312 avg/max bytes residency (2 samples), 1M in use, 0.00 INIT (0.00 elapsed), 2.82 MUT (2.78 elapsed), 0.01 GC (0.06 elapsed) :ghc>>

使用递归列表zipWith进行空间泄漏

2 个答案: