标签: parallel-processing

我有一个 ASP .NET core Web API，它使用此处描述的排队后台任务 。

我已使用提供的代码示例并添加了IBackgroundTaskQueue,BackgroundTaskQueue和 ，QueuedHostedService完全按照文章中所述。

在 my 中Startup.cs，我仅注册一个QueuedHostedService实例，如下所示：services.AddHostedService<QueuedHostedService>();

来自 WebApi 控制器的任务将被入队，然后出队并由QueuedHostedService.

我希望允许多个后台处理线程使传入的任务出队并执行。我能想到的最直接的解决方案是QueuedHostedService在我的Startup.cs. 即，像这样：

 int maxNumOfParallelOperations;
 var isValid = int.TryParse(Configuration["App:MaxNumOfParallelOperations"], out maxNumOfParallelOperations);

 maxNumOfParallelOperations = isValid && maxNumOfParallelOperations > 0 ? maxNumOfParallelOperations : 2;

 for (int index = 0; index < maxNumOfParallelOperations; index++) 
 {
    services.AddHostedService<QueuedHostedService>();
 }

我还注意到，由于 中的信号量BackgroundTaskQueue，QueuedHostedService实例并不是一直在工作，而是仅在队列中有新任务可用时才唤醒。

这个解决方案在我的测试中似乎效果很好。

但是，在这个特定的用例中 - 它真的是一个有效的、推荐的并行处理解决方案吗？

我希望受益于parallelmacOS 上命令的所有潜力（似乎存在 2 个版本，GNU 和 Ole Tange 的版本，但我不确定）。

使用以下命令：

parallel -j8  find {} ::: *

如果我位于包含8个子目录的目录中，我会有很大的性能。但是，如果所有这些子目录除了只有一个之外都具有较小的内容，那么我将只有一个线程可以在唯一的“大”目录上工作。

1. 有没有办法遵循这个“大目录”的并行化？我的意思是，剩下的唯一线程可以得到其他线程的帮助吗（之前的线程适用于小子目录）？

   find理想的情况是，当上面的命令行中的命令找到所有小子时，并行命令“自动切换” 。也许是我问得太多了？

2. 另一个潜在的优化（如果存在）：考虑公共树目录结构：是否有一种类似于命令的方法make -j8，将每个当前线程分配给子(sub-(sub-....))))目录一旦探索了当前目录（别忘了，我主要想在findLinux 命令中使用这种优化），另一个线程探索另一个目录 sub-(sub-(sub- ....)))) 目录？

   当然，运行的总线程数不大于parallel命令指定的数量（parallel -j8在我上面的示例中）：我们可以说，如果树元素的数量（1个节点=1个目录）大于线程数，我们不能超过这个数字。

   我知道在递归上下文中并行化很棘手，但当我想在大树结构中查找文件时，也许我可以获得一个重要因素？

   这就是为什么我以 command 为例make -j8：我不知道它是如何编码的，但这让我认为我们可以对parallel/find帖子开头的几个命令行执行相同的操作。

最后，我想得到您关于这两个问题的建议，更一般地说，目前这些优化建议什么是可能的，什么是不可能的，以便使用经典find命令更快地找到文件。

更新1：正如@OleTange所说，我不知道我想要gupdatedb索引的内容的先验目录结构。因此，很难提前知道maxdepth。您的解决方案很有趣，但第一次执行find不是多线程的，您不使用parallel命令。gupdatedb我有点惊讶的是，不存在多线程版本：在纸面上，这是可行的，但一旦我们想在gupdatedbMacOS 10.15 的 GNU 脚本中对其进行编码，那就更困难了。

如果有人有其他建议，我会接受！

我正在尝试使用两个 GPU 在 PyTorch 中训练模型。我正在使用torch.nn.DataParallel，但由于某种原因nvidia-smi说我只使用一个 GPU。

该代码大致如下：

>>> import torch.nn as nn 
>>> model = SomeModel()
>>> model = nn.DataParallel(model)
>>> model.to('cuda')

当我运行程序并观察 的输出时nvidia-smi，我只看到 GPU 0 正在运行。有人知道问题是什么吗？

