标签: parallel-processing

如何在Cython中的(Python)列表上并行迭代？

考虑以下简单功能:

def sumList():
    cdef int n = 1000
    cdef int sum = 0

    ls = [i for i in range(n)]

    cdef Py_ssize_t i
    for i in prange(n, nogil=True):
        sum += ls[i]

    return sum

这会产生很多编译器错误,因为没有GIL的并行部分显然无法与任何Python对象一起使用:

Error compiling Cython file:
------------------------------------------------------------
...

    ls = [i for i in range(n)]

    cdef Py_ssize_t i
    for i in prange(n, nogil=True):
        sum += ls[i]
     ^
------------------------------------------------------------

src/parallel.pyx:42:6: Coercion from Python not allowed without the GIL

Error compiling Cython file:
------------------------------------------------------------
...

    ls = [i for …

我是用平行的Haskell函数普兰par和pseq我已经发现了一些有趣的事情.

我的例子基于Real World Haskell的书(Haskell中的并行编程)中的例子:

常用代码:

import Control.Parallel (par, pseq)

-- <<sorting code goes here>>

force :: [a] -> ()
force xs = go xs `pseq` ()
    where go (_:xs) = go xs
          go [] = 1

main = do
    print $ take 10 $ parSort [0..1000000]

排序代码1(取自本书):

parSort :: (Ord a) => [a] -> [a]
parSort (x:xs)    = force greater `par` (force lesser `pseq`
                                         (lesser ++ x:greater))
    where lesser  = …

在选择并行化任务时,我通常使用Spark.阅读有关Akka中并行处理的文章,例如http://blog.knoldus.com/2011/09/19/power-of-parallel-processing-in-akka/,似乎使用Akka进行并行处理的程度较低.似乎Spark从用户中抽象出一些较低级别的概念,例如map reduce.Spark为分组和过滤数据提供高级抽象.Akka是Spark的并行任务的竞争者还是他们解决了不同的问题？

在决定使用哪种注意事项之前,我应该做什么？

我在我的程序中使用GZIPInputStream,我知道如果我可以让Java并行运行我的程序,性能会有所帮助.

通常,标准VM是否有一个命令行选项可以在许多内核上运行？它只运行一个.

谢谢!

编辑

我正在Windows XP上运行普通的'Java SE 6更新17'.

将GZIPInputStream放在一个单独的线程上显然会有帮助吗？没有!不要将GZIPInputStream放在单独的线程上!不要多线程I/O!

编辑2

我想I/O是瓶颈,因为我正在读写同一个磁盘......

但总的来说,有没有办法让GZIPInputStream更快？或者是并行运行的GZIPInputStream的替代品？

编辑 我使用的3个代码片段:

GZIPInputStream gzip = new GZIPInputStream(new FileInputStream(INPUT_FILENAME));
DataInputStream in = new DataInputStream(new BufferedInputStream(gzip));

要预先,这是功课.话虽如此,它是非常开放的,我们几乎没有关于如何开始考虑这个问题(或一般的并行算法)的指导.我想指向正确的方向,而不是完整的解决方案.任何可能有帮助的阅读都会很好.

我正在研究一种有效的方法,使用并行算法匹配大量文本中第一次出现的模式.模式是简单的字符匹配,不涉及正则表达式.我已经设法找到了找到所有比赛的可能方法,但那要求我查看所有比赛并找到第一个比赛.

所以问题是,我是否会在流程和扫描方式之间取得更多成功？或者最好是进行某种类型的进程同步搜索,其中第j个进程搜索模式的第j个字符？如果所有进程都为其匹配返回true,则进程将改变它们在匹配所述模式中的位置并再次向上移动,继续直到所有字符都已匹配,然后返回第一个匹配的索引.

到目前为止我所拥有的是非常基本的,而且很可能不起作用.我不会实现这一点,但任何指针都将不胜感激.

使用p个处理器,长度为t的文本,长度为L的模式,以及使用的L个处理器的上限:

 for i=0 to t-l:
    for j=0 to p:
        processor j compares the text[i+j] to pattern[i+j]
            On false match:
                all processors terminate current comparison, i++
            On true match by all processors:
                Iterate p characters at a time until L characters have been compared
                If all L comparisons return true:
                    return i (position of pattern)
                Else:
                    i++

我刚开始玩任务并行库,遇到了有趣的问题; 我对将要发生的事情有一个大概的了解,但是希望听到比我更有能力的人的评论来帮助了解正在发生的事情.我为有点冗长的代码道歉.

我开始使用随机游走的非并行模拟:

 var random = new Random();
 Stopwatch stopwatch = new Stopwatch();

 stopwatch.Start();

 var simulations = new List<int>();
 for (var run = 0; run < 20; run++)
 {
    var position = 0;
    for (var step = 0; step < 10000000; step++)
    {
       if (random.Next(0, 2) == 0)
       {
          position--;
       }
       else
       {
          position++;
       }
    }

    Console.WriteLine(string.Format("Terminated run {0} at position {1}.", run, position));
    simulations.Add(position);
 }

 Console.WriteLine(string.Format("Average position: {0} .", simulations.Average()));
 stopwatch.Stop();

 Console.WriteLine(string.Format("Time elapsed: {0}", stopwatch.ElapsedMilliseconds));
 Console.ReadLine();

然后我在并行循环中写了我的第一次尝试:

 var localRandom …

我正在编写一个使用Socket的应用程序,它将非常密集,然后我真的需要使用我们在大服务器中的每个核心.我在stackoverflow中看到了问题(如何使用ThreadPool运行套接字线程？)这里只有一个答案指向此MSDN示例.

但我认为它只指向如何使它并发而不是并行,这里有人问如何cpu密集是打开一个套接字,它看起来非常密集,有人在这里说它不帮助TPL TaskFactory.FromAsync vs任务与阻塞方法和某人在这里教会如何使用TaskFactory.FromAsync(是否存在将现有的BeginXXX/EndXXX异步方法包装成异步任务的模式？).

如何保持套接字操作并行和高性能,如果处理插槽问题,如断开连接,半连接套接字和消息边界是正常异步方式的头疼.如果将TPL和Task放在一起,如何处理它.

这一切都发生在Windows服务中.

我有一个Queue<T>(实际上是ConcurrentQueue<T>)等待处理的物品.但是,我不想一次只处理一个,我想同时处理n个项目,其中n是一个可配置的整数.

如何使用任务并行库进行此操作？

我知道TPL会代表开发人员对集合进行并发处理,但不确定这是否是我追求的功能.我是多线程和TPL的新手.

我想在特定值上增加索引,例如2:

for (int i = 0; i < 10; i+=2)
{
    Console.WriteLine(i);
}

我如何使用Parallel该类做同样的事情,例如:

Parallel.For(0, 10, i =>
{
    Console.WriteLine(i);
    i += 2; //this a naïve assumption, it's not working
});

编辑

我希望Parallel循环只运行5个操作(作为顺序),顺序对我来说无关紧要.

鉴于作为独立计算引擎的对象的核心模型(存储是实例变量,CPU是类方法)响应从一个传递到另一个的消息,似乎Smalltalk自然适合于大量的并行处理核心.然而,这是一个Smalltalk确实非常弱的领域,它回应了自己的模拟多任务功能,这些功能没有利用现代处理器的硬件功能.

为什么是这样？主要问题是什么？可变性是关键,还是Smalltalk更具体的东西？