我正在寻找一种优雅的方式来实现GNU make中的作业并行化.这是我到目前为止所做的一个例子.以串行方式处理目录dir-1,dir-2和dir-3,这是合乎逻辑的,但不是我的意图:
SUBDIRS=dir-1 dir-2 dir-3
default: all
all:
@for dir in $(SUBDIRS); do (cd $$dir; $(MAKE)); done
.PHONY: clean
clean:
@for dir in $(SUBDIRS); do (cd $$dir; $(MAKE) clean); done
有没有办法支持使用"-j"选项并行处理这些目录而不为每个目录指定特定目标？
请考虑以下代码段:
public static Task<string> FetchAsync()
{
string url = "http://www.example.com", message = "Hello World!";
var request = (HttpWebRequest)WebRequest.Create(url);
request.Method = WebRequestMethods.Http.Post;
return Task.Factory.FromAsync<Stream>(request.BeginGetRequestStream, request.EndGetRequestStream, null)
.ContinueWith(t =>
{
var stream = t.Result;
var data = Encoding.ASCII.GetBytes(message);
Task.Factory.FromAsync(stream.BeginWrite, stream.EndWrite, data, 0, data.Length, null, TaskCreationOptions.AttachedToParent)
.ContinueWith(t2 => { stream.Close(); });
})
.ContinueWith<string>(t =>
{
var t1 =
Task.Factory.FromAsync<WebResponse>(request.BeginGetResponse, request.EndGetResponse, null)
.ContinueWith<string>(t2 =>
{
var response = (HttpWebResponse)t2.Result;
var stream = response.GetResponseStream();
var buffer = new byte[response.ContentLength > 0 ? response.ContentLength : 0x100000]; …我已经读过R只使用一个CPU.如何让R使用所有可用的内核来运行统计算法？
可能重复:
如何并行化一个简单的python循环？
我是Python的新手(使用Python 3.2),我有一个关于并行化的问题.我有一个for循环,我希望在Python 3.2中使用"多处理"并行执行:
def computation:
global output
for x in range(i,j):
localResult = ... #perform some computation as a function of i and j
output.append(localResult)
总的来说,我想在i = 0到j = 100的范围内执行此计算.因此,我想创建一些进程,每个进程使用总范围的子域调用函数"calculate".有关于如何做到这一点的任何想法？有没有比使用多处理更好的方法？
更具体地说,我想执行域分解,我有以下代码:
from multiprocessing import Pool
class testModule:
def __init__(self):
self
def computation(self, args):
start, end = args
print('start: ', start, ' end: ', end)
testMod = testModule()
length = 100
np=4
p = Pool(processes=np)
p.map(yes tMod.computation, [(length, startPosition, length//np) for startPosition in range(0, length, length//np)])
我收到一条提到PicklingError的错误消息.任何想法可能是这里的问题？
python parallel-processing pickle multiprocessing python-3.x
当我使用"#pragma omp parallel num_threads(4)"时,为什么我没有获得不同的线程ID.在这种情况下,所有线程ID都为0.但是当我评论该行并使用默认的线程数时,我得到了不同的线程ID.注意: - 变量我使用变量tid来获取线程ID.
#include <omp.h>
#include <stdio.h>
#include <stdlib.h>
int main (int argc, char *argv[])
{
int nthreads, tid;
int x = 0;
#pragma omp parallel num_threads(4)
#pragma omp parallel private(nthreads, tid)
{
/* Obtain thread number */
tid = omp_get_thread_num();
printf("Hello World from thread = %d\n", tid);
// /* Only master thread does this */
if (tid == 0)
{
nthreads = omp_get_num_threads();
printf("Number of threads = %d\n", nthreads);
}
}
}
上述代码的输出: -
Hello World …这基本上是对这个更专业化问题的跟进.在进行并行计算时,有一些关于创建僵尸进程的帖子R:
有几种方法可以进行并行计算,我将重点介绍目前在本地计算机上使用的三种方法.我在带有内核的本地计算机上使用doMC和doParallel使用foreach包4:
(a)注册一个fork集群:
library(doParallel)
cl <- makeForkCluster(4)
# equivalently here: cl <- makeForkCluster(nnodes=getOption("mc.cores", 4L))
registerDoParallel(cl)
out <- foreach(i=1:1000, .combine = "c") %dopar% {
print(i)
}
stopCluster(cl)
(b)注册PSOCK集群:
library(doParallel)
cl <- makePSOCKcluster(4)
registerDoParallel(cl)
out <- foreach(i=1:1000, .combine = "c") %dopar% {
print(i)
}
stopCluster(cl)
(c)使用 doMC
library(doMC)
library(doParallel)
registerDoMC(4)
out <- foreach(i=1:1000, .combine = "c") %dopar% {
print(i)
}
有几个用户观察到在使用该doMC方法时 - 这只是mclapply函数的包装器,所以它不是 …
我有兴趣了解C#.NET中的并行编程(不是所有要知道的东西,而是基础知识,也许还有一些好的实践),因此我决定重新编程我的一个名为ImageSyncer的旧程序.ImageSyncer是一个非常简单的程序,它所做的只是扫描一个文件夹,找到以.jpg结尾的所有文件,然后根据它们的拍摄日期计算文件的新位置(解析xif数据,或者其他它被称为).在生成位置之后,程序检查该位置的任何现有文件,如果存在,则查看要复制的文件的最后写入时间和文件"以其方式".如果它们相等,则跳过该文件.如果不是,则创建并匹配两个文件的md5校验和.如果没有匹配要复制的是被复制到一个新位置的文件(例如,如果它是被复制到"C:\ test.jpg放在"它复制到"C:\测试(1). jpg"而不是".此操作的结果将填充到包含两个字符串的struct-type队列中,即原始文件和要将其复制到的位置.然后迭代该队列,直到它为空并且复制文件.
换句话说,有4个操作:
1. Scan directory for jpegs
2. Parse files for xif and generate copy-location
3. Check for file existence and if needed generate new path
4. Copy files
因此,我想重写这个程序,使其成为并列,并能够同时执行多个操作,我想知道实现这一目标的最佳方法是什么.我想出了两个我能想到的不同模型,但它们中的任何一个都没有任何好处.第一个是并行化旧程序的4个步骤,以便当要执行第一步时,它在几个线程上完成,并且当完成整个步骤1时,开始步骤2.另外一个(我觉得更有趣,因为我不知道该怎样做到这一点的想法)是创建一种工人和消费者的模式,因此,当一个线程与步骤1中完成了一个又一个接管,并在执行第2步对象(或类似的东西).但正如所说,我不知道这些是否有任何好的解决方案.另外,我对并行编程知之甚少.我知道如何创建一个线程,以及如何让它执行一个以对象作为唯一参数的函数,我也曾经使用过BackgroundWorker类,但我对它们中的任何一个都不熟悉.
任何输入将不胜感激.
Java Hotspot可以很好地优化顺序代码.但我猜测随着多核计算机的出现,运行时的信息可以用于检测在运行时并行化代码的机会,例如检测软件流水线是否可能在循环和类似的事情中.
关于这个话题有没有做过任何有趣的工作？或者是研究失败还是一些很难解决的停顿问题？
我的工作mclapply从multicore包(在Ubuntu),我正在写需要的是结果的函数mclapply(x, f),以便返回(也就是f(x[1]), f(x[2]), ...., f(x[n])).
# multicore doesn't work on Windows
require(multicore)
unlist(mclapply(
1:10,
function(x){
Sys.sleep(sample(1:5, size = 1))
identity(x)}, mc.cores = 2))
[1] 1 2 3 4 5 6 7 8 9 10
上面的代码似乎暗示mclapply返回的结果顺序与lapply.
但是,如果这个假设是错误的,我将不得不花费很长时间来重构我的代码,所以我希望得到更熟悉这个包/并行计算的人的保证,这个假设是正确的.
是否可以安全地假设mclapply始终按顺序返回结果,而不管它是否给出了可选参数？