标签: parallel-processing

我正在学习如何并行运行多个进程

  ./script1.sh param1 1>/dev/null 2>&1 &
  pid1=$!
  ./script1.sh param2 1>/dev/null 2>&1 &
  pid2=$!

我不确定这里发生了什么:

   1>/dev/null 2>&1
   pid1=$!

我试图理解"农场"在计算中的意义,因此,如果一个农场可以作为一个集群示例,那么必须有一个农场独立于集群的东西.

它与网格有什么不同？

这些概念是否具有一般意义,例如,谈论Web服务器只是一种常见的情景,或者它们是否完全不同于上下文？如果是这样,有什么不同的含义(或最常见的含义)？

另外,我应该在其他地方问这个吗？(如果是的话,我表示道歉).

我有一大堆原始价值类型.该阵列实际上是一维的,但在逻辑上代表一个二维场.当您从左向右阅读时,值需要变为(当前单元格的原始值)+(在左侧单元格中计算的结果).显然除了每行的第一个元素外,它只是原始值.

我已经有了一个实现它的实现,但是在整个数组上完全迭代,对于大型(1M +元素)数组来说非常慢.

给出以下示例数组,

0 0 1 0 0
2 0 0 0 3
0 4 1 1 0
0 1 0 4 1

变

0 0 1 1 1
2 2 2 2 5
0 4 5 6 6
0 1 1 5 6

等等,直到有问题的尺寸(1024x1024)

需要更新阵列(理想情况下),但必要时可以使用另一个阵列.内存占用空间不是问题,但性能至关重要,因为这些阵列具有数百万个元素,每秒必须处理数百次.

单个单元格计算似乎不可并行化,因为它们依赖于从左侧开始的值,因此GPU加速似乎是不可能的.我已经研究过PLINQ,但索引的必要条件使得它很难实现.

是否有另一种方法来构建数据以使其更快地处理？

如果使用创新的技术可以实现高效的GPU处理,那么这将是非常可取的,因为这是当前必须从视频卡中拉出并推回到视频卡的纹理数据.

我想知道在使用foreach %dopar%循环后是否可以输出两个不同的对象.

我会尝试解释我在寻找什么.假设我在循环中有几个操作,我有两个data.frame:

library(doMC)
library(parallel)
registerDoMC(cores=4)

result <- foreach(i=1:100) %dopar% {
#### some code here
#### some code here
vec1 <- result_from_previous code # It would be the 1st object I'd like to ouput
vec2 <- result_from_previous code # It would be the 2nd object I'd like to output
}

我想要的输出是长度为2的data.frames列表,例如:

dim(result[[1]]) # equals to nrow=length(vec1) and ncol=100
dim(result[[2]]) # equals to nrow=length(vec2) and ncol=100

我从前一篇文章中尝试了这个保存foreach dopar loop的多个输出:

