标签: parallel-processing

我需要一个支持这些声明的多线程数据结构:

• 允许多个并发读者和作者
• 排序
• 容易推理

实现多个读者和一个作家要容易得多,但我真的不想允许多个作家.

我一直在研究这个领域,我知道ConcurrentSkipList(由Lea基于Fraser和Harris的工作),因为它是在Java SE 6中实现的.我还实现了我自己的并发Skip List版本在一个可证明正确的缩放并发跳表由赫利希,列弗,Luchangco和沙维特.

这两个实现是由比我更聪明的人开发的,但我仍然(有点惭愧,因为它是惊人的工作)不得不问这些问题是否是并发多读/写器数据结构的两个唯一可行的实现今天有空吗？

下面的代码只是创建一个List> of random numbers,然后计算并行foreach循环中每个列表的累积和.为什么我得到的数字少于'numLists'？通常在9990左右.我猜它与线程安全有关.什么是替代方法？(我是C#初学者,所以希望我使用正确的术语)谢谢.

using System;  
using System.Collections.Generic;  
using System.Threading.Tasks;  

namespace testParallelForeach
{
    class Program
    {
        static void Main(string[] args)
        {

            List<List<double>> bsData = new List<List<double>>();
            List<List<double>> cumsumDataP = new List<List<double>>();
            int numLists = 10000;
            int myLen = 400;
            Random rand = new Random();
            for (int i = 0; i < numLists; i++)
            {
                bsData.Add(new List<double>());
                for (int j = 0; j < myLen; j++)
                {
                    bsData[i].Add(rand.NextDouble());
                }
            }
            Parallel.ForEach(bsData, a => cumsumDataP.Add(CumulativeSumParallel(a)));
            Console.WriteLine("cumsumDataP.Count={0}", cumsumDataP.Count);
            Console.ReadKey();

        }

        public static List<double> …

我在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 == …

我目前正在使用gfortran 4.9.2,我想知道编译器是否真的知道如何利用DO CONCURRENT构造(Fortran 2008).我知道编译器"支持"它,但不清楚它是什么.例如,如果打开自动并行化(指定了一定数量的线程),编译器是否知道如何并行化并发循环？

编辑:正如评论中提到的,关于SO的前一个问题与我的非常相似,但它是从2012年开始的,只有最新版本的gfortran已经实现了现代Fortran的最新功能,所以我认为值得询问2015年编译器的当前状态.

目标是在Java 8流的帮助下处理连续的元素流.因此,在处理该流时,将元素添加到并行流的数据源中.

Streams的Javadoc在"无干扰"部分中描述了以下属性:

对于大多数数据源,防止干扰意味着确保在流管道的执行期间根本不修改数据源.值得注意的例外是其源是并发集合的流,这些集合专门用于处理并发修改.并发流源是Spliterator报告CONCURRENT特性的源.

这就是在我们的尝试中使用ConcurrentLinkedQueue的原因,它返回true

new ConcurrentLinkedQueue<Integer>().spliterator().hasCharacteristics(Spliterator.CONCURRENT)

没有明确说明,在并行流中使用时不得修改数据源.

在我们的示例中,对于流中的每个元素,递增的计数器值被添加到队列中,该队列是流的数据源,直到计数器大于N.通过调用queue.stream(),一切正常,顺序执行:

import static org.junit.Assert.assertEquals;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Stream;

public class StreamTest {
    public static void main(String[] args) {
        final int N = 10000;
        assertEquals(N, testSequential(N));
    }

    public static int testSequential(int N) {
        final AtomicInteger counter = new AtomicInteger(0);
        final AtomicInteger check = new AtomicInteger(0);
        final Queue<Integer> queue = new ConcurrentLinkedQueue<Integer>();

        for (int i = 0; i < N / 10; ++i) {
            queue.add(counter.incrementAndGet());
        }

        Stream<Integer> …

我是 powershell 的新手，刚刚学习它。我有一些 C# 经验。我正在尝试使用 foreach-object -Parallel 选项，但无法让所有 Write-* 函数正常工作。

function writeTest {
        1..1 | ForEach-Object -Parallel {
            Write-Host "host"
            Write-Output "Output"
            Write-Information "information" -InformationAction Continue
            Write-Verbose "verbose"
            Write-Warning "Warning"
            Write-Error "error"       
        }
}

函数调用如下：writeTest -verbose

输出：

host
Output
WARNING: Warning
Write-Error: error

我的问题是为什么 write-verbose 和 write-information 不显示任何内容？

如有无知之处请原谅。

@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）。

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

任务管理器截图

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