标签: parallel-processing

我想lme4::lmer在以下格式的60M观测值上运行混合模型(使用); 所有预测变量/因变量都是连续因变量的分类(因子)tc; patient是随机拦截项的分组变量.我有64位R和16Gb RAM,我在中央服务器上工作.RStudio是最新的服务器版本.

model <- lmer(tc~sex+age+lho+atc+(1|patient),
              data=master,REML=TRUE)

lho sex tc      age         atc patient
18  M   16.61   45-54       H   628143
7   F   10.52   12-15       G   2013855
30  M   92.73   35-44       N   2657693
19  M   24.92   70-74       G   2420965
12  F   17.44   65-69       A   2833610
31  F   7.03    75 and over A   1090322
3   F   28.59   70-74       A   2718649
29  F   4.09    75 and over C   384578
16  F   67.22   65-69       R   1579355
23  F   7.7 …

我正在尝试将gnu与一些基本的生物信息学工具并行使用,例如lastz.所以说我有10个seqs,我想在所有这些上使用lastz,我使用:

parallel --dryrun lastz 'pathToFile/seq{}.fa query.fasta --format=text > LASTZ_results_seq{}' ::: {1..10} 

哪个工作正常并返回:

lastz pathToFile/seq1.fa query.fasta --format=text > LASTZ_results_seq1
lastz pathToFile/seq2.fa query.fasta --format=text > LASTZ_results_seq2
lastz pathToFile/seq3.fa query.fasta --format=text > LASTZ_results_seq3
...
lastz pathToFile/seq10.fa query.fasta --format=text > LASTZ_results_seq10

但理想情况下,我希望这一步是bash脚本的一部分,它需要三个命令行参数,所以seqs的数量(例如1到10)在命令行中给出($ 2 = startValue,$ 3 = endValue值).我认为改变它可以工作:

parallel --dryrun lastz 'pathToFile/seq{}.fa query.fasta --format=text > LASTZ_results_seq{}' ::: {"$2".."$3"}

但相反,返回

lastz pathToFile//seq\{\1..\10\} query.fasta --format=text > LASTZ_results_seq\{\1..\10\}

谁能告诉我这里我做错了什么？看起来它将2美元解释为1,将3美元解释为10,但后来却没有将其视为一系列数字......

我的笔记本电脑有4个核心,经过一些简单的测试后,我发现当我使用4个或更多作业的多处理时,我的CPU使用率为100%,3个作业约占75%,2个作业占50%,25% 1份工作.这对我来说非常有意义.

然后我发现我的程序在多处理过程中运行的速度提高了4倍,但我觉得它不应该总是快4倍.

例如,如果我正在运行5个作业,那么我的第5个作业是否应该排队并且只有在完成这4个作业中的任何一个之后才能处理,因为我只有4个核心可供使用？换句话说,如果所有作业都是相同的,并且每个作业需要T秒,所以它们需要5T秒而不需要多处理,那么它们是否应该采用2T来处理多处理,给定4个核心来分割工作？

但是,我的测试结果大约是5T/4,多处理.我真的很好奇为什么,下面是我的测试代码:

import multiprocessing
import time
def worker(num):

    print ("Worker"+str(num)+" start!")
    for i in range(30000000):
        abc = 123
    print ("Worker"+str(num)+" finished!")
    return



if __name__ == '__main__':
    jobs = []
    start = time.time()

    for i in range(5):
        p = multiprocessing.Process(target=worker, args=(i,))
        jobs.append(p)
        p.start()
        # p.join()


    for job in jobs:
        job.join()

    end = time.time()
    print (end - start)

编辑: 在阅读@nneonneo的回答后,我想出了这个后续问题:

如果我的5个作业没有花费相同的时间,但T,T,T,T和2T秒,并且OS调度程序试图确保所有进程获得相等的时间,那么T秒后,我的前4个作业将完成.然后我的核心中只有一个可以在最后一个工作上工作,因此总时间将是T + T = 2T秒,对吧？总时间不再是6T/4.

我正在为我创建的模拟器创建一个闪亮的应用程序.为了加快模拟速度,我使用了parallel包.

我的应用程序在没有并行化我的代码时工作正常,尽管它很慢.但是,当我并行化时,我收到以下错误:

Error in checkForRemoteErrors(val) : 
  3 nodes produced errors; first error: Operation not allowed without an active reactive context. (You tried to do something that can only be done from inside a reactive expression or observer.)

这是我的ui.R和server.R的删节版本:

ui.R

library(shiny)