comb <- function(x, ...) {
  lapply(seq_along(x), function(i) c(x[[i]], …

我有96个txt文件需要处理.现在我正在使用for循环并一次执行一个,这个过程非常慢.生成的96个文件,不需要合并.有没有办法使它们并行运行,ala Parallel.foreach在C#中？当前代码:

for src_name in glob.glob(source_dir+'/*.txt'):
   outfile = open (...)
   with open(...) as infile:
      for line in infile:
         --PROCESS--
   for --condition--:
      outfile.write(...)
   infile.close()
   outfile.close()

希望此进程并行运行source_dir中的所有文件.

有没有办法让J使用多个核心？我认为APL/J的部分好处是语言结构很好地适用于并行解决方案.

看看我的CPU使用情况(我在OSX上),显然只有一个处理器在使用中.

我有一个重要的功能f作用于列表,我不明白为什么它不能将列表分成4个部分,并重新组合结果？

对于从XE2到XE8的Delphi编译器,对于非Windows目标平台,是一个整数数据成员的读操作,用[Volatile]注释,原子？

我知道对于Windows平台的情况,当且仅当数据成员对齐到4个字节时才是原子的,但是非windows(Android等)呢？

请注意,我不是在询问线程安全性.线程安全性和原子性是两回事.

想象一下,我们正在做一些过程,我想在程序的开头设置一个整体种子:例如

mylist <- list( as.list(rep(NA,3)), as.list(rep(NA,3)) )
foo <- function(x){  for(i in 1:length(x)){ 
                       x[[i]] <- sample(100,1)
                         }
                      return(x) 
                     } 

# start block
set.seed(1)
l1 <- lapply(mylist, foo)
l2 <- lapply(mylist, foo)
# end

当然在一个区块内l1并且l2是不同的,但是如果我再次运行上面的区块l1将与之前相同并且l2将与之前相同.

想象一下,foo是可怕的耗时,所以我想用mclapply没有lapply,所以我这样做:

library(parallel)

# start block
set.seed(1)
mclapply(mylist , foo,  mc.cores = 3)
mclapply(mylist , foo,  mc.cores = 3)
# end

如果我再次运行此块,我将在下次获得不同的结果.我如何产生与使用lapply但设置一个整体种子相同的行为mclappy.我查看了mclapplydoc,但我不确定因为使用:

set.seed(1)
l1 <-  mclapply(mylist , …

我在Oozie中使用fork/join,以便并行一些子工作流操作.我的workflow.xml如下所示:

<workflow-app name="myName" xmlns="uri:oozie:workflow:0.5"
<start to="fork1"/>
<kill name="Kill">
    <message>Action failed, error message[${wf:errorMessage(wf:lastErrorNode())}]</message>
    </kill>

<fork name="fork1">
    <path start="subworkflow1"/>
    <path start="subworkflow2"/>
</fork>
<join name="Completed" to="End"

<action name="subworkflow1">
    <sub-workflow>
        <app-path>....</app-path>
        <propagate-configuration/>
        <configuration>
            <property>
                <name>....</name>
                <value>....</value>
            </property>
        </configuration>
    </sub-workflow>
    <ok to="Completed"/>
    <error to="Completed"/>
</action>

<action name="subworkflow2">
    <sub-workflow>
        <app-path>....</app-path>
        <propagate-configuration/>
        <configuration>
            <property>
                <name>....</name>
                <value>....</value>
            </property>
        </configuration>
    </sub-workflow>
    <ok to="Completed"/>
    <error to="Completed"/>
</action>

<end name="End"></workflow-app>

当subworkflow1被杀死时(由于某种原因失败),它也会杀死subworkflow2.我希望这两个动作是平行的,但不依赖.

在我的工作流程中,当workflow1被杀死时,我看到workflow2也被杀死了,但我的应用程序成功了(我在Oozie仪表板上检查它 - > HUE中的工作流程).

在这种情况下,我希望subworkflow1将被杀死,subworkflow2将成功,我真的不关心我的整个应用程序会说什么.

• 在我的情况下,subworkflow1需要比subworkflow2更长的时间,所以当我检查我的应用程序结束时,我看到虽然它说subworkflow1 + 2被杀了,我的应用程序成功了,但真正发生的是subworkflow2完成了它的部分,即使,它后来被杀死了(它继续"运行",直到叉子的所有路径完成它们的运行).所以workflow2完成了它的部分而不是被杀死因为workflow1被杀了...

我应该怎么做才能使每个路径获得它自己的状态并继续运行,即使同一个fork中的其他路径被杀死了？

这可能是我写过的最糟糕的StackOverflow标题.我实际上要做的是执行一个异步方法,该方法在同步方法中多次并行使用async/await约定(并且本身包含额外的await调用),同时在整个执行每个分支的过程中保持相同的线程.并行执行,包括所有等待延续.换句话说,我想同步执行一些异步代码,但我想多次并行执行.现在你可以看到为什么标题太糟糕了.也许最好用一些代码来说明......

假设我有以下内容:

public class MyAsyncCode
{
    async Task MethodA()
    {
        // Do some stuff...
        await MethodB();
        // Some other stuff
    }

    async Task MethodB()
    {
        // Do some stuff...
        await MethodC();
        // Some other stuff
    }

    async Task MethodC()
    {
        // Do some stuff...
    }
}

调用者是同步的(来自控制台应用程序).让我尝试说明我尝试使用Task.WaitAll(...)和包装任务的尝试:

public void MyCallingMethod()
{
    List<Task> tasks = new List<Task>();
    for(int c = 0 ; c < 4 ; c++)
    {
        MyAsyncCode asyncCode = new MyAsyncCode();
        tasks.Add(Task.Run(() => asyncCode.MethodA()));
    }
    Task.WaitAll(tasks.ToArray());
} …