标签: parallel-processing

我已经在Julia工作了几个月了,我有兴趣并行写一些代码.我正在研究一个问题,我使用1个模型为几个不同的接收器生成数据(每个接收器的数据是一个向量).每个接收器的数据可以独立计算,这使我相信我应该能够使用pmap函数.我的计划是将数据初始化为2D SharedArray(每列代表1个接收器的数据),然后在每个列上进行pmap循环.但是我发现将SharedArray与pmap一起使用并不比使用map的串行工作快.我写了下面的虚拟代码来说明这一点.

@everywhere function Dummy(icol,model,data,A,B)
    nx = 250
    nz = 250
    nh = 50
    for ih = 1:nh
        for ix = 1:nx
            for iz = 1:nz
                data[iz,icol] += A[iz,ix,ih]*B[iz,ix,ih]*model[iz,ix,ih]
            end
        end
    end
end


function main()

    nx = 250
    nz = 250
    nh = 50

    nt = 500
    ncol = 100

    model1 = rand(nz,nx,nh)
    model2 = copy(model1)
    model3 = convert(SharedArray,model1)

    data1 = zeros(Float64,nt,ncol)
    data2 = SharedArray(Float64,nt,ncol)
    data3 = SharedArray(Float64,nt,ncol)

    A1 = rand(nz,nx,nh)
    A2 = copy(A1)
    A3 = convert(SharedArray,A1)

    B1 = rand(nz,nx,nh) …

我在Rstudio中使用R 3.3.1的Win7 OS.意图是glmnet与并行处理一起使用.从?glmnet帮助:

parallel:如果TRUE,使用平行的foreach适合每个折叠.必须事先注册并行,例如doMC或其他.请参阅下面的示例.

从引用的例子:

# Parallel
require(doMC)
registerDoMC(cores=4)

install.packages('doMC')返回包不可用.手动检查CRAN可提供可下载的UNIX代码,但Windows二进制文件不可用.

我仍然可以doMC在我的Win7操作系统下使用相同的代码或什么是有用的替代方案？

是否有任何带有t-SNE算法并行版本的Python库？或者存在多核/并行t-SNE算法？

我正在尝试使用t-SNE减少词汇表中所有word2vecs的维度(300d - > 2d).

问题:词汇量的大小约为130000,并且为它们进行t-SNE需要很长时间.

我有一个多维数组（result），应该由一些嵌套循环填充。函数fun()是一个复杂且耗时的函数。我想以并行方式填充数组元素，因此我可以使用系统的所有处理能力。这是代码：

import numpy as np


def fun(x, y, z):
    # time-consuming computation...
    # ...

    return output


dim1 = 10
dim2 = 20
dim3 = 30

result = np.zeros([dim1, dim2, dim3])

for i in xrange(dim1):
    for j in xrange(dim2):
        for k in xrange(dim3):
            result[i, j, k] = fun(i, j, k)

我的问题是“我是否可以并行化此代码？如果可以，如何？”

我正在使用Windows 10 64位和python 2.7。

如果可以的话，请通过更改我的代码来提供您的解决方案。谢谢！

我有一个程序可以生成很多(太字节)的输出并将其发送到stdout.

我想分割输出并与另一个程序的一堆实例并行处理它.它可以以任何方式分发,只要线条保持完整即可.

Parallel可以执行此操作,但它需要固定数量的行并在此之后重新启动过滤器进程:

./relgen | parallel -l 100000 -j 32 --spreadstdin ./filter

有没有办法保持一定数量的进程运行并在它们之间分配数据？

如何在满足条件的情况下为所有工作人员返回的函数中编写并行for循环？

就是这样的:

function test(n)
  @sync @parallel for i in 1:1000
    {... statement ...}
    if {condition}
      return test(n+1)
    end
  end
end

所有工人都停止在for循环上工作,只有主进程返回？(其他进程再次开始使用下一个for循环？)

如果输入大小太小,库会自动序列化流中地图的执行,但这种自动化不会,也不能考虑地图操作的重要程度.有没有办法强制parallelStream()实际并行化CPU 重图？

根据OCP的书,人们必须避免有状态的操作,否则称为有状态的lambda表达.本书中提供的定义是"有状态的lambda表达式,其结果取决于在执行管道期间可能发生变化的任何状态."

它们提供了一个示例,其中使用并行流将固定的数字集合添加到使用该.map()函数的同步ArrayList中.

arraylist中的顺序是完全随机的,这应该让人看到有状态的lambda表达式在运行时产生不可预测的结果.这就是为什么强烈建议在使用并行流时避免有状态操作以消除任何潜在的数据副作用.

它们没有显示无状态lambda表达式,它提供了解决同一问题的方法(向同步的arraylist添加数字),我仍然不知道使用map函数用数据填充空的同步arraylist的问题. ..在执行管道期间可能发生变化的状态究竟是什么？他们指的是Arraylist本身吗？就像当另一个线程决定在并行流仍处于添加数字并因此改变最终结果的过程中时将其他数据添加到ArrayList时？

也许有人可以为我提供一个更好的例子来说明有状态的lambda表达式是什么以及为什么要避免它.非常感谢.

谢谢

我在这里发现了一种"奇怪"的行为.我懂了:

{-# LANGUAGE BangPatterns #-}

import Data.List
import Control.Parallel
import Control.Parallel.Strategies

fib 0 = 1
fib 1 = 1
fib n = fib (n-1) + fib (n-2)

main =
  let xs = [ fib (20 + n `mod` 2) | n <- [0..1000] ]
              `using` test rseq
   in print (sum xs)

test :: Strategy a -> Strategy [a]
test strat xs = do
  parTraversable strat xs  -- case #1
  -- parList strat xs      -- case #2
  return xs

case #1 …

问题和背景

这篇文章描述了一个无锁的32位哈希表算法.算法的核心是无锁线性搜索,用于在(逻辑)列表中插入key-val对:

这是提供的代码:

void ArrayOfItems::SetItem(uint32_t key, uint32_t value)
{
    for (uint32_t idx = 0;; idx++)
    {
        uint32_t prevKey = mint_compare_exchange_strong_32_relaxed(&m_entries[idx].key, 0, key);
        if ((prevKey == 0) || (prevKey == key))
        {
            mint_store_32_relaxed(&m_entries[idx].value, value);
            return;
        }
    }
}

对于特定问题,我需要在表中插入随机键 - 值对.因此,我需要至少64位密钥,因为对于32位,在65536次插入后有50%的冲突几率,这太低了.不幸的是,我没有 64位cmpxchg作为原语.

题

是否可以将上面的哈希表概括为64位密钥,仅使用32位cmpxchg？