我正在使用Task.WaitAny并传入正在运行的任务数组.如果有多个任务同时完成,我想知道如何捕获所有已完成任务的索引.

例如,我正在检索完成的任务的索引,如下所示:`

int i = Task.WaitAny(taskArray);

使用索引i,我用另一个已启动的任务替换数组中的那个位置.taskArray具有固定长度,我只能在完成时启动新任务并替换数组中的任务.如果我只在Task.WaitAny()上返回一个索引,我怎么能这样做,并且阵列中的多个任务可能同时完成.如果只返回一个索引,我该如何处理同时完成的其他任务？

`

C++ 17为标准库添加了并行扩展(例如std::sort(std::execution::par_unseq, arr, arr + 1000),允许使用多个线程和向量指令进行排序).

我注意到微软的实验性实现提到VC++编译器缺乏对这里做矢量化的支持,这让我感到惊讶 - 我认为现代C++编译器能够推断出循环的可矢量化,但显然VC++编译器/优化器无法生成SIMD代码即使明确告知这样做.看似缺乏自动矢量化支持与2011年关于Quora的问题的答案相矛盾,这表明编译器将在可能的情况下进行矢量化.

也许,编译器只会对非常明显的情况进行矢量化,例如a std::array<int, 4>,而且只不过是这样,因此C++ 17的显式并行化会很有用.

因此我的问题是:当没有明确告知这样做时,当前的编译器会自动向量化我的代码吗？(为了使这个问题更具体,让我们将其缩小到支持SIMD的Intel x86 CPU,以及最新版本的GCC,Clang,MSVC和ICC.)

作为扩展:其他语言的编译器是否可以做更好的自动矢量化(可能是由于语言设计)(因此C++标准委员会认为它对于显式(C++ 17风格)矢量化是必要的)？

我尝试创建将两个不同的空间数据集组合在一起的摘要统计信息：一个大的栅格文件和一个多边形文件。这个想法是获得每个面内栅格值的摘要统计信息。

由于栅格太大而无法一次处理，因此我尝试创建子任务并并行处理它们，即一次处理每个多边形SpatialPolgyonsDataframe。

该代码工作正常，但是经过大约100次交互后，我遇到了内存问题。这是我的代码以及我打算做的事情：

# session setup
library("raster")
library("rgdal")

# multicore processing. 
library("foreach")
library("doSNOW")
# assign three clusters to be used for current R session
cluster = makeCluster(3, type = "SOCK",outfile="")
registerDoSNOW(cluster)
getDoParWorkers()# check if it worked

