为什么`(map digitalToInt) . show`这么快?

2024-03-07

转换非负数Integer其数字列表通常是这样完成的:

import Data.Char

digits :: Integer -> [Int]
digits = (map digitToInt) . show

我试图找到一种更直接的方法来执行任务,而不涉及字符串转换,但我无法想出更快的方法。

到目前为止我一直在尝试的事情:

基线:

digits :: Int -> [Int]
digits = (map digitToInt) . show

从 StackOverflow 上的另一个问题得到这个:

digits2 :: Int -> [Int]
digits2 = map (`mod` 10) . reverse . takeWhile (> 0) . iterate (`div` 10)

尝试推出我自己的:

digits3 :: Int -> [Int]
digits3 = reverse . revDigits3

revDigits3 :: Int -> [Int]
revDigits3 n = case divMod n 10 of
               (0, digit) -> [digit]
               (rest, digit) -> digit:(revDigits3 rest)

这个的灵感来自于showInt in Numeric:

digits4 n0 = go n0 [] where
    go n cs
        | n < 10    =  n:cs
        | otherwise =  go q (r:cs)
        where
        (q,r) = n `quotRem` 10

现在是基准。注意:我强制使用filter.

λ>:set +s
λ>length $ filter (>5) $ concat $ map (digits) [1..1000000]
2400000
(1.58 secs, 771212628 bytes)

这是参考。现在为digits2:

λ>length $ filter (>5) $ concat $ map (digits2) [1..1000000]
2400000
(5.47 secs, 1256170448 bytes)

That's 3.46时间更长。

λ>length $ filter (>5) $ concat $ map (digits3) [1..1000000]
2400000
(7.74 secs, 1365486528 bytes)

digits3 is 4.89时间变慢。只是为了好玩,我尝试仅使用 revDigits3 并避免reverse.

λ>length $ filter (>5) $ concat $ map (revDigits3) [1..1000000]
2400000
(8.28 secs, 1277538760 bytes)

奇怪的是,这甚至更慢,5.24慢几倍。

最后一张:

λ>length $ filter (>5) $ concat $ map (digits4) [1..1000000]
2400000
(16.48 secs, 1779445968 bytes)

This is 10.43时间变慢。

我的印象是,仅使用算术和缺点会优于涉及字符串转换的任何内容。显然,有些东西我无法理解。

那么有什么窍门呢?为什么是digits很快?

我正在使用 GHC 6.12.3。


鉴于我还无法添加评论,我将做更多工作并分析所有评论。我把分析放在最上面;不过,相关数据如下。 (注意:所有这些都是在 6.12.3 中完成的 - 还没有 GHC 7 魔法。)


分析:

版本1:show 对于整数来说非常好,尤其是像我们这样短的整数。实际上,在 GHC 中制作字符串往往是不错的;然而,读取字符串并将大字符串写入文件(或标准输出,尽管您不想这样做)是您的代码绝对可以抓取的地方。我怀疑为什么这么快背后的很多细节都是由于 Ints 显示中的巧妙优化。

版本2:编译时,这是其中最慢的一个。一些问题:反向论证的严格性。这意味着在计算下一个元素时,您无法从对列表的第一部分执行计算中受益;您必须计算所有它们,翻转它们,然后对列表的元素进行计算(即 (`mod` 10) )。虽然这看起来很小,但它可能会导致更大的内存使用量(请注意此处分配的 5GB 堆内存)和更慢的计算速度。 (长话短说:不要使用反向。)

版本3:还记得我刚才说过不要使用反向吗?事实证明,如果你把它拿出来,总执行时间会下降到 1.79 秒——仅比基线慢一点。这里唯一的问题是,当你深入了解数字时,你会以错误的方向构建列表的主干(本质上,你是通过递归“进入”列表,而不是“进入”列表)列表)。

版本 4:这是一个非常巧妙的实现。您可以从几件好事中受益:首先,quotRem 应该使用欧几里得算法,该算法的较大参数是对数的。 (也许它更快,但我不相信有什么比欧几里得更快的常数因子。)此外,您可以像上次讨论的那样对列表进行操作,这样您就不必在处理时解决任何列表重击问题。 go - 当您返回解析列表时,列表已经完全构建完毕。如您所见,性能由此受益。

