标签: parallel-processing

我的问题是如何利用 iMac 的多个核心来使 gganimate 运行得更快。还有另一个问题（更多链接在下面）询问同样的事情\xe2\x80\x94我的问题是关于这个问题的答案：加速 gganimate Rendering。

在该答案中，Roman 和 mhovd 指出了此GitHub 评论中的一个示例（另请参阅此 GitHub 帖子）：

library(gganimate)\nlibrary(future)\n\nanim <- ggplot(mtcars, aes(mpg, disp)) +\n  transition_states(gear, transition_length = 2, state_length = 1) +\n  enter_fade() +\n  exit_fade()\n\nfuture::plan("sequential")  ## default\nt0 <- system.time(animate(anim))\nprint(t0)\n\nfuture::plan("multiprocess", workers = 4L)\nt1 <- system.time(animate(anim))\nprint(t1)\n

我已经尝试过这个，但得到的时间彼此非常接近：

     user    system   elapsed \n1.0041475 0.9775679 0.9995509 \n

除了这段代码之外，我还需要做些什么吗？根据上述 StackOverflow 答案或 GitHub 页面，我无法判断这段代码是否应该按原样工作，或者是否在幕后进行了其他修改。

如果有帮助的话，我正在使用配备 8 核 Intel 处理器的 iMac。我也在 R 中运行它，因为 RStudio 说了一些关于它不支持多核的内容。

另请注意，我的问题也广泛涉及这三个过去的问题：

第一次在这里提问。请善待:)

我试图以并行方式递归地获取所有目录，希望减少遍历驱动器所需的时间。下面是我尝试过的代码。本质上我想要做的是输入一个文件夹并对其子文件夹及其子文件夹等并行执行相同的操作，但该函数在并行块内无法识别

