标签: parallel-processing

我想将这个功能并行化,但我是开放式mp的新手,如果有人能帮助我,我将不胜感激:

void my_function(float** A,int nbNeurons,int nbOutput, float* p, float* amp){
   float t=0;
   for(int r=0;r<nbNeurons;r++){
      t+=p[r];
   }

   for(int i=0;i<nbOutput;i++){
      float coef=0;
      for(int r=0;r<nbNeurons;r++){
       coef+=p[r]*A[r][i];
      }
   amp[i]=coef/t;
   }
}

由于双循环,我不知道如何正确并行化它,目前,我只考虑做一个: #pragma omp parallel for reduction(+:t)

但我认为这不是通过openMp更快地实现计算的最佳方式.

预先感谢,

如何修改以下代码并使其同时运行多个任务？

foreach (SyndicationItem item in CurrentFeed.Items)
{
    if (m_bDownloadInterrupted)
    break;

    await Task.Run( async () =>
    {
        // do some downloading and processing work here
        await DoSomethingAsync();
    }
}

我还需要中断并尽可能地停止这个过程.因为我的DoSomethingAsync方法读取标记(一个全局布尔值)来停止进程.

谢谢

我一直在阅读和重新阅读IPython文档/教程,我无法弄清楚这段特殊代码的问题.看起来这个函数dimensionless_run对于传递给每个引擎的命名空间是不可见的,但我很困惑,因为函数是在__main__全局命名空间中定义的,并且清晰可见.

wrapper.py:

import math, os

def dimensionless_run(inputs):
    output_file = open(inputs['fn'],'w')
    ...
    return output_stats

def parallel_run(inputs):
    import math, os  ## Removing this line causes a NameError: global name 'math'
                     ## is not defined.
    folder = inputs['folder']
    zfill_amt = int(math.floor(math.log10(inputs['num_iters'])))
    for i in range(inputs['num_iters']):
        run_num_str = str(i).zfill(zfill_amt)
        if not os.path.exists(folder + '/'):
            os.mkdir(folder)
        dimensionless_run(inputs)
    return

if __name__ == "__main__":
    inputs = [input1,input2,...]
    client = Client()
    lbview = client.load_balanced_view()
    lbview.block = True
    for x in sorted(globals().items()):
        print x
    lbview.map(parallel_run,inputs) …

我试图在任务并行库中找到Task.WaitAll(..).

我正在使用以下代码运行测试以尝试模拟两个任务,一个将比指定的等待时间(10秒)运行更长时间(10秒),一个运行时间少于指定的时间(3秒)等待的时间.指定的时间是5秒.我使用的代码如下:

Task<int>[] tasks = new Task<int>[]
{
    Task.Factory.StartNew<int>(()=>
        {
            Thread.Sleep(10000);
            return 1;
        }),
    Task.Factory.StartNew<int>(()=>
        {
            Thread.Sleep(3000);
            return 2;
        })
};

TimeSpan timeSpan = new TimeSpan(0, 0, 5);
Task.WaitAll(tasks,timeSpan);

int[] results = new int[tasks.Length];
for(int i = 0; i < tasks.Length;i++)
{
    Console.WriteLine(tasks[i].Result);
}

至于timeSpan,我也尝试直接传入5000而不是timeSpan变量,但它不起作用.我得到以下输出:

1
2

我希望只得到以下输出,因为另一个线程的执行时间超过了预期的等待时间.

1

我误解了这个,还是做错了？

我试图通过多个进程更新一个常用字典.你能帮我找一下这段代码有什么问题吗？我得到以下输出:

inside function
{1: 1, 2: -1}
comes here
inside function
{1: 0, 2: 2}
comes here
{1: 0, 2: -1}

谢谢.

from multiprocessing import Lock, Process, Manager

l= Lock()


def computeCopyNum(test,val):
    l.acquire()
    test[val]=val
    print "inside function"
    print test
    l.release()
    return

a=dict({1: 0, 2: -1})

procs=list()

for i in range(1,3):
    p = Process(target=computeCopyNum, args=(a,i))
    procs.append(p)
    p.start()

for p in procs:
p.join()
    print "comes here"

print a

我正在尝试掌握fork()和exec()的概念,以用于我自己的学习目的.我正在尝试使用perl fork作为第二个相同的进程,然后使用它来执行.sh脚本.

如果我使用fork()和exec(),我可以让.sh脚本与我的perl脚本并行运行吗？Perl脚本不会等待子进程并继续执行.所以我的perl脚本并不关心子进程的输出,而只关心命令有效并且正在运行.有点像调用脚本在后台运行.

我是否可以通过某种安全措施来了解子进程是否正确退出？

我正在使用一个位于(例如)a StreamReader或者顶部的界面SqlDataReader.接口公开一个方法,GetNext()如果有任何对象,或者null如果没有剩下,则返回一个对象.

public interface ICollectionWidget<T>
{
    T GetNext(); // Returns a T if there are any left, or null if there aren't
}

我需要并行处理每个T返回的GetNext(),并在GetNext()返回时停止处理 null.我不太确定这是怎么做的(使用TPL或其他).我需要一种平行while!显然,我不希望任何线程仍然处理完成,当我得到一个null,我只是不想添加任何新的处理 - 然后当所有线程完成他们正在做的事情时退出'循环' .

有人可以帮忙吗？如果我的问题没有意义,请告诉我.

在我的应用我有三个班,Extractor,Transformer并且Loader,由第四类协调Coordinator.Extractor,Transformer并且Loader非常简单,并执行以下操作:

Extractor

公开名为Resultstype 的成员IEnumerable<string>,例如通过从文本文件中读取.提取应该是同步的.

Transformer

公开一个被调用的成员Transform,它接受一个字符串并通过某个过程将其转换为另一个字符串,这个过程预计很费时(在这里使用并行处理).

Loader

公开一个名为的成员Load,该成员接受一个字符串并将其加载到某个最终形式(例如另一个文本文件)中.加载应该是同步的.

这些Coordinator类协调三个操作.转换过程应该并行完成,然后将结果推送到加载程序读取的队列.Coordinator的Run()方法如下:

Extractor extractor = new Extractor();
Transformer transformer = new Transformer();
Loader loader = new Loader();

ConcurrentQueue<string> outputs = new ConcurrentQueue<string>();

Parallel.ForEach(extractor.Results, x => outputs.Enqueue(transformer.Transform(x)));

foreach(string output in outputs)
{
  loader.Load(output);
}

这样做很有效,除了必须在任何加载完成之前完成ALL转换 - 即Parallel.ForEach()在下一个foreach开始之前完成.我希望每个输出在准备就绪后立即传递给加载器.

我也试过这个:

Extractor extractor = new …

我已经注意到这么多次了,我不知道它为什么会这样

对于这个例子:它全部用asp,缓冲,IIS 7,运营商级服务器,充满RAM和CPU编写

正如您在捕获时看到的那样,首先执行主页面,然后使用Jquery调用3个ajax脚本.

我必须在document.ready事件之前调用第一个,以便在其他2个之前回答它.

否则,如果同时调用3,则在最慢的执行完成之前,它们将无法得到答案.两个持续时间在document.ready上调用.我们清楚地看到,当最慢的执行结束时,2开始响应.但是最轻的一个人会非常快,有些毫秒.

当我从应用程序下载一些文件时也会发生这种情况.该应用程序使用bynarystream方法发送文件.当从浏览器客户端下载文件时,应用程序将不会回复任何其他浏览器请求(例如,在另一个选项卡中),直到下载完成.

奇怪的是,您可以打开另一个浏览器(IE,Chrome ...),服务器将立即回答任何请求,但对于这个新浏览器将采取相同的行动.此浏览器的任何请求都不能并行运行.

我知道ASP是一个旧东西,但有人可以告诉我为什么它这样工作？

是因为浏览器限制还是技术？由于会话机制？由于IIS？由于数据库访问(我认为没有,因为下载流媒体内容时不涉及数据库访问)？它会以另一种方式为其他语言和环境工作吗？

我可以改变这种行为吗？怎么样 ？

干杯

弗雷德

这是我第一次遇到类似下面的内容.

• 多个线程(实现Runnable的内部类)共享数据结构(上层类的实例变量).

• 工作:从Eclipse项目的bin文件夹中获取类,在Unix机器上运行.

• 不工作:直接在Unix机器上编译src并使用那些类文件.代码编译然后运行时没有错误/警告,但是一个线程无法正确访问共享资源.

• 问题:一个线程将元素添加到上面的公共DS中.第二个线程执行以下操作...

  while(true){
   if(myArrayList.size() > 0){
   //do stuff
   }
  

  Run Code Online (Sandbox Code Playgroud)

  }

• 日志显示大小在线程1中更新.

• 出于某种神秘的原因,工作流程并没有因为()......

如果我直接粘贴Eclipse的bin文件夹中的类文件,则完全相同的代码运行完美.

如果我错过任何明显的事,我道歉.

码:

ArrayList<CSRequest> newCSRequests = new ArrayList<CSRequest>();

//线程1

private class ListeningSocketThread implements Runnable {
    ServerSocket listeningSocket;

    public void run() {
        try {
            LogUtil.log("Initiating...");
            init(); // creates socket
            processIncomongMessages();
            listeningSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void processIncomongMessages() throws IOException {     
        while (true) {
            try {
                processMessage(listeningSocket.accept());
            } catch (ClassNotFoundException e) {                    
                e.printStackTrace();
            }
        }
    }

    private void processMessage(Socket s) throws IOException, …