样式问题

Question

上下文

我需要使用多线程进行计算。我使用SBCL，可移植性不是问题。我知道bordeaux-threads和lparallel存在，但是我想在特定SBCL线程实现所提供的相对较低的级别上实现某些东西。我需要最大的速度，即使是以可读性/编程努力为代价的。

计算密集型操作示例

我们可以定义一个足够的计算密集型函数，该函数将从多线程中受益。

(defun intensive-sqrt (x)
  "Dummy calculation for intensive algorithm.
Approx 50 ms for 1e6 iterations."
  (let ((y x))
    (dotimes (it 1000000 t)
      (if (> y 1.01d0)
          (setf y (sqrt y))
          (setf y (* y y y))))
    y))

将每个计算映射到一个线程并执行

给定参数列表llarg和函数fun的列表，我们要计算nthreads的结果并返回结果列表res-list。这是我使用发现的资源想到的（请参见下文）。

(defmacro splice-arglist-help (fun arglist)
  "Helper macro.
   Splices a list 'arglist' (arg1 arg2 ...) into the function call of 'fun'
   Returns (funcall fun arg1 arg2 ...)"
  `(funcall ,fun ,@arglist))

(defun splice-arglist (fun arglist)
  (eval `(splice-arglist-help ,fun ,arglist)))

(defun maplist-fun-multi (fun llarg nthreads)
  "Maps 'fun' over list of argument lists 'llarg' using multithreading.
   Breaks up llarg and feeds it to each thread.
   Appends all the result lists at the end."
  (let ((thread-list nil)
        (res-list nil))
    ;; Create and run threads
    (dotimes (it nthreads t)
      (let ((larg-temp (elt llarg it)))
        (setf thread-list (append thread-list
                                  (list (sb-thread:make-thread
                                         (lambda ()
                                           (splice-arglist fun larg-temp))))))))
    ;; Join threads
    ;; Threads are joined in order, not optimal for speed.
    ;; Should be joined when finished ?
    (dotimes (it (list-length thread-list) t)
      (setf res-list (append res-list (list (sb-thread:join-thread (elt thread-list it))))))
    res-list))

nthreads不一定与llarg的长度匹配，但是为了简单起见，我避免了额外的簿记。我还省略了用于优化的各种declare。

我们可以使用以下命令测试多线程并比较时间：

(defparameter *test-args-sqrt-long* nil)
(dotimes (it 10000 t)
  (push (list (+ 3d0 it)) *test-args-sqrt-long*))

(time (intensive-sqrt 5d0))
(time (maplist-fun-multi #'intensive-sqrt *test-args-sqrt-long* 100))

线程数很高。我认为最佳方法是使用与CPU一样多的线程，但是我注意到性能下降在时间/操作方面几乎不明显。进行更多操作将涉及将输入列表分成较小的部分。

以上代码在2核/ 4线程计算机上输出：

Evaluation took:
  0.029 seconds of real time
  0.015625 seconds of total run time (0.015625 user, 0.000000 system)
  55.17% CPU
  71,972,879 processor cycles
  22,151,168 bytes consed

Evaluation took:
  1.415 seconds of real time
  4.703125 seconds of total run time (4.437500 user, 0.265625 system)
  [ Run times consist of 0.205 seconds GC time, and 4.499 seconds non-GC time. ]
  332.37% CPU
  3,530,632,834 processor cycles
  2,215,345,584 bytes consed

我在烦什么

我给出的示例效果很好并且很健壮（即结果不会在线程之间混淆，并且我不会崩溃）。速度增益也在那里，并且计算确实在我测试过此代码的机器上使用了多个内核/线程。但是，我希望在以下方面提供一些意见/帮助：

使用参数列表llarg和larg-temp。这真的必要吗？有什么方法可以避免操纵潜在的庞大列表？
线程按照它们在thread-list中存储的顺序进行连接。我想如果每个操作花费不同的时间来完成，那将不是最佳选择。有没有一种方法可以在完成每个线程时加入它们，而不是等待它们？

答案应该在我已经找到的资源中，但是我发现更难处理的更高级的东西。

到目前为止找到的资源

Answer 1

样式问题

根本不需要splice-arglist助手（因此我也将跳过其中的详细信息）。在您的线程函数中改用apply：
```
(lambda ()
  (apply fun larg-temp))
```
您不需要（也不应该）索引到列表中，因为对于每个查找而言，它都是 O（n）-您的循环是二次的。使用dolist进行简单的副作用循环，或者使用loop进行e处理。 G。并行迭代：
```
(loop :repeat nthreads
      :for args :in llarg
      :collect (sb-thread:make-thread (lambda () (apply fun args))))
```
要在创建具有相同长度的新列表（其中每个元素都是根据源列表中的对应元素计算得出）的同时遍历列表，请使用mapcar：
```
(mapcar #'sb-thread:join-thread threads)
```

您的功能将变为：

(defun map-args-parallel (fun arglists nthreads)
  (let ((threads (loop :repeat nthreads
                       :for args :in arglists
                       :collect (sb-thread:make-thread
                                 (lambda ()
                                   (apply fun args))))))
    (mapcar #'sb-thread:join-thread threads)))

性能

您是对的，通常创建的线程数最多只能等于ca。可用内核数。如果您通过始终创建 n 个线程，然后将它们加入，然后进行下一个批处理来测试性能，那么您的性能确实不会有太大差异。那是因为效率低下在于创建线程。线程与进程一样耗费资源。

通常要做的是创建一个线程池，在该线程池中，线程不会被联接，而是被重用。为此，您需要某种其他机制来传递参数和结果，例如。 G。渠道（例如来自chanl的渠道）。

但是请注意e。 G。 lparallel已经提供了pmap函数，并且可以正常运行。这种包装库的目的不仅是为用户（程序员）提供一个不错的界面，而且还要认真思考问题并明智地进行优化。我非常有信心pmap将比您的尝试快得多。

在SBCL中进行多线程计算的正确方法

上下文

计算密集型操作示例

将每个计算映射到一个线程并执行

我在烦什么

到目前为止找到的资源

1 个答案:

样式问题

性能