标签: parallel-processing

我有一些代码使用共享网关模式来实现控件容器的反转.我有几百个NUnit单元测试来运行使用这个IOC的代码.他们都工作(在我的机器上!)但我担心这些测试可能会在负载下失败.我似乎记得NUnit(和MSTest)试图在多个线程上并行运行测试(这肯定会触发静态/共享网关上的竞争条件),但我找不到任何说明实际发生情况的文档.我的经验是,NUnit似乎正在顺序运行测试.我的问题是,NUnit(或MSTest)是否并行运行单元测试？如果是这样,在什么条件下？而且,我可以通过某种配置选项关闭它吗？

我正在寻找能够在群集上轻松运行(正确编码)令人尴尬的并行JVM代码的东西(这样我就可以使用Clojure + Incanter).

我过去曾使用Parallel Python来做到这一点.我们有一个新的PBS集群,我们的管理员很快将设置使用PBS作为后端的IPython节点.这两个系统都使得在集群中运行某些类型的代码几乎是明智之举.

我错误地在过去使用Hadoop(Hadoop不适合我使用的那种数据) - 甚至小的运行延迟执行1-2分钟.

JPPF或Gridgain更适合我需要的吗？这里有没有人有任何经验？还有什么可以推荐的吗？

我想知道你们中是否有人知道为什么我的表现很糟糕;

我想要实现的目标; 生成220万个文件.要创建每个文件,平均需要2-5个数据库调用.

我正在处理的服务器有24个内核和190GB的RAM.

我将需要生成的文件分为24个批次.

乳清我使用下面的代码,我的表现很糟糕.生成过程需要一个多小时.

Parrallel.ForEach(batches, batch => 
{
    using (var ctx = new MyContext())
    {
        for each(var file in batch.Files)
        {
            GenerateFile(file);
        }
    }
});

但是,当我确保我的程序收到一个参数,以便progam知道要生成哪个批处理,所以我不需要使用并行功能.如果我使用以下.bat文件为每个批处理执行程序;

START CaMaakEiBericht.exe \B1
START CaMaakEiBericht.exe \B2
...
START CaMaakEiBericht.exe \B24

它的运行速度惊人!总生成过程不到15分钟!此批处理文件还确保每个核心的CPU使用率约为90%.当我使用Parallel方法时,我只能获得30-40%的使用率.

有人对此有合理的解释吗？我对这个项目感到很满意,因为我终于有可能将.NET 4 Parallel库与EF结合使用,但不幸的是,它让我很失望:-)

我个人有点怀疑EF是这里的瓶颈......它是否在内部缓存一些东西,当多个进程获取数据时会强加一些锁？

开导我 :-)

来自Josh Suereth的"Scala in Depth":

"应用仿函数提供了一种方法来进行两次计算并使用函数将它们连接在一起.Traversable示例突出显示了如何将两个集合并行化成对.应用仿函数和并行处理就像面包和黄油一样."

我对整个functor/monads/applicative东西有一个模糊的概念,但并不完全掌握它(对整个monad来说是新的,functor的东西).我理解monads(flatten,flatMap)和monadic工作流以及functor(maps)的概念.

任何人都可以就它的完成方式,示例和/或优势与"传统"并行化方面的问题详细说明一下吗？

scala并行收集操作的效果与Akka Actors(和Futures)在系统上的有效调度方面使用的并发性/并行性有关吗？

演员和期货的执行是由ExecutionContext一般提供的Dispatcher.我在并行集合上发现它表明它们使用了一个TaskSupport对象.我找到了一个ExecutionContextTaskSupport可能连接这两个但不确定的物体.

混合两种并发解决方案的正确方法是什么,或者建议不要这样做？

我试图在Haskell中尝试并行评估,但似乎已经碰壁了.

就像一个实验一样,我想评估一个需要很长时间才能完成的任务列表.所以我想出了这个人为的例子.

import Control.Parallel.Strategies

startNum = 800000

bigList :: [Integer]
bigList = [2042^x | x <- [startNum..startNum+10]]

main = print $ sum $ parMap rdeepseq (length . show) bigList

我编译了这个,ghc -O2 -eventlog -rtsopts -threaded test.hs --make然后运行了两次.

$ time ./test +RTS -N1 -lf -sstderr
29128678
   2,702,130,280 bytes allocated in the heap
      59,409,320 bytes copied during GC
       3,114,392 bytes maximum residency (68 sample(s))
       1,093,600 bytes maximum slop
              28 MB total memory in use (6 MB lost due to fragmentation)
                                    Tot …

