标签: parallel-processing

我在我的程序中使用GZIPInputStream,我知道如果我可以让Java并行运行我的程序,性能会有所帮助.

通常,标准VM是否有一个命令行选项可以在许多内核上运行？它只运行一个.

谢谢!

编辑

我正在Windows XP上运行普通的'Java SE 6更新17'.

将GZIPInputStream放在一个单独的线程上显然会有帮助吗？没有!不要将GZIPInputStream放在单独的线程上!不要多线程I/O!

编辑2

我想I/O是瓶颈,因为我正在读写同一个磁盘......

但总的来说,有没有办法让GZIPInputStream更快？或者是并行运行的GZIPInputStream的替代品？

编辑 我使用的3个代码片段:

GZIPInputStream gzip = new GZIPInputStream(new FileInputStream(INPUT_FILENAME));
DataInputStream in = new DataInputStream(new BufferedInputStream(gzip));

要预先,这是功课.话虽如此,它是非常开放的,我们几乎没有关于如何开始考虑这个问题(或一般的并行算法)的指导.我想指向正确的方向,而不是完整的解决方案.任何可能有帮助的阅读都会很好.

我正在研究一种有效的方法,使用并行算法匹配大量文本中第一次出现的模式.模式是简单的字符匹配,不涉及正则表达式.我已经设法找到了找到所有比赛的可能方法,但那要求我查看所有比赛并找到第一个比赛.

所以问题是,我是否会在流程和扫描方式之间取得更多成功？或者最好是进行某种类型的进程同步搜索,其中第j个进程搜索模式的第j个字符？如果所有进程都为其匹配返回true,则进程将改变它们在匹配所述模式中的位置并再次向上移动,继续直到所有字符都已匹配,然后返回第一个匹配的索引.

到目前为止我所拥有的是非常基本的,而且很可能不起作用.我不会实现这一点,但任何指针都将不胜感激.

使用p个处理器,长度为t的文本,长度为L的模式,以及使用的L个处理器的上限:

 for i=0 to t-l:
    for j=0 to p:
        processor j compares the text[i+j] to pattern[i+j]
            On false match:
                all processors terminate current comparison, i++
            On true match by all processors:
                Iterate p characters at a time until L characters have been compared
                If all L comparisons return true:
                    return i (position of pattern)
                Else:
                    i++

我刚开始玩任务并行库,遇到了有趣的问题; 我对将要发生的事情有一个大概的了解,但是希望听到比我更有能力的人的评论来帮助了解正在发生的事情.我为有点冗长的代码道歉.

我开始使用随机游走的非并行模拟:

 var random = new Random();
 Stopwatch stopwatch = new Stopwatch();

 stopwatch.Start();

 var simulations = new List<int>();
 for (var run = 0; run < 20; run++)
 {
    var position = 0;
    for (var step = 0; step < 10000000; step++)
    {
       if (random.Next(0, 2) == 0)
       {
          position--;
       }
       else
       {
          position++;
       }
    }

    Console.WriteLine(string.Format("Terminated run {0} at position {1}.", run, position));
    simulations.Add(position);
 }

 Console.WriteLine(string.Format("Average position: {0} .", simulations.Average()));
 stopwatch.Stop();

 Console.WriteLine(string.Format("Time elapsed: {0}", stopwatch.ElapsedMilliseconds));
 Console.ReadLine();

然后我在并行循环中写了我的第一次尝试:

 var localRandom …

我从haskell并行性开始,我已经成功地学会了如何使用一些策略:r0, rseq, rdeepseq, parList, parMap.现在我正在寻求更高的效率.所以这是我的问题:parList和之间有什么区别parBuffer？在哪些情况下,每个策略都有效？

我正在编写一个使用Socket的应用程序,它将非常密集,然后我真的需要使用我们在大服务器中的每个核心.我在stackoverflow中看到了问题(如何使用ThreadPool运行套接字线程？)这里只有一个答案指向此MSDN示例.

但我认为它只指向如何使它并发而不是并行,这里有人问如何cpu密集是打开一个套接字,它看起来非常密集,有人在这里说它不帮助TPL TaskFactory.FromAsync vs任务与阻塞方法和某人在这里教会如何使用TaskFactory.FromAsync(是否存在将现有的BeginXXX/EndXXX异步方法包装成异步任务的模式？).

如何保持套接字操作并行和高性能,如果处理插槽问题,如断开连接,半连接套接字和消息边界是正常异步方式的头疼.如果将TPL和Task放在一起,如何处理它.

我有一个很大的列表循环(1.500.000项),每个项目我都要做一个非常小的检查.完全在30秒内.

使用Sequential时的CPU利用率约为10%,因此没有使用大量资源.

第一个想法是使用Parallel,但由于每个项目的持续时间有限,Parallel比持续的Foreach持续时间更长,这是因为" 为什么并行版本比本例中的顺序版本慢？ ",这解释了每项任务的创建都会花费时间.

