标签: parallel-processing

这对我来说似乎很吵.五行开销太多了.

m_Lock.EnterReadLock()
Try
    Return m_List.Count
Finally
    m_Lock.ExitReadLock()
End Try

那你怎么这么简单呢？

我是.Net平台的新手.我做了一个搜索,发现有几种方法可以在.Net中进行并行计算:

1. 任务并行库中的并行任务,即.Net 3.5.

2. PLINQ,.Net 4.0

3. Asynchounous Programming,.Net 2.0,(异步主要用于执行I/O繁重的任务,F#有一个简洁的语法支持这一点).我列出这个是因为在Mono中,似乎没有TPL或PLINQ.因此,如果我需要编写跨平台并行程序,我可以使用异步.

4. .Net线程.没有版本限制.

您能否对这些做一些简短评论或在此列表中添加更多方法？

我有一个返回IO动作的函数,

f :: Int -> IO Int

我想为参数的多个值并行计算这个函数.我天真的实施如下:

import Control.Parallel.Strategies

vals = [1..10]
main = do
      results <- mapM f vals
      let results' = results `using` parList rseq
      mapM_ print results'

我给这理由是,第一mapM结合型的东西IO [Int]来results,results'应用并行的策略所包含的名单,并mapM_通过打印,最后请求的实际值-但究竟是要打印并行已经引起的,所以程序应并行.

在确实使用了我所有的CPU之后感到高兴,我注意到程序在运行时效果较差(如挂钟时间),而+RTS -N8不是没有任何RTS标志.我能想到的唯一解释是,第一个mapM必须排序 - 即执行 - 所有IO操作已经,但这不会导致无效,但使N8执行与非平行的一样有效,因为所有的工作都由主线程.以+RTS -N8 -s收益率运行程序SPARKS: 36 (11 converted, 0 overflowed, 0 dud, 21 GC'd, 4 fizzled),这肯定不是最优的,但不幸的是我无法理解它.

我想我已经在Haskell并行化或IO monad的内部找到了初学者的垫脚石之一.我究竟做错了什么？

背景信息:f n是一个返回Project Euler问题n的解决方案的函数.由于其中许多都有要读取的数据,因此我将结果放入IO monad中.它看起来如何的一个例子是 …

可能重复:
并行处理期间的C#值存储

我今天在我的控制台应用程序中运行了一些性能测试,我偶然发现了一些非常意外的事情.我的代码:

int iterations = 1000000;

var mainList = new List<string>();

for (int i = 0; i < iterations; i++)
{
    mainList.Add(i.ToString());
}

var listA = new List<string>();

Parallel.ForEach(mainList, (listItem) =>
                           {
                               if (Int32.Parse(listItem)%2 == 0)
                               {
                                   listA.Add(listItem);
                               }
                           });

Console.WriteLine("Parallel Count: {0}", listA.Count);

var listB = new List<string>();
foreach (var listItem in mainList)
{
    if (Int32.Parse(listItem) % 2 == 0)
    {
        listB.Add(listItem);
    }
}

Console.WriteLine("Sequential Count: {0}", listB.Count);

这产生了一个输出:

平行计数:495939

顺序计数:500000

我运行了几次,并行循环似乎永远不会在适当的时间执行.任何人都能解释这种"不端行为"吗？并行循环是否值得信赖？

PS我知道在提供的代码示例中有很多废话,比如ToString()调用一个整数而不是解析它们但这只是我在测试时提出的随机代码.提前致谢.

听起来在ZeroMQ中使用传统UNIX套接字的套接字是没有意义的.我基于对ZeroMQ的错误感知设计了一种用于分布式搜索算法的架构.在我的程序中,有一个代理负责监视其他代理并收集他们的数据.在PULL-PUSH或PUB-SUB模式之后,将在代理之间传输实际数据.每个代理都有一个PULL套接字监听传入的消息.每条消息都包含一个ID号,用于指定发送者标识.

在初始化阶段,监视器应该监听其REP套接字.每个代理将连接到监视器的着名REP套接字并自我介绍(发送他的ID号和代理正在侦听的端口号).监视器将有关代理的所有数据存储在三个字段的记录中:<ID, IP, port>.(这是我在ZMQ遇到问题的地方.)当某些代理计数器准备就绪时,监视器会将所有数据(每个代理程序<IP,ID,port>)发送给所有代理程序.最后一步是通过代理和监视器之间的PUB-SUB模式完成的.

这张图片可能有助于了解我的意图:

在上面的图片中,显示器应该将它的表发送给每个人.关键问题是如何以REQ-REP模式获取请求者(任何代理)的公共IP地址？所有代理都绑定到其本地主机(127.0.0.1).它们应该分布在任意数量的主机上.所以AFAIK他们需要了解彼此的公共IP.

在没有解决方案的情况下,任何有关重新设计架构的帮助都是合适的.

更新

我能想到的一个候选解决方案是修改每个代理以绑定到他/她的公共IP而不是localhost.如果有一种获取公共IP地址的神奇方法,任何代理都可以将其地址发送到监视器.

第二次更新

目前,代理获取其公共IP地址并通过消息将其发送到服务器:

std::string AIT::ABT_Socket::getIP() {
    std::string address = "";
    FILE * fp = popen("ifconfig", "r");
    if (fp) {
        char *p = NULL, *e;
        size_t n;
        while ((getline(&p, &n, fp) > 0) && p) {
            if (p = strstr(p, "inet addr:")) {
                p += 10;
                if (e = strchr(p, ' ')) {
                    *e = '\0';
                    return std::string(p);
                    address = std::string(p);

                }
            }
        }
    }
    pclose(fp);
    return …

我有一个项目,其中包括一个代码生成器,它只需一次调用代码生成器就可以从一个输入文件生成几个.c和.h文件.我有一个规则,其中.c和.h文件作为多个目标,输入文件作为先决条件,配方是代码生成器的调用.然后我有进一步的规则来编译和链接生成的.c文件.

这可以正常使用-j因子为1,但如果我增加j因子,我发现我得到了代码生成器的多次调用,直到-j因子或预期目标文件的数量,以最小者为准.这很糟糕,因为代码生成器的多次调用可能会因生成的代码被多次写入而导致失败.

我不打算在这里发布我的实际(大)代码,但我已经能够构建一个似乎表现出相同行为的小例子.

Makefile看起来像这样:

output.concat: output5 output4 output3 output2 output1
    cat $^ > $@

output1 output2 output3 output4 output5: input
    ./frob input

clean:
    rm -rf output*

对于此示例,我编写了一个简单的shell脚本,frob而不是代码生成器,它从一个输入文件生成多个输出文件:

#!/bin/bash

for i in {1..5}; do
    {
    echo "This is output${i}, generated from ${1}. input was:"
    cat ${1}
    } > output${i}
done

当我使用非统一-j因子运行此Makefile时,我得到以下输出:

$ make -j2 
./frob input
./frob input
cat output5 output4 output3 output2 output1 > output.concat
$

我们看到./frob这里被调用了两次,这很糟糕.有没有什么方法可以构造这个规则,使配方只被调用一次,即使是非统一-j因子？

我考虑过更改规则,以便只有一个预期的输出文件是目标,然后添加另一个没有配方的规则,使其目标是剩余的预期输出文件,先决条件是第一个预期的输出文件.但我不确定这会起作用,因为我不知道我是否可以保证生成文件的顺序,因此可能最终会产生循环依赖.

所以我们有一个不是线程安全的应用程序.它正在使用的一些库正在对文件系统级别进行锁定.不幸的是,它没有正常工作,如果有一些并发使用的库会崩溃并抛出错误.我们也无法切换这个库.要实现并发,哪一个更好？在一台功能强大的机器中运行100个容器或将其分成100个小型机器？

由于我们使用的是亚马逊,我想的是每个运行一个容器的100个X t2.micro实例和一个带有100个泊坞容器的c4.8xlarge机器.我们对记忆没有任何问题.任务受CPU限制.但它也不是那么重,只要它只处理一个t2.micro实例就足以处理它.

我和一位同事讨论了哪一个更好.我更喜欢100个实例,因为我认为Docker隔离将是一个重大的开销.这就像你只有一个资源,但它分为100个需要使用资源的人.另一方面,我的同事提出了一些我认为可能有效的观点.创建Linux命名空间比启动整个操作系统要轻.因此,如果我们有100台机器,我们有100台操作系统,而使用大型机器,我们只有1台操作系统.

问题是,我不知道哪一个是正确的.有这方面知识的人可以解释哪一个会更好并给我一个具体的理由吗？

由于我意识到我刚问了一个不好的问题,我将尝试在这里添加更多信息.为了使问题更加准确,我并不是真的要问哪一个在我的特定用例中更好,哪个更便宜.这只是一个好奇心,在CPU方面表现更好.想象一下,我们有一个非常大的计算问题,我们必须做100个.我们想要并行化它们,但它们不是线程安全的.在100台小型机器或1台100台容器的强大机器中进行它们会更好吗？哪一个会更快完成,为什么？

如果我们只有一台功能强大的机器,那么所有这100个集装箱都不会争夺资源并减缓整个过程吗？如果它是100台小型机器,由于操作系统或其他因素,整体性能可能会更慢？无论如何,我对此没有任何经验.当然我可以试试这个,但最后,因为它不是理想的环境(有很多因素),所以结果不会是权威的.我一直在寻找那些知道两种情况如何在低级别工作的人的答案,并且可以论证哪种环境能够更快地完成任务.

我正在尝试训练几个随机森林(用于回归)让他们竞争,看看哪个特征选择和哪个参数给出最佳模型.

然而,训练似乎花了很多时间,我想知道我做错了什么.

我用于训练的数据集(train下面称为)有217k行和58列(其中只有21列作为随机森林中的预测变量.它们都是numeric或者integer,除了布尔值,它是类的character该y输出是numeric).

我跑到下面的代码四次,给值4,100,500,2000到nb_trees:

library("randomForest")
nb_trees <- #this changes with each test, see above
ptm <- proc.time()
fit <- randomForest(y ~ x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 
    + x10 + x11 + x12 + x13 + x14 + x15 + x16 + x17 + x18 + x19 …

我试图用平行运行我的查询,我得到一个00001: Error in .jcheck() : No running JVM detected. Maybe .jinit() would help.错误.当我逐个运行查询时,查询正在运行

我的剧本:

我知道它不是真正的可再现但我不能给你我的日志/通行证:)

我试图.jinit()和Sys.setenv(JAVA_HOME='C:\\Program Files\\Java\\jdk1.8.0_102')在从它不工作

library(RJDBC)
library(parallelemap)

jdbcDriver <- JDBC(driverClass="oracle.jdbc.OracleDriver",  classPath="ojdbc6.jar" )
jdbcConnection <- dbConnect(jdbcDriver, "jdbc:oracle:thin:@//mybase", "login", "pass")

query_list<- list( "SELECT * FROM table1",
                   "SELECT * FROM table2",
                   "SELECT * FROM table3",
                   "SELECT * FROM table4", 
                   "SELECT * FROM table5")


 import_base_fonction <- function(query) {return(dbGetQuery( jdbcConnection , query))}


parallelStartSocket( 5 ) 

parallelLibrary("RJDBC","rJava")
parallelExport("listquery_list","import_base_fonction" ,"jdbcConnection")

mes_tables <- parallelMap(import_base_fonction,query_list)  

parallelStop() 

我的会话信息

R version 3.4.1 (2017-06-30) …

我有一个bash脚本,其函数需要与不同的参数并行运行.我需要知道是否至少有一个执行失败(返回非零) - 无论多少失败都无关紧要.

该命令接受执行的参数数组.由于高负载,我需要将并发限制为4次并发运行.我还需要在父进程(运行bash脚本的进程)中打印日志

这是我正在运行的功能:

function run_and_retry {
  EXIT_STATUS=0
  $COMMAND || EXIT_STATUS=$?

  if [ $EXIT_STATUS -ne 0 ]; then
    EXIT_STATUS=0
    $COMMAND || EXIT_STATUS=$?

  fi

  return $EXIT_STATUS
}

我尝试过使用GNU parallel和xargs,并遇到了两个问题.

使用xargs :(无法从中获取退出状态,当我在TravisCI中运行它时也无效)

PARAMETERS=(first-parameter second-parameter third-parameter)
export -f run_and_retry
echo "${PARAMETERS[@]}" | xargs -P 4 -n 1 -I {} bash -c "run_and_retry {}"

使用GNU并行:

PARAMETERS=(first-parameter second-parameter third-parameter)
export -f run_and_retry
parallel -j 4 -k --lb 2 run_and_retry {} ::: echo "${PARAMETERS[@]}"