标签: parallel-processing

我正在研究基于时间序列的计算.每次迭代计算都是独立的.有人可以在Matlab中使用并行处理分享一些提示/在线引子吗？如何在实际代码中指定？

我想开始阅读C#/ .Net 4.0中的多线程和并行计算.

我理解多线程的基础知识,所以我正在寻找的东西不仅仅是基础知识.我也在寻找与.Net 4.0中的变化最新的东西.

你能推荐一本书吗？

非常感谢.

我在EC2上运行了一个ebs支持的实例.我正在使用它对大约16Gb的数据进行一些计算密集型文本处理,这些数据存储在sdb上(即与实例关联的较大ebs卷).

我想通过创建此实例的副本来并行化处理,每个副本都有自己的数据副本.我可以从实例创建一个AMI,但我需要图像包含两个sda(根ebs卷)和ALSO sdb,这是所有数据所在的卷.如何制作整个包装的复制品？

在AWS管理控制台中创建映像只是复制sda(即根卷,它太小而无法容纳我的数据).

这甚至可能吗？

(PS:我甚至没有在AWS管理控制台Elastic Block Store-> Volumes面板中看到sdb卷)

谢谢!

在这篇文章之后,我想要并行化这个方法:

    public IEnumerable<string> GetAllLogs(IEnumerable<IComputer> computers)
    {
        foreach (var cpt in computers)
        {
            foreach (var log in cpt.GetLogs())
            {
                yield return log;
            }
        }
    }

当其中一个方法GetLogs完成时,我希望方法"yield returns"成为日志.如果我有4台电脑返回:

• 计算机01:"a","b","c","d","e"
• 计算机02:"1","2","3","4","5"
• 计算机03:"alpha","beta","gamma","delta","epsilon"
• 计算机04:"我","II","III","IV","V"

使用"顺序方法",输出为:

a
b
c
d
e
1
2
3
4
5
alpha
beta
gamma
delta
epsilon
I
II
III
IV
V

这些方法在20秒内运行.有一个Thread.Sleep(1000)在GetLogs方法.

我希望输出看起来像这样:

III
a
4
gamma
b
c
IV
5
d
II
beta
e
1
2
delta
alpha
3
epsilon
I

并在几秒钟内运行.

我想方法返回一个IEnumerable

有什么在C#中类似新的Microsoft C++ 11并发库,允许(因为它是做例如建立异步代理这里)？

我实现了康威的生命游戏.我希望通过使用并行性来加速它.

life :: [(Int, Int)] -> [(Int, Int)]
life cells = map snd . filter rules . freq $ concatMap neighbours cells
    where rules (n, c) = n == 3 || (n == 2 && c `elem` cells)
          freq = map (length &&& head) . group . sort

parLife :: [(Int, Int)] -> [(Int, Int)]
parLife cells = parMap rseq snd . filter rules . freq . concat $ parMap rseq neighbours cells
    where rules (n, c) = n == …

我想使用Ansible在几个远程节点上同时执行一个简单的工作.实际工作涉及点击一些日志文件,然后在我的本地主机(其远程节点上没有软件)上对结果进行后处理.

命令行ansible工具似乎不太适合这种用例,因为它们将ansible生成的格式与远程执行的命令的输出混合在一起.Python API似乎应该能够做到这一点,因为它暴露了未经修改的输出(除了一些潜在的unicode修改,这里不应该相关).

我提出的Python程序的简化版本如下所示:

from sys import argv
import ansible.runner
runner = ansible.runner.Runner(
    pattern='*', forks=10,
    module_name="command",
    module_args=(
        """
        sleep 10
        """),
    inventory=ansible.inventory.Inventory(argv[1]),
)
results = runner.run()

在这里,sleep 10代表实际的日志grepping命令 - 这个想法只是为了模拟一个不会立即完成的命令.

但是,在运行此操作时,我发现所花费的时间似乎与我的库存中的主机数量成正比.以下是分别针对2,5和9主机的库存的时间结果:

exarkun@top:/tmp$ time python howlong.py two-hosts.inventory
real    0m24.285s
user    0m0.216s
sys     0m0.120s
exarkun@top:/tmp$ time python howlong.py five-hosts.inventory                                                                                   
real    0m55.120s
user    0m0.224s
sys     0m0.160s
exarkun@top:/tmp$ time python howlong.py nine-hosts.inventory
real    1m57.272s
user    0m0.360s
sys     0m0.284s
exarkun@top:/tmp$

其他一些随机观察:

• ansible all --forks=10 -i five-hosts.inventory -m command -a "sleep 10" 表现出相同的行为
• ansible …

是否可以在脚本的多次运行中调用gnu parallel,而这些脚本又由gnu parallel生成？

我有一个运行100次连续迭代的python脚本,并且在每次迭代中的某个地方,并行计算4个值(使用gnu parallel).现在我想同时使用gnu parallel生成多个这样的脚本.这可能吗？gnu parallel会不会好好利用可用内核？

例如,如果在内部循环中,4个值中有2个已完成且2个正在运行,那么在计算所有4个值之前,单个脚本无法继续下一次迭代.这两个免费核心是否会用于自动计算不同脚本运行的结果？如何指定可用的核心总数？在内部呼叫并行或外部呼叫？

这个问题表明可以将调用嵌套到并行中,但是当我从脚本内部调用嵌套并行时,我不确定这是否会发生变化.

PS:Thrashing不是一个问题,我可以使用大型集群中的大量核心.

PS2:gnu-parallel是一款非常棒的工具......谢谢!:)

我有以下方法:

public String getResult() {

        List<String> serversList = getServerListFromDB();

        List<String> appList = getAppListFromDB();

        List<String> userList = getUserFromDB();

        return getResult(serversList, appList, userList);
    }

在这里,我按顺序调用三个方法,然后点击DB并获取结果,然后我对从DB命中获得的结果进行后处理.我知道如何通过使用同时调用这三种方法Threads.但我想用Java 8 Parallel Stream来实现这一目标.有人可以指导我如何通过Parallel Streams实现同样的目标吗？

编辑我只想通过Stream并行调用方法.

private void getInformation() {
    method1();
    method2();
    method3();
    method4();
    method5();
}

@njit(parallel=True)当使用 Numba 库中的装饰器运行函数时，我试图限制活动 CPU 核心的数量。

到目前为止，我已经做了这样的事情（示例）：

from numba import njit, prange, set_num_threads

import numpy as np


@njit(parallel=True)
def func():

    for i in prange(int(1e10)):

        print(np.cos(i))


if __name__ == '__main__':
    
    num_threads = input(f'Enter max number of threads to use: ')

    set_num_threads(int(num_threads))

    func()

但即使将线程数设置为 1，使用任务管理器进行快速检查显示工作负载仍然由所有核心共享（在我的例子中为 4）。

在下面的屏幕截图中可以看到这一点。红色圆圈表示程序启动和中断的时间。

任务管理器截图

有没有更好的方法来限制活动核心的数量？