Wolfram网站指出,其并行功能通常只使用4个核心.如果您想要超过4个,您需要联系他们并付款.
我有一台配有2个四核超线程处理器的机器.当我运行并行命令时,它启动16个内核2 x 4 x 2(HT的因子为2,我猜).所以它看起来像使用16个内核而不是4.正确吗？可能是我的大学许可证允许> 4核心.我只是想检查一下我是否真的使用了所有可用的内核.
谢谢.
我希望使用多处理模块来加快某些传输规划模型的运行时间.我通过"正常"方法尽可能地优化,但其核心是一个荒谬的并行问题.例如,执行相同的矩阵运算集,4个不同的输入集,所有独立的信息.
伪代码:
for mat1,mat2,mat3,mat4 in zip([a1,a2,a3,a4],[b1,b2,b3,b4],[c1,c2,c3,c4],[d1,d2,d3,d4]):
result1 = mat1*mat2^mat3
result2 = mat1/mat4
result3 = mat3.T*mat2.T+mat4
所以我真正想做的就是在四核计算机上并行处理这个循环的迭代.我已经在这里以及多处理模块上的其他地方阅读了它,除了要求之外它似乎完全符合要求:
if __name__ == '__main__'
根据我的理解,这意味着您只能从脚本运行多处理代码？即如果我做了类似的事情:
import multiprocessing
from numpy.random import randn
a = randn(100,100)
b = randn(100,100)
c = randn(100,100)
d = randn(100,100)
def process_matrix(mat):
return mat^2
if __name__=='__main__':
print "Multiprocessing"
jobs=[]
for input_matrix in [a,b,c,d]:
p = multiprocessing.Process(target=process_matrix,args=(input_matrix,))
jobs.append(p)
p.start()
它运行正常,但假设我将上面保存为'matrix_multiproc.py',并定义了一个新文件'imported_test.py',它只是声明:
import matrix_multiproc
多处理不会发生,因为名称现在是'matrix_multiproc'而不是' main '
这是否意味着我永远不能在导入的模块上使用并行处理？我所要做的就是将我的模型运行为:
def Model_Run():
import Part1, Part2, Part3, matrix_multiproc, Part4
Part1.Run()
Part2.Run()
Part3.Run()
matrix_multiproc.Run()
Part4.Run()
很抱歉,这可能只是一个简单的答案,非常长的问题,谢谢!
我编程的代码存在很大问题.我不是专家,在来到这里之前我问了很多人.也纠正了很多事情.所以,我想我已准备好向您展示代码并向您提问我的问题.我会把整个代码放在这里,以便让你很好地理解我的问题.我想做的事情是,如果ARRAY_SIZETHREAD_SIZE太大了,那么我将大数组的数据放入一个较小的数组中,特别是用大小创建的THREAD_SIZE.然后,我将它发送到内核并做我必须做的任何事情.但是我有问题
isub_matrix[x*THREAD_SIZE+y]=big_matrix[x*ARRAY_SIZE+y];
由于堆栈溢出,代码停止的地方.首先,我制作了big_matrix的双指针.但freenode irc网络#cuda频道的人告诉我,CPU内存太大而无法处理它,我应该创建一个线性指针.我做到了,但我仍然有同样的堆栈溢出问题.所以,在这里它......经过一些更改后更新,但还没有工作(堆栈溢出停止,但是链接和清单更新失败)
#define ARRAY_SIZE 2048
#define THREAD_SIZE 32
#define PI 3.14
int main(int argc, char** argv)
{
int array_plus=0,x,y;
float time;
//unsigned int memsize=sizeof(float)*THREAD_SIZE*THREAD_SIZE;
//bool array_rest;
cudaEvent_t start,stop;
float *d_isub_matrix;
float *big_matrix = new float[ARRAY_SIZE*ARRAY_SIZE];
float *big_matrix2 = new float[ARRAY_SIZE*ARRAY_SIZE];
float *isub_matrix = new float[THREAD_SIZE*THREAD_SIZE];
float *osub_matrix = new float[THREAD_SIZE*THREAD_SIZE];
//if the array's size is not compatible with the thread's size, it won't work.
//array_rest=(ARRAY_SIZE*ARRAY_SIZE)/(THREAD_SIZE*THREAD_SIZE);
//isub_matrix=(float*) malloc(memsize);
//osub_matrix=(float*) malloc(memsize);
if(((ARRAY_SIZE*ARRAY_SIZE)%(THREAD_SIZE*THREAD_SIZE)==0))
{
//allocating space in …我致力于转换现有程序以利用STL的一些并行功能.
具体来说,我重新编写了一个大循环来处理std :: accumulate.它很好地运行.
现在,我希望并行运行累积操作.
我在GCC上看到的文档概述了两个具体步骤.
-D_GLIBCXX_PARALLEL<parallel/algorithm>添加编译器标志似乎没有任何改变.执行时间是相同的,在监视系统时,我没有看到任何多个核心使用的迹象.
添加并行/算法标头时出错.我认为它将包含在最新版本的gcc(4.7)中.
那么,有几个问题:
欢迎任何和所有建议.
谢谢!
根据NVIDIA,这是最快的减少内核:
template <unsigned int blockSize>
__device__ void warpReduce(volatile int *sdata, unsigned int tid) {
if (blockSize >= 64) sdata[tid] += sdata[tid + 32];
if (blockSize >= 32) sdata[tid] += sdata[tid + 16];
if (blockSize >= 16) sdata[tid] += sdata[tid + 8];
if (blockSize >= 8) sdata[tid] += sdata[tid + 4];
if (blockSize >= 4) sdata[tid] += sdata[tid + 2];
if (blockSize >= 2) sdata[tid] += sdata[tid + 1];
}
template <unsigned int blockSize>
__global__ void reduce6(int *g_idata, int …我试图在Erlang中实现一个修改后的并行深度优先搜索算法(我们称之为*dfs_mod*).
我想要得到的只是所有'死胡同路径',这些路径基本上是当*dfs_mod*访问没有邻居的顶点或带有邻居的顶点时返回的路径.我保存每个路径ets_table1,如果我的自定义函数fun1(Path)返回true以及ets_table2如果fun1(Path)回报false(我需要一些客户过滤器来过滤所产生的"死胡同"路径).
我已经实现了这个算法的顺序版本,并且由于一些奇怪的原因,它比并行版本表现更好.
并行实现背后的想法很简单:
Vertex从[Vertex|Other_vertices] = Unvisited_neighbours,Vertex到当前路径;{self(), wait}到'收集'流程;Unvisited_neighbours当前的Vertex一个新的进程 ;Other_vertices);{self(), done}到收集器进程并终止;所以,基本上每当我访问一个带有未访问邻居的顶点时,我会产生一个新的深度优先搜索过程,然后继续其他顶点.
在产生第一个*dfs_mod*进程后,我开始收集所有{Pid, wait}和{Pid, done}消息(wait消息是让收集器等待所有done消息).在等待收集器函数返回后的N毫秒内ok.
出于某种原因,这个并行实现的运行时间为8到160秒,而顺序版本仅运行4秒(测试是在具有Intel i5处理器的机器上具有5个顶点的完全连接的有向图上完成的).
以下是我对这种糟糕表现的看法:
Graph给每个运行*dfs_mod*的新进程.也许digraph:out_neighbours(Graph)从多个进程中反对一个有向图会导致这种缓慢？([bag, public,{write_concurrency, true}),但也许我做错了什么？fun1()(它基本上检查路径是否在带有"m"的顶点之前出现标有字母"n"的顶点,并true/false根据结果返回).也许这fun1() …我目前正在研究一些图形理论问题的MPI代码,其中许多节点都可以包含答案和答案的长度.为了让所有东西都回到主节点,我正在做一个MPI_Gather来获得答案,并且我正在尝试使用MPI_MINLOC操作来确定谁拥有最短的解决方案.现在我存储长度和节点ID的数据类型定义为(按照http://www.open-mpi.org/doc/v1.4/man3/MPI_Reduce.3.php等众多网站上显示的示例):
struct minType
{
float len;
int index;
};
在每个节点上,我正在以下列方式初始化此结构的本地副本:
int commRank;
MPI_Comm_rank (MPI_COMM_WORLD, &commRank);
minType solutionLen;
solutionLen.len = 1e37;
solutionLen.index = commRank;
在执行结束时,我有一个MPI_Gather调用,成功地将所有解决方案(我从内存中打印出来以验证它们)以及调用:
MPI_Reduce (&solutionLen, &solutionLen, 1, MPI_FLOAT_INT, MPI_MINLOC, 0, MPI_COMM_WORLD);
我的理解是这些论点应该是:
当我的代码进入reduce操作时,我收到此错误:
[compute-2-19.local:9754] *** An error occurred in MPI_Reduce
[compute-2-19.local:9754] *** on communicator MPI_COMM_WORLD
[compute-2-19.local:9754] *** MPI_ERR_ARG: invalid argument of some other kind
[compute-2-19.local:9754] *** MPI_ERRORS_ARE_FATAL (your MPI job will now abort)
--------------------------------------------------------------------------
mpirun has exited due to process …假设我想在R中做一些通常(在一个进程/线程中)看起来像这样的东西:
for(i in 1:2) {
for(j in 1:2) {
#Do some stuff here
}
}
在四核机器上使用R的新包并行,我可以执行以下操作吗？
cluster<-makeCluster(4)
innerLoop<-function() {
#Do some stuff here
}
outerLoop<-function() {
result<-do.call(, parLapply(cluster, c(1:2), innerLoop))
}
final.result<-do.call(, parLapply(cluster, c(1:2), outerLoop))
这是否可以使用R-2.14.0附带的并行包？
以下nunit测试比较了运行单个线程与在双核机器上运行2个线程之间的性能.具体来说,这是一台运行在四核Linux SLED主机上的VMWare双核虚拟Windows 7计算机,戴尔Inspiron 503.
每个线程简单地循环并递增2个计数器,addCounter和readCounter.此测试是对Queue实施的原始测试,该实施被发现在多核机器上表现更差.因此,在将问题缩小到可重复性较小的代码时,你在这里没有只增加变量的队列,而且令人震惊和沮丧,它只有2个线程然后一个慢得多.
运行第一个测试时,任务管理器显示1个核心100%忙于另一个核心几乎空闲.这是单线程测试的测试输出:
readCounter 360687000
readCounter2 0
total readCounter 360687000
addCounter 360687000
addCounter2 0
你会看到超过3.6亿的增量!
接下来,双线程测试显示在整个5秒的测试持续时间内两个内核100%忙碌.但是它的输出只显示:
readCounter 88687000
readCounter2 134606500
totoal readCounter 223293500
addCounter 88687000
addCounter2 67303250
addFailure0
这只是2.23亿读取增量.什么是上帝的创造是那些2 CPU在5秒钟内完成的工作少了？
任何可能的线索？你可以在你的机器上运行测试,看看你是否得到不同的结果？一个想法是,VMWare双核性能可能不是您所希望的.
using System;
using System.Threading;
using NUnit.Framework;
namespace TickZoom.Utilities.TickZoom.Utilities
{
[TestFixture]
public class ActiveMultiQueueTest
{
private volatile bool stopThread = false;
private Exception threadException;
private long addCounter;
private long readCounter;
private long addCounter2;
private long readCounter2;
private long addFailureCounter;
[SetUp]
public void Setup() …所以我最近开始学习Scala并且一直在使用图形作为我的项目 - 改进我的Scala,并且它进展顺利 - 我已经设法轻松地并行化一些图形算法(从数据并行化中受益)由Scala 2.9提供并行收藏的惊人支持.
但是,我想更进一步,让它不仅在一台机器上而且在几台机器上并行化.Scala是否提供任何干净的方式来执行此操作,就像它对并行集合一样,或者我是否必须等到我的Actors中的章节/了解有关Akka的更多信息？
谢谢!-kstruct
parallel-processing distributed scala graph scala-collections