这段代码可能是 GHCi 中最慢的,因为 GHC 中使用 -O3 标志执行的许多优化都是为了使列表更快,而 GHCi 不会这样做。

Lessons:以正确的方式将 cons 放入列表中,注意可能减慢计算速度的中间严格性,并做一些跑腿工作来查看代码性能的细粒度统计数据。还要使用 -O3 标志进行编译:只要你不这样做,所有那些花费大量时间使 GHC 超快的人都会对你大眼瞪小眼。


Data:

我只是将所有四个函数粘贴到一个 .hs 文件中,然后根据需要进行更改以反映正在使用的函数。另外,我将限制提高到 5e6,因为在某些情况下,编译的代码在 1e6 上运行时间不到半秒,这可能会导致我们正在进行的测量出现粒度问题。

编译器选项:使用ghc --make -O3 [文件名].hs让 GHC 做一些优化。我们将使用以下命令将统计数据转储到标准错误数字+RTS -sstderr.

在数字 1 的情况下,转储到 -stderr 会得到如下所示的输出:

digits1 +RTS -sstderr
12000000
   2,885,827,628 bytes allocated in the heap
         446,080 bytes copied during GC
           3,224 bytes maximum residency (1 sample(s))
          12,100 bytes maximum slop
               1 MB total memory in use (0 MB lost due to fragmentation)

  Generation 0:  5504 collections,     0 parallel,  0.06s,  0.03s elapsed
  Generation 1:     1 collections,     0 parallel,  0.00s,  0.00s elapsed

  INIT  time    0.00s  (  0.00s elapsed)
  MUT   time    1.61s  (  1.66s elapsed)
  GC    time    0.06s  (  0.03s elapsed)
  EXIT  time    0.00s  (  0.00s elapsed)
  Total time    1.67s  (  1.69s elapsed)

  %GC time       3.7%  (1.5% elapsed)

  Alloc rate    1,795,998,050 bytes per MUT second

  Productivity  96.3% of total user, 95.2% of total elapsed

这里有三个关键统计数据:

  1. 使用的总内存:仅 1MB 意味着该版本非常节省空间。
  2. 总时间:1.61 秒现在没有任何意义,但我们将看看它与其他实现相比如何。
  3. 生产力:这只是 100% 减去垃圾收集;因为我们已经完成了 96.3%,这意味着我们没有创建大量留在内存中的对象。

好吧,让我们继续讨论版本 2。

digits2 +RTS -sstderr
12000000
   5,512,869,824 bytes allocated in the heap
       1,312,416 bytes copied during GC
           3,336 bytes maximum residency (1 sample(s))
          13,048 bytes maximum slop
               1 MB total memory in use (0 MB lost due to fragmentation)

  Generation 0: 10515 collections,     0 parallel,  0.06s,  0.04s elapsed
  Generation 1:     1 collections,     0 parallel,  0.00s,  0.00s elapsed

  INIT  time    0.00s  (  0.00s elapsed)
  MUT   time    3.20s  (  3.25s elapsed)
  GC    time    0.06s  (  0.04s elapsed)
  EXIT  time    0.00s  (  0.00s elapsed)
  Total time    3.26s  (  3.29s elapsed)

  %GC time       1.9%  (1.2% elapsed)

  Alloc rate    1,723,838,984 bytes per MUT second

  Productivity  98.1% of total user, 97.1% of total elapsed

好吧,我们看到了一个有趣的模式。

  1. 使用相同数量的内存。这意味着这是一个非常好的实现,尽管这可能意味着我们需要测试更高的样本输入以查看是否可以找到差异。
  2. 需要两倍的时间。我们稍后会回过头来猜测为什么会这样。
  3. 它实际上稍微更有效率,但考虑到 GC 并不是这两个程序的很大一部分,这对我们没有任何重大帮助。

版本3:

digits3 +RTS -sstderr
12000000
   3,231,154,752 bytes allocated in the heap
         832,724 bytes copied during GC
           3,292 bytes maximum residency (1 sample(s))
          12,100 bytes maximum slop
               1 MB total memory in use (0 MB lost due to fragmentation)

  Generation 0:  6163 collections,     0 parallel,  0.02s,  0.02s elapsed
  Generation 1:     1 collections,     0 parallel,  0.00s,  0.00s elapsed

  INIT  time    0.00s  (  0.00s elapsed)
  MUT   time    2.09s  (  2.08s elapsed)
  GC    time    0.02s  (  0.02s elapsed)
  EXIT  time    0.00s  (  0.00s elapsed)
  Total time    2.11s  (  2.10s elapsed)

  %GC time       0.7%  (1.0% elapsed)

  Alloc rate    1,545,701,615 bytes per MUT second

  Productivity  99.3% of total user, 99.3% of total elapsed

好吧,我们看到了一些奇怪的模式。

  1. 我们的总内存使用量仍为 1MB。所以我们没有遇到任何内存效率低下的问题,这很好。
  2. 我们还没有完全达到“digits1”,但我们已经很容易击败“digits2”了。
  3. GC 很少。 (请记住,任何超过 95% 的生产率都非常好,因此我们在这里并没有真正处理任何太重要的事情。)

最后是版本 4:

digits4 +RTS -sstderr
12000000
   1,347,856,636 bytes allocated in the heap
         270,692 bytes copied during GC
           3,180 bytes maximum residency (1 sample(s))
          12,100 bytes maximum slop
               1 MB total memory in use (0 MB lost due to fragmentation)

  Generation 0:  2570 collections,     0 parallel,  0.00s,  0.01s elapsed
  Generation 1:     1 collections,     0 parallel,  0.00s,  0.00s elapsed

  INIT  time    0.00s  (  0.00s elapsed)
  MUT   time    1.09s  (  1.08s elapsed)
  GC    time    0.00s  (  0.01s elapsed)
  EXIT  time    0.00s  (  0.00s elapsed)
  Total time    1.09s  (  1.09s elapsed)

  %GC time       0.0%  (0.8% elapsed)

  Alloc rate    1,234,293,036 bytes per MUT second

  Productivity 100.0% of total user, 100.5% of total elapsed

哇扎!让我们来分解一下:

  1. 总共仍然是 1MB。这几乎肯定是这些实现的一个特性,因为它们在 5e5 和 5e7 的输入上保持在 1MB。如果你愿意的话,这是懒惰的证明。
  2. 我们削减了大约 32% 的原始时间,这非常令人印象深刻。
  3. 我怀疑这里的百分比反映了 -sstderr 监控的粒度,而不是对超光速粒子的任何计算。
本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系:hwhale#tublm.com(使用前将#替换为@)