我目前正在测试Parallel for C#.通常它工作正常,使用并行比正常的foreach循环更快.但是,有时(如5次中的1次),我的CPU将达到100%的使用率,导致并行任务非常慢.我的CPU设置为i5-4570,内存为8gb.有谁知道为什么会出现这个问题？

以下是我用来测试功能的代码

            // Using normal foreach
            ConcurrentBag<int> resultData = new ConcurrentBag<int>();
            Stopwatch sw = new Stopwatch();
            sw.Start();
            foreach (var item in testData)
            {
                if (item.Equals(1))
                {
                    resultData.Add(item);
                }
            }
            Console.WriteLine("Normal ForEach " + sw.ElapsedMilliseconds);

            // Using list parallel for
            resultData = new ConcurrentBag<int>();
            sw.Restart();
            System.Threading.Tasks.Parallel.For(0, testData.Count() - 1, (i, loopState) =>
            {
                int data = testData[i];
                if (data.Equals(1))
                {
                    resultData.Add(data);
                }
            });
            Console.WriteLine("List Parallel For " + sw.ElapsedMilliseconds);

            // Using list parallel foreach
            //resultData.Clear();
            resultData = new ConcurrentBag<int>(); …

我是Spark的新手,并尝试用Python理解Spark概念.在使用Python为Spark开发应用程序时,我对以并行方式处理数据的方式感到困惑.

1.每个人都说我不需要担心在处理封装在RDD变量中的数据时会调用哪个节点和多少个节点.因此,基于我的最佳理解,我相信Spark集群会对下面的代码做什么:

a = sc.textFile(filename)
b = a.filter(lambda x: len(x) > 0 and x.split("\t").count("9999-12-31") == 0)
c = b.collect()

可以描述为以下步骤:

(1)变量a将被保存为包含预期txt文件内容的RDD变量
(2)不同的RDD块a将被广播到集群中的不同节点,并且当不同节点
(3)中的每个块时将进行过滤方法.调用集合操作,结果将从不同节点返回到主节点并保存为局部变量c.

我的描述是对的吗？如果没有,该程序究竟是什么？如果我是对的,那么并行化方法有什么意义呢？以下代码是否与上面列出的代码相同？

a = sc.textFile(filename).collect()
b = sc.parallelize(a).filter(lambda x: len(x)>0 and x.split("\t").count("9999-12-31"))
c = b.collect()

2.对于以下代码,是否可以通过将定义的表划分为多个分区来并行处理SQL查询语法？

a = sc.textFile(filename)
b = a.filter(lambda x: len(x) > 0 and x.split("\t").count("9999-12-31") == 0)
parts = b.map(lambda x: x.split("\t"))
records = parts.map(Row(r0 = str(x[0]), r1 = x[1], r2 = x[2]))
rTable …

我通过在perl被调用中使用forking模块并行运行一些代码Parallel::ForkManager.我目前将最大进程数设置为30:

my $pm = Parallel::ForkManager->new(30);

什么是最合适的创建流程？我在商业级Solaris服务器上这样做,但我仍然不想让系统超载.

有没有办法明确设置/限制std::async和相关类使用的并行度(=单独线程数)？

仔细阅读线程支持库并没有发现任何有希望的东西.

尽可能接近,std::async实现(通常是？)在内部使用线程池.是否有标准化的API来控制这个？

对于后台:我在一个设置(共享集群)中,我必须手动限制使用的核心数.如果我没有这样做,负载共享调度程序会抛出一个拟合,我会受到惩罚.特别是,std::thread::hardware_concurrency()没有有用的信息,因为物理核心的数量与我所受的约束无关.

这是一段相关的代码(在C++ 17中使用并行TS,可能会使用并行std::transform编写):

auto read_data(std::string const&) -> std::string;

auto multi_read_data(std::vector<std::string> const& filenames, int ncores = 2) -> std::vector<std::string> {
    auto futures = std::vector<std::future<std::string>>{};

    // Haha, I wish.
    std::thread_pool::set_max_parallelism(ncores);

    for (auto const& filename : filenames) {
        futures.push_back(std::async(std::launch::async, read_data, filename));
    }

    auto ret = std::vector<std::string>(filenames.size());
    std::transform(futures.begin(), futures.end(), ret.begin(),
            [](std::future<std::string>& f) {return f.get();});
    return ret;
}

从设计的角度来看,我已经期望这个std::execution::parallel_policy类(来自并行性TS)允许指定(事实上,这就是我在我为硕士论文设计的框架中所做的那样).但事实似乎并非如此.

理想情况下,我想要一个C++ 11的解决方案,但是如果有一个用于更高版本的解决方案,我仍然想知道它(尽管我不能使用它).