标签: parallel-processing

如果您计划编写一个计算量很大的并行应用程序,那么您将使用什么准则来设计对象(无论是类还是结构,还是其他任何东西),以最大限度地发挥从并行性中获得最大收益的潜力.

我正在考虑一个应用程序,它说解释/编译一个类似于树的图形对象,它需要创建东西,将它传递给另一个要处理的对象,依此类推,具有树状结构.

从早期的设计过程中应该考虑什么？

我的应用程序中有两个线程.是否可以同时执行两个线程而不会休眠任何线程？

请帮助我使用openmp使这个代码并行这个代码是在按钮点击运行,文本框是128

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace IMG
{
public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }

    string path = "";
    public void openimage()
    {
        if (openFileDialog1.ShowDialog() == DialogResult.OK)
        {
            path = openFileDialog1.FileName;
            Graphics g = this.CreateGraphics();
            g.Clear(this.BackColor);
            Bitmap curBitmap = new Bitmap(path);
            g.DrawImage(curBitmap, 200, 220, 200, 200);
        }
    }
    Bitmap bm;
    Bitmap gs;
    private void button1_Click(object sender, EventArgs e)
    {
        if (path == "") …

我正在尝试在OS X 10.5上的GHC 6.10.4(来自MacPorts)中运行并行代码

我在makefile中使用-threaded构建:

GHC=ghc -prof -auto-all -O -threaded

glicko: glicko.hs Lib.hs
        $(GHC) --make -main-is Glicko glicko.hs lib.hs

当我调用./glicko +RTS -N或./glicko +RTS -N1代码运行时,似乎只使用一个CPU.如果我调用as ./glicko +RTS -N2,那么我将获得记录命令行参数的运行时帮助消息; 但是文档表明这应该运行该程序.

为什么-N2不起作用？

这里有更多时间信息:

$ ./glicko +RTS --info
 [("GHC RTS", "YES")
 ,("GHC version", "6.10.4")
 ,("RTS way", "rts_thr_p")
 ,("Host platform", "i386-apple-darwin")
 ,("Host architecture", "i386")
 ,("Host OS", "darwin")
 ,("Host vendor", "apple")
 ,("Build platform", "i386-apple-darwin")
 ,("Build architecture", "i386")
 ,("Build OS", "darwin")
 ,("Build vendor", "apple")
 ,("Target platform", "i386-apple-darwin")
 ,("Target architecture", "i386")
 ,("Target OS", …

我需要在我的多核桌面上并行化CPU密集型Java应用程序,但我对线程编程不太满意.我看了Scala,但这意味着要学习一种非常耗时的新语言.我还看了Ateji PX Java并行扩展,看起来很容易使用,但还没有机会评估它.有人会推荐吗？欢迎其他建议.

在此先感谢您的帮助

法案

我编写了一个简单的测试程序来比较使用 MPI 并行化多个进程的性能，或者使用std::thread. 并行化的工作只是写入一个大数组。我看到的是，多进程 MPI 的性能远远优于多线程。

测试代码为：

#ifdef USE_MPI
#include <mpi.h>
#else
#include <thread>
#endif
#include <iostream>
#include <vector>

void dowork(int i){
    int n = 1000000000;
    std::vector<int> foo(n, -1);
}

int main(int argc, char *argv[]){
    int npar = 1;
#ifdef USE_MPI
    MPI_Init(&argc, &argv);
    MPI_Comm_size(MPI_COMM_WORLD, &npar);
#else
    npar = 8;
    if(argc > 1){
        npar = atoi(argv[1]);
    }
#endif
    std::cout << "npar = " << npar << std::endl;

    int i;

#ifdef USE_MPI
    MPI_Comm_rank(MPI_COMM_WORLD, &i);
    dowork(i);
    MPI_Finalize();
#else
    std::vector<std::thread> threads;
    for(i …

我有一个并行的 Bash 函数：

#!/bin/bash

touch out.txt
vals=$(seq 1 1 20)
task(){
    echo $1 >> out.txt
    x=$(wc -l out.txt | cut -d' ' -f 1) #read current length of file
    if [ $x > 5 ]
    then
    echo $x #NB prints even if <5!!
    KILL_ALL_JOBS_HERE_ON_IF_THEN_CONDITION
    fi
}

export -f task

echo $vals | xargs -P2 -I'{}' -d' ' bash -c 'task "$1"' bash {} 

该函数开始将二十个值回显到单个文本文件。但是，当文件长度超过 5 行时，我希望所有进程/实例停止并且不再处理变量中的值。我该怎么做？（注意一个小问题，if-then 语句也很奇怪 - 它会回显处理后的值 $x，无论它是否 >5）。

当我尝试从以下代码中执行数学表达式时，矩阵值不一致，如何解决这个问题？

#pragma omp parallel num_threads (NUM_THREADS)
    {
    #pragma omp for
        for(int i = 1; i < qtdPassos; i++)
        {   
            #pragma omp critical
            matriz[i][0] = matriz[i-1][0]; /
            for (int j = 1; j < qtdElementos-1; j++)
            {
                matriz[i][j] = (matriz[i-1][j-1] + (2 * matriz[i-1][j]) + matriz[i-1][j+1]) / 4; // Xi(t+1) = [Xi-1 ^ (t) + 2 * Xi ^ (t)+ Xi+1 ^ (t)] / 4
            }
            matriz[i][qtdElementos-1] = matriz[i-1][qtdElementos-1]; 
        }
    }

我正在学习 SIMD 内在函数和并行计算。我不确定Intel对x86指令的定义sqrtpd是否 表示将同时计算传递给它的两个数字的平方根：

对源操作数（第二个操作数）中的两个、四个或八个压缩双精度浮点值的平方根执行 SIMD 计算，并将压缩双精度浮点结果存储在目标操作数（第二个操作数）中第一个操作数）。

我知道它明确表示SIMD 计算，但这是否意味着对于此操作，将同时计算两个数字的根？

我现在正在学习 Go，并且对并发、并行和顺序之间的区别感到非常沮丧。

假设我们有一个流程，可以截取 5 个 URL 的片段并将内容粘贴到文本文件中。每个 URL 该过程需要 2 秒。

• 顺序 -> 需要 10 秒，因为它一个接一个地执行
• 并行 -> 需要不到 10 秒的时间，因为它同时执行这些操作，但使用多个线程或处理器。
• 并发 -> 耗时不到 10 秒，但不需要多个线程或处理器。

直到这里我还不确定我是否正确。我的问题是：

我读到并行性可以同时做事情（例如跑步和听音乐），而并发可以同时处理事情（例如在熨烫衬衫的同时完成早餐）。

但如果是这样的话，为什么并发不需要 10 秒才能完成，因为在一天结束时，您并不是同时做所有事情，而是只做所有事情的一部分，直到完成所有事情？