标签: parallel-processing

我正在尝试使用MPI和opemMP一起制作并行版本的"Harmonic Progression Sum"问题.但输出是彼此不同的过程.

有人可以帮我完成这个问题吗？

并行程序:(MPI和OpenMP)

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <sstream>
#include <time.h>
#include <omp.h>
#include <mpi.h>

#define d 10    //Numbers of Digits (Example: 5 => 0,xxxxx)
#define n 1000  //Value of N (Example: 5 => 1/1 + 1/2 + 1/3 + 1/4 + 1/5)

using namespace std;

double t_ini, t_fim, t_tot;

int getProcessId(){
    int rank;
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    return rank;
}

int numberProcess(){
    int numProc;
    MPI_Comm_size(MPI_COMM_WORLD, &numProc);
    return numProc;
}

void reduce(long unsigned int digits1 [])
{ …

在尝试在Haskell程序中添加多线程功能后,我注意到性能根本没有改善.追逐它,我从threadscope获得了以下数据:

绿色表示正在运行,橙色表示垃圾收集. 这里垂直的绿色条表示火花创建,蓝色条表示并行GC请求,浅蓝色条表示创建线程. 标签是:创建spark,请求并行GC,创建线程n,以及从第2章窃取火花.

平均而言,我只能在4个内核上获得大约25%的活动,这与单线程程序相比没有任何改进.

当然,如果没有实际程序的描述,这个问题就会无效.本质上,我创建了一个可遍历的数据结构(例如树),然后在它上面映射一个函数,然后将其提供给一个图像编写例程(在程序运行结束时解释明确的单线程段,超过15秒) .函数的构造和fmapping都需要花费大量的时间来运行,尽管第二个稍微多一点.

上图是通过在图像写入消耗之前为该数据结构添加parTraversable策略来完成的.我也尝试在数据结构上使用toList,然后使用各种并行列表策略(parList,parListChunk,parBuffer),但每次对于各种参数(甚至使用大块)的结果都相似.
我还试图在将函数映射到它之前完全评估可遍历的数据结构,但是出现了完全相同的问题.

以下是一些其他统计信息(针对同一程序的不同运行):

   5,702,829,756 bytes allocated in the heap
     385,998,024 bytes copied during GC
      55,819,120 bytes maximum residency (8 sample(s))
       1,392,044 bytes maximum slop
             133 MB total memory in use (0 MB lost due to fragmentation)

                                    Tot time (elapsed)  Avg pause  Max pause 
  Gen  0     10379 colls, 10378 par    5.20s    1.40s     0.0001s    0.0327s
  Gen  1         8 colls,     8 par    1.01s    0.25s     0.0319s    0.0509s

  Parallel GC work balance: 1.24 (96361163 / 77659897, ideal 4) …

是否可以在与R并行的单个多核机器上迭代单个文本文件？对于上下文,文本文件介于250-400MB的JSON输出之间.

编辑:

以下是我一直在玩的一些代码示例.令我惊讶的是,并行处理没有赢 - 只是基本的lapply - 但这可能是由于我的用户错误.另外,当试图读取一些大文件时,我的机器窒息了.

## test on first 100 rows of 1 twitter file
library(rjson)
library(parallel)
library(foreach)
library(plyr)
N = 100
library(rbenchmark)
mc.cores <- detectCores()
benchmark(lapply(readLines(FILE, n=N, warn=FALSE), fromJSON),
          llply(readLines(FILE, n=N, warn=FALSE), fromJSON),
          mclapply(readLines(FILE, n=N, warn=FALSE), fromJSON),
          mclapply(readLines(FILE, n=N, warn=FALSE), fromJSON, 
                   mc.cores=mc.cores),
          foreach(x=readLines(FILE, n=N, warn=FALSE)) %do% fromJSON(x),
          replications=100)

这是第二个代码示例

parseData <- function(x) {
  x <- tryCatch(fromJSON(x), 
                error=function(e) return(list())
                )
  ## need to do a test to see if valid data, if so ,save out the files
  if …

最近我已经阅读了很多关于.NET中的并行编程的内容,但我仍然对这个主题的文本中的语句相矛盾.

例如,弹出(在鼠标指向标记的图标上时)stackoverflow.com task-parallel-library标记的描述:

"任务并行库是.NET 4的一部分.它是一组API,使开发人员能够编写多核共享内存处理器"

这是否意味着使用早期版本的.NET无法实现多核d和并行编程应用程序？

我是否在.NET多线程应用程序中控制核心之间的多核/并行使用/分配？

如何识别要运行线程的核心并将线程归属到特定核心？

什么启用了.NET 4.0+任务并行库,这在以前的.NET版本中是不可能的？

更新:
嗯,很难提出具体问题,但我想更好地理解:

.NET在开发多线程应用程序和并行编程之间有什么区别？

到目前为止,我无法理解它们之间的区别

Update2:
MSDN ".NET Framework中的并行编程"从.NET 4.0版本开始,其文章任务并行库告诉:

"从.NET Framework 4开始,TPL是编写多线程和并行代码的首选方式"

您是否可以提示如何在.NET4之前(在.NET3.5中)专门创建并行代码,同时考虑到我熟悉多线程开发？

//    parallel processing

    int processors = Runtime.getRuntime().availableProcessors();
    ExecutorService executorService = Executors.newFixedThreadPool(threads);


    final List<String> albumIds2 = new ArrayList<String>();
    long start2 = System.nanoTime();
    for (final HColumn<String, String> column : result.get().getColumns()) {
        Runnable worker = new Runnable() {

            @Override
            public void run() {
                albumIds2.add(column.getName());
            }
        };
        executorService.execute(worker);
    }
    long timeTaken2 = System.nanoTime() - start2;

我有像上面的例子一样的代码,它创建了一个List<String>专辑ID.该列是来自cassandra数据库的切片.我记录要创建的整个专辑列表所用的时间.

我使用增强的for循环完成了同样的操作,如下所示.

        QueryResult<ColumnSlice<String, String>> result =  CassandraDAO.getRowColumns(AlbumIds_CF, customerId);
    long start = System.nanoTime();
    for (HColumn<String, String> column : result.get().getColumns()) {
        albumIds.add(column.getName());
    }
    long timeTaken = System.nanoTime() - start; …

我需要一些帮助来理解GPU上的内核与CPU中的内核的概念,以便进行并行计算.

说到CPU中的核心,看起来很简单.我有一个超级密集的"for"循环,迭代四次.我的Intel i5 2.26GHz CPU有四个内核.我给每个核心一个循环.四个循环中的每一个都独立于另一个.繁荣 - 我现在创建了四个线程和100%CPU使用率(而不是只有一个核心的25%CPU使用率).我的"for"循环现在运行速度比没有并行化时快四倍.顺便说一下,对于"for"循环,我使用了Microsoft Visual Studio 2012上提供的自动并行化,如在线示例所示:( http://msdn.microsoft.com/en-us/library/hh872235. aspx).

相比之下,我甚至不知道我可以用于并行计算的笔记本电脑的GPU(英特尔图形媒体加速器HD,或英特尔高清显卡,1696MB共享内存)中的内核数量.我甚至不知道将GPU与CPU进行比较的有效方法.当我在我的显卡描述旁边看到"12 @ 500MHz"时,我想知道这是否意味着显卡有12个并行核心,可以像CPU中的4个内核一样工作,除了GPU核心运行在500MHz [慢而不是2.26GHz [快]？GPU使用率是否与Windows任务管理器中的CPU使用率相当？我是一个试图在visual studio 2012中使用C++库的新手,如果这有任何区别的话.当我编写实际的GPU软件时,并行化代码如下所示:( http://msdn.microsoft.com/en-us/library/hh265137.aspx).

那么,请您填写我的知识中的一些空白或错误​​,或者帮助我比较两者？我不需要一个非常复杂的答案,就像"由于空白空白而无法将CPU核心与GPU核心进行比较"或"GPU核心不像CPU核心那样真正的核心"这样简单非常感谢.

我正在尝试使用OpenMP在以下函数中并行化循环

 void CEnergymulti::forcetwobody(vector<CMolecule*>  m_mols,CPnt force0,CPnt torque0)
{
 const int nmol=m_mols.size();
 vector<CMolecule*> twomols(2);
 CPnt forcetemp,torquetemp;
 twomols.clear();
 force0.zero();
 torque0.zero();
 forcetemp.zero();
 torquetemp.zero();
 #pragma omp parallel for reduction(+:force0,torque0) private(twomols)
 for(int j=1;j<nmol;j++)
       { twomols.push_back(m_mols[0]);
         twomols.push_back(m_mols[j]);
         CMolecule::polarize_mutual(twomols,false, 1000);
         twomols[0]->computeMol_Force_and_Torque(forcetemp,torquetemp);
         force0+=forcetemp;
         torque0+=torquetemp;
         forcetemp.zero();
         torquetemp.zero();
         twomols.clear();
        }
     REAL converter=COUL_K*IKbT;
     force0*=converter;
     torque0*=converter;
     return;
     }

当我编译代码时,它给出以下消息:

EnergyD_multi.cpp: In static member function ‘static void
CEnergymulti::forcetwobody(std::vector<CMolecule*,
std::allocator<CMolecule*> >, CPnt, CPnt)’: EnergyD_multi.cpp:226:
error: ‘torque0’ has invalid type for ‘reduction’
EnergyD_multi.cpp:226: error: ‘force0’ has invalid type for
‘reduction’

我知道变量'force0'和'torque0'既不是双重或整数类型的数据,而是类型'CPnt',这是一个定义为表示空间中三维向量的类.对于类'CPnt',运算符'+'和' - '已经由运算符重载定义.所以我的问题是:OpenMP的减少是否真的无法处理这样的重载运算符？有没有其他方法可以将此循环与OpenMP并行化而不减少'force0'和'torque0'的每个组件？

非常感谢.

我正在学习并行化,在一个练习中,我给出了一些我应该提高性能的算法.其中一个是Fibonacci序列生成器:

array[0] = 0;
array[1] = 1;
for (q = 2; q < MAX; q++) {
    array[q] = array[q?1] + array[q?2];
}

我怀疑这是不能优化的(通过并行化),因为每个数字都取决于前两个数字(因此间接地取决于所有前面的数字).怎么可以并行化呢？

介绍

我想就我将要自己开始的新编程项目请求很多建议.对于我想要完成的事情以及我的基本要求,我将非常精确.因此,这将是一个长期的问题.请多多包涵.

我将把问题分为五个部分:

1. 现实世界的问题
2. 模拟问题
3. 要求和偏好
4. 附加信息
5. 建议请求列表

1.现实世界的问题

摩天大楼和大型桥梁受到动态风荷载的影响.这意味着,如果设计不正确,它们会因风引起的振动而崩溃(这实际上发生在1940年:http://www.youtube.com/watch？v = 3mclp9QmCGs).为了正确设计这样的结构,需要有效的数字运算软件进行分析和模拟.

2.模拟问题

存在许多能够模拟流体流动或结构力学的软件.许多已经开发了30多年,并且是经过验证和成熟的技术.因此,编写一个能够同时模拟流体流动和结构力学的多物理程序是不明智的.首先,在成熟之前需要多年的开发才能进入一个依赖特定软件超过30年的世界.但更重要的是......为什么在重用时重新创建？我不喜欢采用单片方法,而是采用分区方法,可以重用现有的仿真软件.

在分区方法中,我将使用软件X来模拟流程,我将使用软件Y来模拟结构.然后我将编写自己的耦合算法,建立X和Y之间的通信,并使用它们来模拟多物理问题(例如摩天大楼或桥梁的风引起的振动).我使用X和Y而不是实际软件名称的原因是因为X和Y应该是黑盒子.我的耦合算法决不依赖于X和Y的实现.算法将仅依赖于X和Y的输出.这样最终用户可以选择哪个X或Y可用于哪个或哪个永远X或Y能够做到最终用户想要实现的目标.

因为我想使用黑盒分区方法,软件X不知道Y,反之亦然.但是,如何在不知道周围气流的情况下模拟桥梁的变形,以及如何知道周围气流在不知道任何变形的情况下被周围气流扰动的方式？答案很简单:从猜测开始,使用迭代方法收敛到正确的解决方案.然而,这种方法在计算上非常昂贵.为了降低计算成本,可以使用非常有效的技术以巧妙的方式编写耦合算法,这里不再讨论.我想说的是需要一些重线性代数数字运算.

3.要求和偏好

我需要做的是:

• 建立第三方开源或专有软件之间的通信
• 执行一些重数字运算(线性代数)
• 可视化结果(2D/3D绘图和动画)
• 提供交互式分析和开发环境
• 创建直观的图形用户界面

我想要的软件是什么:

• 开源
• 跨平台
• 可通过脚本和/或共享库进行扩展

我打算用什么:

• 用于重数字运算的C++
• CPython用于编程逻辑
• NumPy/SciPy在CPython中进行一些数字运算
• Matplotlib用于CPython中的结果可视化

4.补充资料

事实:

• 一开始就是单人项目,如果成功就会成长为公司
• 主操作系统是基于KDE的Linux发行版

商业模式:

• 免费软件和基本文档.
• 付费服务和精心制作的文档.

5.建议请求清单

我想通过编写许多单独执行一项微小任务的函数来完成C++中的所有数字运算.程序逻辑将包含在CPython包中,该包执行整个模拟,同时依靠C++函数执行数字运算.C++/CPython算法将使用CPython(使用NumPy,SciPy,SymPy和Matplotlib)编写的脚本进行扩展,以生成和可视化原始数值数据的结果.我希望能够进行并行计算,我需要与几个第三方开源和专有软件进行通信.

要完成所有这些我将需要一大堆现有的库/包/技术等.对于所有相关问题,我知道我可以使用什么,但是我不知道我应该使用什么.最好的解决方案是一如既往地尝试一切,看看最有效的方法.但是,如果任何有经验的用户可以淘汰一些更不可能的候选人,我很乐意收到他或她的建议,建议,赞成/列表:

1. 粘贴C++和CPython(例如CTypes,SIP,SWIG等)
2. C++线性代数数字运算库(例如Armadillo,Eigen,PETSc等)
3. 图形界面开发库(例如Qt,GTK,wxWidgets等)
4. 软件通信和并行计算(例如MPICH,OpenMPI,OpenMP等)
5. CPython 2.7.x或CPython 3.x.

注意:我总结了上面的一些选项,但这些只是示例性而非限制.只要它是用C,C++,Fortran或Python编写的,我对所有东西都是开放的.此外,我不希望在一个人的上述所有五个类别中得到答案.让社区的集体知识来处理这个问题.

我感谢所有的贡献者,并祝你在自己的努力中一切顺利.

有没有一种简单的方法来使用scala并行集合而无需将完整集合加载到内存中？

例如,我有一个大型集合,我想在一个小块上并行执行特定操作(折叠),这个块适合内存,而不是另一个块等等,最后重新组合所有块的结果.

我知道,可以使用actor,但是使用par-collections会非常好.

我写了一个解决方案,但它并不好:

  def split[A](list: Iterable[A], chunkSize: Int): Iterable[Iterable[A]] = {
    new Iterator[Iterable[A]] {
      var rest = list
      def hasNext = !rest.isEmpty
      def next = {
        val chunk = rest.take(chunkSize)
        rest = rest.drop(chunkSize)
        chunk
      }
    }.toIterable
  }                                               

  def foldPar[A](acc: A)(list: Iterable[A], chunkSize: Int, combine: ((A, A) => A)): A = {
    val chunks: Iterable[Iterable[A]] = split(list, chunkSize)
    def combineChunk: ((A,Iterable[A]) => A) = { case (res, entries) => entries.par.fold(res)(combine) }
    chunks.foldLeft(acc)(combineChunk)
  }                                               

  val chunkSize = 10000000                        
    val x = …