为什么`(map digitalToInt) . show`这么快? 的相关文章

  • 更改为通用接口对性能的影响

    我使用 Visual Studio 使用 C NET 开发应用程序 ReSharper 在我的方法原型中经常建议我用更通用的类型替换输入参数的类型 例如 如果我仅在方法主体中使用带有 foreach 的列表 则使用 List 和 IEnum
  • 为什么 Python 对于一个简单的 for 循环来说这么慢?

    我们正在做一些kNN and SVDPython 中的实现 其他人选择了 Java 我们的执行时间非常不同 我使用 cProfile 来查看我在哪里犯了错误 但一切都很好fine http wiki python org moin Pyth
  • ElasticSearch 匹配多个前缀术语

    我试图为 ElasticSearch 提供一个包含多个术语的查询 然后给出匹配的文档 其中指定的术语位于目标字段中的任何位置 这些术语可以是完整的单词或单词前缀 示例文档 msg 你好 我是一条短信 示例查询字符串 你好消息 你好 和 消息
  • 为什么在我的例子中 For 循环比 Map、Reduce 和 List 理解更快

    我编写了一个简单的脚本来测试速度 这就是我发现的结果 实际上 for 循环在我的例子中是最快的 这真的让我感到惊讶 请查看下面 正在计算平方和 这是因为它在内存中保存列表还是有意为之 谁能解释一下这一点 from functools imp
  • 存在函数依赖关系时类型推断如何工作

    考虑下面的代码 LANGUAGE MultiParamTypeClasses FlexibleInstances FunctionalDependencies UndecidableInstances FlexibleContexts cl
  • 我应该使用什么递归方案来重复有效的操作,直到其结果符合某些标准?

    也就是说 我要问的是一个循环 effectful Int gt IO Int effectful n do putStrLn Effect show n return n condition 3 final Int gt IO final
  • MySQL InnoDB 查询性能

    我正在尝试优化一个简单的 sql 查询 该查询将多次运行大量数据 这是场景 MySQL 与 InnoDB 表 where 和 join 中使用的所有字段都已索引 表有 FK 我不需要查询的整个缓存 但每个表的缓存是可能的 表有更多的更新 插
  • 在 Haskell 命令行应用程序中提示输入密码

    以下 Haskell 程序提示用户在终端中输入密码 如果输入正确则继续 main do putStrLn Password password lt getLine case hash password member database of
  • 非阻塞方法中的饥饿

    一段时间以来 我一直在阅读有关非阻塞方法的内容 这是一段所谓的无锁计数器的代码 public class CasCounter private SimulatedCAS value public int getValue return va
  • 嵌套在其他 monad 中的 IO 操作未执行

    我有一个 foobar IO ParseResult String String ParseResult 是一个在这里定义的 monad https hackage haskell org package haskell src exts
  • 有什么方法可以在 do / while / let 块中打印出变量的类型吗?

    有没有办法打印出嵌套变量的推断类型ghci 考虑代码 let f g where g x Int x 那么 最好查询一下类型g e g t f g会打印出Int gt Int 您可以通过给出适当的错误类型注释并检查错误消息来诱骗此信息 Ma
  • 管道中缺少 ResourceT 实例

    我在尝试使用时遇到奇怪的错误ResourceT http hackage haskell org package conduit 1 0 9 1 docs Data Conduit html t 3aResourceT来自管道 1 0 9
  • 嵌套辅助函数和性能

    嵌套辅助函数对于使代码更易于理解非常有用 谷歌甚至建议在他们的应用程序中使用嵌套函数时尚指南 https google styleguide googlecode com svn trunk javascriptguide xml Nest
  • 使用 Haskell 将函数注入到 Java .class 文件中

    我使用 Haskell 编写了一个 Java 字节码解析器 它工作得很好 然而下一步让我完全难住了 我的 Haskell 程序需要修改 class 文件 以便在执行时 Java 程序打印 输入 此处的方法名称 在执行方法之前 并且 退出 此
  • 为什么解析器组合器“seq”用“bind”和“return”定义?

    我正在读这个article http eprints nottingham ac uk 237 1 monparsing pdf关于解析器组合器并且不理解以下内容 他们说使用seq 见下文 导致解析器将嵌套元组作为结果 操作起来很混乱 se
  • 比较运算符性能 <= 与 !=

    让我们首先声明代码可读性胜过微优化 我们应该将其留给编译器 这只是一个奇怪的案例 具体细节似乎与一般建议相比很有趣 因此 我在搞素数生成器函数 并提出了一种奇怪的行为 其中 人们建议效率最高 实际上效率最低 而 C private stat
  • 为什么 Haskell 中的点是从右向左排列的?

    如果我们有两个函数 f and g 然后在哈斯克尔h f g相当于h x f g x IE 这些函数从右到左应用于输入 有什么根本原因可以解释为什么它是从右到左 而不是从左到右吗 IE 他们为什么不做h f g相当于h x g f x 反而
  • 隐藏类以及 {} 对象与自定义构造函数之间的等效性 (v8)

    鉴于这篇文章 http richardartoul github io jekyll update 2015 04 26 hidden classes html http richardartoul github io jekyll upd
  • 是否可以提高 Mongoexport 速度?

    我有一个 1 3 亿行的 MongoDB 3 6 2 0 集合 它有几个简单的字段和 2 个带有嵌套 JSON 文档的字段 数据以压缩格式 zlib 存储 我需要尽快将其中一个嵌入字段导出为 JSON 格式 然而 mongoexport 需
  • Haskell 类型定义,=> 等

    我正在使用 Learn You a Haskell 来学习 Haskell 第 54 页上有一个 像这样执行 take Num i Ord i gt i gt a gt a take n n lt 0 take take n x xs x

随机推荐