【问题标题】:Concurrent cartesian product algorithm in ClojureClojure 中的并发笛卡尔积算法
【发布时间】:2011-02-03 21:40:10
【问题描述】:

Clojure 中是否有很好的算法可以同时计算三个seqs 的笛卡尔积?

我正在从事 Clojure 的一个小型业余项目,主要是作为学习该语言及其并发特性的一种手段。在我的项目中,我需要计算三个seqs 的笛卡尔积(并对结果进行处理)。

我在clojure.contrib.combinatorics 中找到了cartesian-product 函数,效果很好。然而,笛卡尔积的计算结果证明是程序的瓶颈。因此,我想同时进行计算。

现在,对于map 函数,有一个方便的pmap 替代方案可以神奇地使事情并发。这很酷:)。不幸的是,cartesian-product 不存在这样的事情。我已经查看了源代码,但我找不到一个简单的方法让它自己并发。

另外,我尝试使用map 自己实现一个算法,但我想我的算法技能已经不像以前那样了。我设法为两个seqs 想出了一些丑陋的东西,但三个绝对是一座太远的桥梁。

那么,有谁知道已经并发的算法,或者我可以自己并行化的算法?


编辑

换句话说,我真正想要实现的是实现类似于以下 Java 代码的东西:

for (ClassA a : someExpensiveComputation()) {
    for (ClassB b : someOtherExpensiveComputation()) {
        for (ClassC c : andAnotherOne()) {
            // Do something interesting with a, b and c
        }
    }
}

【问题讨论】:

  • 你能记住你昂贵的计算吗?

标签: algorithm concurrency clojure parallel-processing cartesian-product


【解决方案1】:

如果您用于处理笛卡尔积的逻辑不是以某种方式固有的顺序,那么也许您可以将输入分成两半(也许将每个输入序列分成两部分),计算 8 个单独的笛卡尔积(首先- half x first-half x first-half, first-half x first-half x second-half, ...),处理它们,然后组合结果。我希望这已经给你很大的推动力。至于调整笛卡尔积本身的性能,我不是专家,但我确实有一些想法和观察(有时需要为 Project Euler 计算叉积),所以我试图在下面总结它们。

首先,我觉得性能部门的c.c.combinatorics函数有点奇怪。 cmets 说它取自 Knuth,我相信,因此可能获得以下之一:(1)它对向量的性能非常好,但是向量化输入序列的成本会降低其对其他序列类型的性能; (2) 这种编程风格通常在 Clojure 中不一定表现良好; (3) 由于某些设计选择(例如具有该本地功能)而产生的累积开销很大; (4) 我错过了一些非常重要的东西。所以,虽然我不想否认它可能是一个很好的功能,可用于某些用例(由所涉及的序列总数、每个序列中的元素数量等决定),但在我所有的 (不科学)测量一个简单的for 似乎更好。

然后是我的两个功能,其中一个与for相当(我认为在更有趣的测试中会慢一些,虽然在其他测试中它似乎实际上有点快......不能说我感觉准备好进行全面的比较),另一个显然更快,初始输入序列很长,因为它是第一个的受限功能并行版本。 (详情如下。)所以,时间优先(如果你想重复它们,请偶尔输入(System/gc)):

;; a couple warm-up runs ellided
user> (time (last (doall (pcross (range 100) (range 100) (range 100)))))
"Elapsed time: 1130.751258 msecs"
(99 99 99)
user> (time (last (doall (cross (range 100) (range 100) (range 100)))))
"Elapsed time: 2428.642741 msecs"
(99 99 99)
user> (require '[clojure.contrib.combinatorics :as comb])
nil
user> (time (last (doall (comb/cartesian-product (range 100) (range 100) (range 100)))))
"Elapsed time: 7423.131008 msecs"
(99 99 99)
;; a second time, as no warm-up was performed earlier...
user> (time (last (doall (comb/cartesian-product (range 100) (range 100) (range 100)))))
"Elapsed time: 6596.631127 msecs"
(99 99 99)
;; umm... is syntax-quote that expensive?
user> (time (last (doall (for [x (range 100)
                               y (range 100)
                               z (range 100)]
                           `(~x ~x ~x)))))
"Elapsed time: 11029.038047 msecs"
(99 99 99)
user> (time (last (doall (for [x (range 100)
                               y (range 100)
                               z (range 100)]
                           (list x y z)))))
"Elapsed time: 2597.533138 msecs"
(99 99 99)
;; one more time...
user> (time (last (doall (for [x (range 100)
                               y (range 100)
                               z (range 100)]
                           (list x y z)))))
"Elapsed time: 2179.69127 msecs"
(99 99 99)

现在是函数定义:

(defn cross [& seqs]
  (when seqs
    (if-let [s (first seqs)]
      (if-let [ss (next seqs)]
        (for [x  s
              ys (apply cross ss)]
          (cons x ys))
        (map list s)))))

(defn pcross [s1 s2 s3]
  (when (and (first s1)
             (first s2)
             (first s3))
    (let [l1 (count s1)
          [half1 half2] (split-at (quot l1 2) s1)
          s2xs3 (cross s2 s3)
          f1 (future (for [x half1 yz s2xs3] (cons x yz)))
          f2 (future (for [x half2 yz s2xs3] (cons x yz)))]
      (concat @f1 @f2))))

我相信所有版本都会产生相同的结果。 pcross 可以扩展以处理更多序列,或者在分配工作量的方式上更加复杂,但这就是我想出的第一个近似值......如果你用你的程序测试它(也许适应它当然,您的需求),我很想知道结果。

【讨论】:

  • 感谢您的出色回答!不得不在 pcross 中做一个小的调整,因为我正在与 Java 对象交互,我无法在它们上调用 count。一般来说,在我的项目中执行时间是这样的:pcross < cartesian-product < cross。与 pcross 的区别并不像我希望的那么大,但这似乎主要是由于我编写应用程序的方式。我可能有点误判了性能特征。当然,我还有很多关于 Clojure 的知识要学习 :)。
  • 这几乎和cross:(defmacro mcross [& seqs] (let [idents (take (count seqs) (repeatedly gensym)) bindings (mapcat vector idents seqs)] `(for [~@bindings] [~@idents])))一样快——事实上,在某些输入上更快。
【解决方案2】:

'clojure.contrib.combinatorics 具有笛卡尔积函数。 它返回一个惰性序列,可以跨越任意数量的序列。

【讨论】:

  • 原发帖者提到这个功能对于他的需求来说太慢了......
猜你喜欢
  • 2013-08-17
  • 2015-10-21
  • 2021-11-19
  • 2018-02-03
  • 2011-03-24
  • 2017-03-07
  • 1970-01-01
  • 2020-08-12
  • 2013-10-22
相关资源
最近更新 更多