shinyUI(fluidPage(
  titlePanel("Simulator"),

  fluidRow(
    column(6,
           fluidRow(
             column(5,
                    helpText("Choose 9 bitcoins for firm 1"),
                    selectizeInput("firm1bit1", label = "Bitcoin 1:",
                                   choices = data$bitcoin, options = 
                                     list(maxOptions = 7)),
                    selectizeInput("firm1bit2", label = "Bitcoin 2:",
                                   choices = data$bitcoin, options =
                                     list(maxOptions = 7)), …

我已经看到了以下问题:Bash运行两个命令并从两者获得输出几乎响应我的需要.

但是,wait命令是阻塞的,这意味着如果命令2在命令1成功之前失败,则命令2失败但命令1成功时命令不会返回.

是否可以并行运行多个命令,并且只要其中一个命令失败就返回1,如果所有命令都成功则返回0(并尽快返回)？

如果使用标准命令(如xargs或并行)可能会更好,但如果使用bash编写也可以.

例如,我按顺序运行4个脚本:

%run -i script1.py
%run -i script2.py
%run -i script3.py
%run -i script4.py

每个执行时间都很长.在iPython笔记本中是否有任何方法可以并行运行脚本并从所有这些变量中返回局部变量(2或3个变量很重要)？在顺序执行中它工作正常但很长.先感谢您.

我试图应用这个主题的代码,但坚持第一部分:

def my_func(my_file):
      !python pgm.py my_file

或者在我的情况下:

 def my_func(my_file):
      %run -i $my_file

我可以看到代码的执行正在发生但在此之后我无法从这些脚本中看到局部变量.

我试图了解使用MPI进行并行处理时阻塞和非阻塞消息传递机制之间的区别。假设我们有以下阻止代码：

#include <stdio.h> 
#include <string.h> 
#include "mpi.h"

int main (int argc, char* argv[]) {
    const int maximum_message_length = 100;
    const int rank_0= 0;
    char message[maximum_message_length+1]; 
    MPI_Status status; /* Info about receive status */ 
    int my_rank; /* This process ID */
    int num_procs; /* Number of processes in run */ 
    int source; /* Process ID to receive from */
    int destination; /* Process ID to send to */
    int tag = 0; /* Message ID */

    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &my_rank); 
    MPI_Comm_size(MPI_COMM_WORLD, …

我有我的脚本while read用于逐行处理一些文件..

当我做:

head -n5 file1 | ./myscript.sh

我的结果很好.

但尝试使用gnu并行化它parallel:

head -n5 file1 | parallel -j 4 ./myscript.sh

产生result文件空!？

我也尝试过:

parallel -j 4 -a file1 ./myscript.sh

但仍然无法正常工作.我试图做类似于他们在文档中所说的内容,但没有任何成功.我究竟做错了什么？

编辑:

也许这可以帮助:

head -n5 file1 | parallel -a - -j 4 echo #this works
head -n5 file1 | parallel -a - -j 4 ./myscript #this doesn't

下面的结果是我有一个令人尴尬的并行for循环,我试图解决.解释这个问题还有一些麻烦,但尽管所有问题都很冗长,但我认为这应该是一个相当简单的问题,多处理模块的设计很容易解决.

我有一个由k个不同函数组成的大长度N数组,以及一个长度为N的abcissa数组.由于@senderle提供的聪明的解决方案在高效算法中描述,用于评估相同长度的1d numpy数组上的1-d函数数组,我有一个快速的基于numpy的算法,我可以用它来评估abcissa的函数返回长度为N的纵坐标数组:

def apply_indexed_fast(abcissa, func_indices, func_table):
    """ Returns the output of an array of functions evaluated at a set of input points 
    if the indices of the table storing the required functions are known. 

    Parameters 
    ----------
    func_table : array_like 
        Length k array of function objects

    abcissa : array_like 
        Length Npts array of points at which to evaluate the functions. 

    func_indices : array_like 
        Length Npts array providing the indices to use to choose which …

我目前正在编写一个简单的WPF文件复制应用程序,它可以并行复制文件.到目前为止它很棒!它做我想做的一切.操作的内容在以下代码块中:

Parallel.ForEach(Directory.GetFiles(dir).ToList(), file =>
{
    _destDetail.CurrOp = string.Format("Copying file: {0}", Path.GetFileName(file));
    File.Copy(file, file.Replace(_destDetail.Source, _destDetail.Dest), true);
    if (_destDetail.Progress < _destDetail.MaxProgress)
        _destDetail.Progress++;
});

我也可以实现ParallelOptions并将最大线程数限制为4,但我想知道是否有办法准确地跟踪每个线程在这种情况下会做什么？

例如,假设我的UI的一部分专用于复制操作的当前"状态".我希望有4行Grid,每行有一个特定的线程和当前正在复制的文件.

我知道我可以使用Interlocked以操纵是外部变量的Parallel循环,但我怎么会跟踪线程特定变量从内部的中Parallel环,并使用这些变量来保持UI最新哪个线程正在哪个文件？