function New-RecursiveDirectoryList {
    [CmdletBinding()]
    param (
        # Specifies a path to one or more locations.
        [Parameter(Mandatory = $true,
            Position = 0,
            ValueFromPipeline = $true,
            ValueFromPipelineByPropertyName = $true,
            HelpMessage = 'Path to one or more locations.')]
        [Alias('PSPath')]
        [ValidateNotNullOrEmpty()]
        [string[]]
        $Path
    )
    process {
        foreach ($aPath in $Path) {
            Get-Item $aPath

            Get-ChildItem -Path $aPath -Directory |
                # Recursively call itself in Parallel block not working
                # Getting error "The term 'New-RecursiveDirectoryList' is not recognized as a name of a cmdlet" …

由于 NumPy 的转置函数，我目前遇到了巨大的开销。我发现这个函数实际上总是在单线程中运行，无论转置矩阵/数组有多大。我可能需要避免这种巨大的时间成本。

据我了解，np.dot如果 numpy 数组足够大，其他函数（例如向量增量）将并行运行。一些按元素操作似乎在 numexpr 包中可以更好地并行化，但 numexpr 可能无法处理转置。

我想了解解决问题的更好方法。为了详细说明这个问题，

\n
• 有时，NumPy 运行转置速度超快（如B = A.T），因为转置后的张量不用于计算或转储，并且在此阶段不需要真正转置数据。调用时B[:] = A.T，确实会转置数据。
\n
• 我认为并行转置函数应该是一个解决方案。问题是如何实施。
\n
• 希望该解决方案不需要 NumPy 以外的软件包。ctype 绑定是可以接受的。希望代码不会太难使用，也不会太复杂。
\n
• 张量转置是一个优点。虽然转置矩阵的技术也可以用于特定的张量转置问题，但我认为为张量转置编写通用 API 可能很困难。我实际上还需要处理张量转置，但是处理张量可能会使这个 stackoverflow 问题复杂化。
\n
• 未来是否有可能实现并行转置，或者是否有计划？那么就不需要自己实现转置了;)
\n

在此先感谢您的任何建议！

当前的解决方法

在我的 Linux 个人计算机上处​​理模型转置问题（大小约为A763MB），可用 4 核（总共 400% CPU）。

A = np.random.random((9999, 10001))\nB = np.random.random((10001, 9999))\nD = np.random.random((9999, 10001))\n

当前的解决方法似乎不够有效。一般来说，如果在 4 核 CPU 上完全并行化，它应该会看到大约 3 倍~4 倍的加速，但我编写的代码只获得了大约 1.5 倍。 …

我正在开发 R 包，并且需要myfun使用parallel::parLapply. myfun调用我的包中的几个附加函数，这些函数又调用更多函数，其中一些函数有多个方法......因此按名称显式将所有函数和方法传递到集群非常麻烦。

据我了解，标准建议是跑步 parallel::clusterEvalQ({library("my_package")})。但对 R-CMD-check 的调用library("my_package")显然是令人厌恶的。我有理由相信这my-package:::function也不会在 CRAN 上运行。

这里的标准方法是什么？我需要按名称导出每个相关函数和方法吗？

我有一个相对简单的案例：

1. 我的程序将通过 Websockets 接收更新，并将使用这些更新来更新其本地状态。这些更新将非常小（通常 < 1-1000 字节 JSON，因此反序列化 < 1 毫秒），但会非常频繁（高达 ~1000/s）。
2. 同时，程序将从该本地状态读取/评估并输出其结果。
3. 这两个任务应该并行运行，并且将在程序的持续时间内运行，即永远不会停止。
4. 本地状态大小相对较小，因此内存使用量不是一个大问题。

棘手的部分是更新需要“原子地”发生，这样它就不会从本地状态读取，例如，只写入了一半的更新。状态不限于使用原语，并且可以包含任意类 AFAICT atm，因此我无法通过使用Interlocked原子操作之类的简单方法来解决它。我计划在其自己的线程上运行每个任务，因此在本例中总共有两个线程。

为了实现这个目标，我想使用双缓冲区技术，其中：

1. 它保留状态的两份副本，以便在写入另一份时可以读取一份。
2. 线程可以通过使用锁来传达它们正在使用哪个副本。即 Writer 线程在写入时锁定副本；读取器线程在完成当前副本后请求访问锁；编写器线程看到读取器线程正在使用它，因此它切换到其他副本。
3. 写入线程会跟踪在当前副本上完成的状态更新，因此当它切换到另一个副本时，它可以“赶上”。

这是这个想法的总体要点，但实际的实现当然会有点不同。

我试图查找这是否是一个常见的解决方案，但找不到太多信息，所以这让我想知道以下内容：

1. 它可行吗，还是我错过了什么？
2. 有更好的方法吗？
3. 这是一个通用的解决方案吗？如果有的话，通常被称为什么？
4. （奖励）是否有一个好的资源可供我阅读与此相关的主题？

我几乎觉得我已经走进了一个死胡同，我找不到（因为我不知道要搜索什么）更多的资源和信息来看看这种方法是否“好”。我计划用 .NET C# 编写此内容，但我认为这些技术和解决方案可以转换为任何语言。所有见解均受到赞赏。

我正在尝试更改一些 PyTorch 代码，以便它可以在 CPU 上运行。

该模型经过训练，torch.nn.DataParallel()因此当我加载预训练模型并尝试使用它时，我必须使用nn.DataParallel()我目前正在做的事情，如下所示：

device = torch.device("cuda:0")
net = nn.DataParallel(net, device_ids=[0])
net.load_state_dict(torch.load(PATH))
net.to(device)

然而，当我将我的手电筒设备切换到 CPU 后，如下所示：

device = torch.device('cpu')
net = nn.DataParallel(net, device_ids=[0])
net.load_state_dict(torch.load(PATH))
net.to(device)

我收到这个错误：

File "C:\My\Program\win-py362-venv\lib\site-packages\torch\nn\parallel\data_parallel.py", line 156, in forward
    "them on device: {}".format(self.src_device_obj, t.device))
RuntimeError: module must have its parameters and buffers on device cuda:0 (device_ids[0]) but found one of them on device: cpu

我假设它仍在寻找 CUDA，因为这就是device_ids设置的内容，但有没有办法让它使用 CPU？PyTorch 存储库中的这篇文章让我认为我可以，但它没有解释如何做到。

如果没有，是否有其他方法可以在您的 CPU 上使用通过 DataParallel 训练的模型？

我用来rowwise在每一行上执行一个函数。这需要很长时间。为了加快速度，有没有办法使用并行处理，以便多个核心同时处理不同的行？

例如，我将 PRISM 天气数据 ( https://prism.oregonstate.edu/ ) 聚合到州一级，同时按人口进行加权。这是基于https://www.patrickbaylis.com/blog/2021-08-15-pop-weighted-weather/。

请注意，下面的代码需要下载每日天气数据以及具有非常小的地理区域人口估计值的 shapefile。

library(prism)
library(tidyverse) 
library(sf)
library(exactextractr)
library(tigris)
library(terra)
library(raster)
library(ggthemes)

################################################################################
#get daily PRISM data
prism_set_dl_dir("/prism/daily/")
get_prism_dailys(type = "tmean", minDate = "2012-01-01", maxDate = "2021-07-31", keepZip=FALSE) 

Get states shape file and limit to lower 48    
states = tigris::states(cb = TRUE, resolution = "20m") %>%
    filter(!NAME %in% c("Alaska", "Hawaii", "Puerto Rico"))

setwd("/prism/daily")

################################################################################
#get list of files in the directory, and extract date
##see if it is stable (TRUE) …

我有一个包含内部循环的外部 foreach/dopar 并行循环。内部循环的每个实例都应该处理同一组随机数。其余部分，即外部主体的其余部分和并行实例应照常工作，即具有独立的随机数。

我可以在非并行实现中实现这一点，方法是在内循环开始之前保存 RNG 的状态，并在执行内循环的每个实例之后恢复该状态。请参见以下示例：

library(doSNOW)

seed = 4711

cl = makeCluster(2)
registerDoSNOW(cl)
clusterSetupRNGstream (cl, seed=rep(seed,6))

erg = foreach(irun = 1:3,.combine = rbind) %dopar% {

  #do some random stuff in outer loop
  smp = runif(1)

  # save current state of RNG
  s = .Random.seed

  # inner loop, does some more random stuff
  idx = numeric(5)
  for(ii in seq.int(5)) {
    idx[ii] = sample.int(10, 1)
    # reset RNG for next loop iteration
    set.seed(s)
  }

  c(smp,idx)
}

> print(erg)
              [,1] [,2] [,3] …

我正在使用 Simon Marlow 的书学习 Haskell 中的并行编程。在关于并行数独求解器的章节中，我决定使用回溯算法编写自己的求解器。问题是，当我尝试在 6 个核心之间分配 6 个案例时，几乎没有性能增益。当我尝试使用更多情况进行示例时，我获得了更显着的性能提升，但距离理论上的最大值（应在 5 到 6 之间）仍然很远。我知道某些情况可能运行得慢得多，但 threadscope 图显示没有理由这么少获得。有人可以解释一下我做错了什么吗？也许 ST 线程有一些我不理解的地方？

这是代码：

数独.hs

{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}

module Sudoku (getSudokus, solve) where

import Data.Vector(Vector, (!), generate, thaw, freeze)
import Data.List ( nub )
import qualified Data.Vector.Mutable as MV
import Text.Trifecta
import Control.Monad ( replicateM, when )
import Control.Applicative ((<|>))
import Control.Monad.ST
import Control.DeepSeq (NFData)
import GHC.Generics (Generic)

data Cell = Given Int
        | Filled Int
        | Empty
        deriving (Generic, NFData)

newtype Sudoku …

我有一台 24 个核心的机器，每个核心有 2 个线程。我正在尝试优化以下代码以实现并行执行。但是，我注意到代码的性能在达到一定数量的线程后开始下降。

import argparse
import glob
import h5py
import numpy as np
import pandas as pd
import xarray as xr
from tqdm import tqdm
import time
import datetime
from multiprocessing import Pool, cpu_count, Lock
import multiprocessing
import cProfile, pstats, io


def process_parcel_file(f, bands, mask):
    start_time = time.time()
    test = xr.open_dataset(f)
    print(f"Elapsed in process_parcel_file for reading dataset: {time.time() - start_time}")

    start_time = time.time()
    subset = test[bands + ['SCL']].copy()
    subset = subset.where(subset != 0, np.nan)
    if mask:
        subset = …