我编程的代码存在很大问题.我不是专家,在来到这里之前我问了很多人.也纠正了很多事情.所以,我想我已准备好向您展示代码并向您提问我的问题.我会把整个代码放在这里,以便让你很好地理解我的问题.我想做的事情是,如果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() …假设我想在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() …我正在尝试制作自己的简单网络爬虫.我想从URL下载具有特定扩展名的文件.我写了以下代码:
private void button1_Click(object sender, RoutedEventArgs e)
{
if (bw.IsBusy) return;
bw.DoWork += new DoWorkEventHandler(bw_DoWork);
bw.RunWorkerAsync(new string[] { URL.Text, SavePath.Text, Filter.Text });
}
//--------------------------------------------------------------------------------------------
void bw_DoWork(object sender, DoWorkEventArgs e)
{
try
{
ThreadPool.SetMaxThreads(4, 4);
string[] strs = e.Argument as string[];
Regex reg = new Regex("<a(\\s*[^>]*?){0,1}\\s*href\\s*\\=\\s*\\\"([^>]*?)\\\"\\s*[^>]*>(.*?)</a>", RegexOptions.Compiled | RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);
int i = 0;
string domainS = strs[0];
string Extensions = strs[2];
string OutDir = strs[1];
var domain = new Uri(domainS);
string[] Filters = Extensions.Split(new char[] { ';', ',', ' …我有一个List<byte[]>,我喜欢将每个反序列byte[]化为Foo.列表是有序的,我喜欢写一个并行循环,其中结果List<Foo>包含所有Foo的顺序与原始顺序相同byte[].该列表非常大,可以使并行操作变得有价值.有没有内置的方法来实现这一目标？
如果没有,任何想法如何实现同步运行这一切的加速？
谢谢
如何将OpenCL内核编译成比特流,以后可以直接加载而无需重新编译？我的平台是带有APU和AMD独立GPU的AMD机器.该机器运行最新的支持OpenCL 1.2的AMD APP SDK.
我想在函数中使用多进程,我该如何实现它.
如您所知,MPI_Init需要两个参数:"int argc,char**argv".这是否意味着我必须在函数定义中添加这两个参数？
我的要求是我希望并行化一个功能步骤而不是主程序中的步骤.
例如,
func(mat &A, vec &x) {
some computation on A;
auto B = sub_mat(A, 0, 10);
B*x; // I want to parallelize this computation
}
main(){
mat A;
vec x;
func(A, x);
}
我只想在B*x中使用MPI,但我不知道如何初始化MPI？顺便说一下,如果我可以初始化MPI int func,那么此时每个进程中是否存在A？
帮帮我,谢谢!