所以我有另一个想法,那就是将列表分成4个(或更多)相等的和平并创建一个线程来遍历项目以使其更快.

在创建自己的课程之前,这是一个好方法吗？或者关于如何加快速度的任何其他想法？或者你知道更好的处理方法吗？

码

我为另一个并行方法创建的代码:(在我自己的静态类中使用)

public static void ForEach<T>(IEnumerable<T> list, Action<T> body, int listDevide)
{
    // Number of items
    int items = list.Count();
    // Divided (in int, so floored)
    int listPart = items / listDevide;
    // Get numbers extra for last run
    int rest = items % listDevide;

    // List to save the actions
    var actions = new List<Action>();
    for(var x = 0; x < listDevide; x++)
    {
        // Create the actions
        actions.Add(delegate {
            foreach(var item …

最近,我已经创建了一个对象factor=1在我的工作区,不知道是有功能factor的base包.

我打算做的是factor在并行循环中使用变量,例如,

library(plyr)
library(foreach)
library(doParallel)

workers <- makeCluster(2)
registerDoParallel(workers,cores=2)

factor=1

llply(
  as.list(1:2),
  function(x) factor*x,
  .parallel = TRUE,
  .paropts=list(.export=c("factor"))
     )

然而,这会导致错误,让我有时间去理解.看起来,在environemt中plyr创建对象,但使用而不是用户提供的对象.请参阅以下示例factorexportEnvbase::factor

llply(
  as.list(1:2),
  function(x) {
    function_env=environment();
    global_env=parent.env(function_env);
    export_env=parent.env(global_env);
    list(
      function_env=function_env,
      global_env=global_env,
      export_env=export_env,
      objects_in_exportenv=unlist(ls(envir=export_env)),
      factor_found_in_envs=find("factor"),
      factor_in_exportenv=get("factor",envir=export_env)
      )
    },
  .parallel = TRUE,
  .paropts=list(.export=c("factor"))
  )

stopCluster(workers)

如果我们检查输出llply,我们看到该行factor_in_exportenv=get("factor",envir=export_env)不返回1(对应于用户提供的对象)而是函数定义base::factor.

问题1)我怎样才能理解这种行为？我原以为输出是1.

问题2)R如果我将一个新值分配给另一个包中已经定义的对象(例如我的情况下factor),是否有办法获得警告？

如何找到Python进程及其所有分叉子进程使用的驻留内存总量？

我知道我可以使用psutil,例如,查找当前进程使用的可用物理内存的百分比,如下所示:

import os
import psutil
current_process = psutil.Process(os.getpid())
mem = current_process.memory_percent()

但我正在寻找进程及其子进程使用的总内存,如果有的话.

我有一个csv文件("SomeSiteValidURLs.csv"),它列出了我需要抓取的所有链接.代码正在运行,将通过csv中的url,抓取信息并记录/保存在另一个csv文件("Output.csv")中.但是,由于我计划在网站的大部分区域(大于10,000,000页)进行此操作,因此速度非常重要.对于每个链接,爬行并将信息保存到csv大约需要1秒,这对于项目的大小来说太慢了.所以我已经整合了多线程模块,令我惊讶的是它根本没有加速,它仍然需要1个人链接.我做错什么了吗？还有其他方法可以加快处理速度吗？

没有多线程:

import urllib2
import csv
from bs4 import BeautifulSoup
import threading

def crawlToCSV(FileName):

    with open(FileName, "rb") as f:
        for URLrecords in f:

            OpenSomeSiteURL = urllib2.urlopen(URLrecords)
            Soup_SomeSite = BeautifulSoup(OpenSomeSiteURL, "lxml")
            OpenSomeSiteURL.close()

            tbodyTags = Soup_SomeSite.find("tbody")
            trTags = tbodyTags.find_all("tr", class_="result-item ")

            placeHolder = []

            for trTag in trTags:
                tdTags = trTag.find("td", class_="result-value")
                tdTags_string = tdTags.string
                placeHolder.append(tdTags_string)

            with open("Output.csv", "ab") as f:
                writeFile = csv.writer(f)
                writeFile.writerow(placeHolder)

crawltoCSV("SomeSiteValidURLs.csv")

使用多线程:

import urllib2
import csv
from bs4 import BeautifulSoup
import threading

def crawlToCSV(FileName):

    with open(FileName, "rb") …

我有一种算法，可以在给定段上同步计算某个积分。我想使用Control.Parallel库，或者par :: a -> b -> b将并行计算添加到此算法。我怎样才能做到这一点？

integrate :: (Double -> Double) -> Double -> Double -> Double
integrate f a b =
  let
    step     = (b - a) / 1000
    segments = [a + x * step | x <- [0..999]]
    area x   = step * (f x + f (x + step)) / 2
  in sum $ map area segments