# load base data
r.terra.2008<-raster("~/terra.tif")
spodf.malha.2007<-readOGR("~/,"composed")

# bring both data-sets to a common CRS
proj4string(r.terra.2008)
proj4string(spodf.malha.2007)
spodf.malha.2007<-spTransform(spodf.malha.2007,CRSobj = CRS(projargs = proj4string(r.terra.2008)))
proj4string(r.terra.2008)==proj4string(spodf.malha.2007) # should be TRUE

# create a function to extract areas
function.landcover.sum<-function(r.landuse,spodf.pol){
  return(table(extract(r.landuse,spodf.pol)))}

# apply it one one subset to …

我正在运行一堆shell脚本, parallel -a my_scripts bash 并且在某些时候我决定我已经运行了足够多的东西,并希望停止产生新的工作,并简单地让所有现有的工作完成.换句话说,我想杀死父进程而不杀死孩子.

在第一次启动GNU并行时似乎有控制终止的方法(例如,如果我事先知道我只想运行x作业,那么我可以使用--halt now,success=x参数),但是我已经找不到如何控制GNU并行运行.

当然我可以只是CTRL+C杀死并行,并重新运行中止的工作,但我认为可能有一个更聪明的方法.

ECMA-2017(ES8)刚刚在一个月前完成,它引入了SharedArrayBuffer和Atomics.此处的链接表明它们已在某些浏览器中得到支持.

我们知道,它们旨在允许跨线程共享数据.我想知道在浏览器和Node中如何实现这种并行性？我们应该分别使用Web Workers和'cluster'包吗？

我在这个主题上看过其他一些帖子,似乎没有一个与我遇到的问题完全相同.但是这里:

我正在使用并行运行一个函数

cores <- detectCores() cl <- makeCluster(8L,outfile="output.txt") registerDoParallel(cl) x <- foreach(i = 1:length(y), .combine='list',.packages=c('httr','jsonlite'), .multicombine=TRUE,.verbose=F,.inorder=F) %dopar% {function(y[i])}

这通常工作正常,但现在抛出错误:

序列化错误(数据,节点$ con):写入连接时出错

检查output.txt文件后,我看到:

starting worker pid=11112 on localhost:11828 at 12:38:32.867
starting worker pid=10468 on localhost:11828 at 12:38:33.389
starting worker pid=4996 on localhost:11828 at 12:38:33.912
starting worker pid=3300 on localhost:11828 at 12:38:34.422
starting worker pid=10808 on localhost:11828 at 12:38:34.937
starting worker pid=5840 on localhost:11828 at 12:38:35.435
starting worker pid=8764 on localhost:11828 at 12:38:35.940
starting worker pid=7384 on localhost:11828 at 12:38:36.448
Error in …

在上市波纹管,我希望当我打电话t.detach()时创建线程行之后,该线程t将在后台运行,而printf("quit the main function now \n")会叫,然后main将退出.

#include <thread>
#include <iostream>

void hello3(int* i)
{

    for (int j = 0; j < 100; j++)
    {
        *i = *i + 1;
        printf("From new thread %d \n", *i);
        fflush(stdout);

    }

    char c = getchar();
 }

int main()
{
    int i;
    i = 0;
    std::thread t(hello3, &i);
    t.detach();
    printf("quit the main function now \n");
    fflush(stdout);
    return 0;
}

然而,从它在屏幕上打印的内容来看并非如此.它打印

From new thread 1
From new thread …

我已经看过几个关于这个主题的问题,但我没有能力将其转化为我的具体问题.我有一个for循环遍历子目录,然后在每个目录内的压缩文本文件上执行.sh脚本.我想并行化这个过程,但我正在努力应用gnu parallel.

这是我的循环:

for d in ./*/ ; do (cd "$d" && script.sh); done

我知道我需要并行输入一个列表,所以我一直在尝试这个:

ls -d */ | parallel cd && script.sh

虽然这似乎已经开始,但是当gzip尝试解压缩目录中的一个txt文件时,我收到一个错误,说该文件不存在:

gzip: *.txt.gz: No such file or directory

但是,当我运行原始for循环时,除了需要一个世纪才能完成之外我没有任何问题.此外,我在使用并行时只获得一次gzip错误,考虑到我有超过1000个子目录,这是非常奇怪的.

我的问题是:

1. 在我的案例中如何让Parallel工作？如何并行将.sh脚本的应用程序并行化到自己子目录中的1000个文件？即 - 我的问题的解决方案是什么？我必须取得进步.

2. 我错过了什么？语法,循环,坏脚本？我想学习.

3. 并行实际上是否尝试并行运行所有这些.sh脚本？为什么我的每个.txt.gz文件都没有出错？

4. 并行是应用程序的最佳选择吗？还有其他选择更适合我的需求吗？

背景

我目前正在研究我的学士论文,基本上我的任务是优化Go中的给定代码,即尽可能快地运行.首先,我优化了串行功能,然后尝试通过goroutines引入并行性.在互联网上进行研究之后,由于来自talks.golang的以下幻灯片,我现在理解了并发性和并行性之间的区别.我参观了一些并行编程课程,我们在pthread/openmp的帮助下并行化了ac/c ++代码,因此我尝试在Go中应用这些范例.也就是说,在这个特殊情况下,我正在优化一个函数,它计算一个长度的切片的移动平均值len:=n+(window_size-1)(它等于9393或10175),因此我们有n窗口,我们计算相应的算术平均值,并在输出中正确保存切片.

请注意,此任务本质上是令人尴尬的并行.

我的优化尝试和结果

在moving_avg_concurrent2我将切片分成num_goroutines小片并用一个goroutine运行.这个功能是用一个goroutine执行的,出于某种原因(但是我们在这里找不到原因,但是我们在这里得到了切线),moving_avg_serial4但是比一个以上的goroutine它开始表现更差moving_avg_serial4.
在moving_avg_concurrent3我所采用的主/工人模式.性能比moving_avg_serial4使用一个goroutine时差.在这里,我们至少在增加时获得了更好的表现,num_goroutines但仍然没有更好moving_avg_serial4.为了比较的性能moving_avg_serial4,moving_avg_concurrent2和moving_avg_concurrent3我写了一个标杆和我列出的结果:

fct & num_goroutines | timing in ns/op | percentage  
---------------------------------------------------------------------   
          serial4    |         4357893 |   100.00%  
          concur2_1  |         5174818 |   118.75%  
          concur2_4  |         9986386 |   229.16%  
          concur2_8  |        18973443 |   435.38%  
          concur2_32 |        75602438 |  1734.84%  
          concur3_1  |        32423150 |   744.01%  
          concur3_4  |        21083897 | …

我正在尝试编写并行压缩/加密备份脚本，以使用GNU parallel，xz和GnuPG进行归档。脚本的核心部分是：

tar --create --format=posix --preserve-permissions --same-owner --directory $BASE/$name --to-stdout . \
    | parallel --pipe --recend '' --keep-order --block-size 128M "xz -9 --check=sha256 | gpg --encrypt --recipient $RECIPIENT" \
    | pv > $TARGET/$FILENAME

没有GnuPG加密，它会很好地工作（解压缩和解压缩工作），但是添加并行加密后，它解密失败，并出现以下错误：

[don't know]: invalid packet (ctb=0a)
gpg: WARNING: encrypted message has been manipulated!
gpg: decrypt_message failed: Unexpected error
: Truncated tar archive
tar: Error exit delayed from previous errors.

因为未压缩的大小与gnu parallel的块大小相同（大约125M），所以我认为这与GnuPG对部分块加密的支持有关。我怎么解决这个问题？

费耶

关于随机数生成的另一个并行gpg加密问题

https://unix.stackexchange.com/questions/105059/parallel-pausing-and-resuming