我正在尝试使用 IronPDFs HTML 到 PDF 功能并行生成多个 PDF。但从 ASP.NET 启动时似乎陷入僵局:(

我在这里重新创建了问题：https ://github.com/snebjorn/ironpdf-threading-issue-aspnet

这是包含基本部分的片段。

打电话GetSequential()有效。但不是并行执行。 GetSimple()并行运行但出现死锁。

public class TestController : Controller
{
    [HttpGet]
    [Route("simple")]
    public async Task<IActionResult> GetSimple()
    {
        var tasks = Enumerable
            .Range(1, 10)
            .Select(i => HtmlToDocumentAsync("hello", i));
        var pdfs = await Task.WhenAll(tasks);

        using var pdf = PdfDocument.Merge(pdfs);
        pdf.SaveAs("output.pdf");
        return Ok();
    }

    [HttpGet]
    [Route("seq")]
    public async Task<IActionResult> GetSequential()
    {
        var pdfs = new List<PdfDocument>();
        foreach (var i in Enumerable.Range(1, 10))
        {
            pdfs.Add(await HtmlToDocumentAsync("hello", i));
        }

        using var …

使用下面的代码块作为参考，一次更新可提供以下结果：

intReturn = 0

inputArrayReturn = 1

internalArrayReturn = 1

这里对我来说唯一有意义的值是internalArrayReturn.

为什么不intReturn等于1？即使在执行过程中应该将 1 添加到结构中，但到底发生了什么导致该结构的值没有改变？如果这只是 NativeArray 和 int 之间的根本区别，有人可以解释一下或给我指出一个参考资料来帮助我更好地理解这一点吗？

另外，为什么不inputArrayReturn等于0？ NativeArray是一个结构体，所以当该行执行时它不应该被视为值的副本而不是引用吗testArray = testArrayResults？如果是这种情况，则 theninputArrayReturn将保持等于 0，而不是更新为 中包含的相同值testJob.testArray。

using UnityEngine;
using Unity.Jobs;
using Unity.Collections;

public class ParallelTesting : MonoBehaviour
{
    void Update()
    {
        NativeArray<int> testArrayResults = new NativeArray<int>(1, Allocator.TempJob);

        TestJob testJob = new TestJob
        {
            testInt = 0,
            testArray = testArrayResults
        };

        JobHandle testJobHandle = testJob.Schedule();
        testJobHandle.Complete();

        int intReturn …

我是 javascript 和 node.js 的新手，

这里我有两个循环，我想让它们并行运行，

function loop1(){
    for (var i = 10000; i < 20000; i++) {
        console.log(i);
    }
}
function loop2(){
    for (var i = 0; i < 10000; i++) {
        console.log(i);
    }
}
loop1();
loop2();

这意味着我期望的输出就像

10000
0
10001
1
...
19999
9999

但这输出

10000
10001
...
19999
0
1
...
9999

我尝试过使用类似的承诺

Promise.all([loop1(), loop2()])

但什么也没发生。

对此有什么想法吗？我的最终目标是将文件夹中的文件分成两半并并行处理它们。因此多线程或多处理可能是可以接受的。感谢您的帮助。

我想跑for loop进去parallel process。我的代码结果for loop R很符合我的口味，但将其应用到非常huge data因此，执行的时间很慢。

library(forecast)
library(dplyr)
arima_order_results = data.frame()
seed_out2 <- c(1, 16, 170, 178, 411, 630, 661, 1242, 1625, 1901, 1926, 1927, 1928, 2170, 2779, 3687, 4139, 4583, 4825, 4828, 4829, 4827, 5103, 5211, 5509, 5561, 5569, 5679, 6344, 6490, 6943, 6944, 6945, 6946, 6948, 6950, 6951, 6952)
for (my_seed in seed_out2){
  set.seed(my_seed)
  ar1 <- arima.sim(n = 100, model=list(ar = 0.8, order = c(1, 0, 0)), sd = 1) …

我想在 bash 脚本中并行运行多个命令，但如果其中任何命令失败（返回非零退出代码），则脚本退出代码必须非零。

我尝试使用sem（https://www.gnu.org/software/parallel/sem.html）：

cat >script.sh <<EOF
sem -j+0 "sleep 2; echo 1"
sem -j+0 "sleep 4; exit 1; echo 2"
sem -j+0 "sleep 6; echo 3"
sem --wait
EOF
bash script.sh; echo $?

并只是后台进程：

cat >script.sh <<EOF
{sleep 2; echo 1} &
{sleep 4; exit 1; echo 2} &
{sleep 6; echo 3} &
wait
EOF
bash script.sh; echo $?

在这两种情况下，总体退出代码始终为 0。

有任何想法吗？

我正在使用modin.pandas来缩放pandas以适应大型数据集。但是，当使用pd.read_csv加载 5 MB csv 数据集来比较和jupyter notebook的性能时，它会给出意外的执行时间。modin.pandaspandas

modin.pandas所花费的时间比pandas. 为什么？

代码-

import modin.pandas as mpd
df = mpd.read_csv(r"C:\Downloads\annual-enterprise-survey-2019-financial-year-provisional-csv.csv")

import pandas as pd
df = pd.read_csv(r"C:\Downloads\annual-enterprise-survey-2019-financial-year-provisional-csv.csv")

这是 CSV 文件的链接。我正在使用 modin 版本0.8.3和 pandas 版本1.1.5。

输出截图-

系统信息-

编辑：我尝试使用 500 MB 的 CSV 文件，结果略有改善。modin现在和的执行时间pandas几乎相同。这是常见的吗？

I know "cluster" and "child_process" can use multiple cores of a CPU so that we can achieve true parallel processing.

I also know that the async event loop is single-threaded so we can only achieve concurrency.

My question is about worker_threads:

假设我的电脑有 4 核 CPU 并且我正在执行一个 Nodejs 脚本。该脚本创建三个工作线程。

三个工作线程会利用CPU中剩余的3个核心来实现并行吗？

或者三个工作线程将只使用主核心而其余3个核心不被使用，就像事件循环一样？