// parallel processing
int processors = Runtime.getRuntime().availableProcessors();
ExecutorService executorService = Executors.newFixedThreadPool(threads);
final List<String> albumIds2 = new ArrayList<String>();
long start2 = System.nanoTime();
for (final HColumn<String, String> column : result.get().getColumns()) {
Runnable worker = new Runnable() {
@Override
public void run() {
albumIds2.add(column.getName());
}
};
executorService.execute(worker);
}
long timeTaken2 = System.nanoTime() - start2;
我有像上面的例子一样的代码,它创建了一个List<String>专辑ID.该列是来自cassandra数据库的切片.我记录要创建的整个专辑列表所用的时间.
我使用增强的for循环完成了同样的操作,如下所示.
QueryResult<ColumnSlice<String, String>> result = CassandraDAO.getRowColumns(AlbumIds_CF, customerId);
long start = System.nanoTime();
for (HColumn<String, String> column : result.get().getColumns()) {
albumIds.add(column.getName());
}
long timeTaken = System.nanoTime() - start; …我需要一些帮助来理解GPU上的内核与CPU中的内核的概念,以便进行并行计算.
说到CPU中的核心,看起来很简单.我有一个超级密集的"for"循环,迭代四次.我的Intel i5 2.26GHz CPU有四个内核.我给每个核心一个循环.四个循环中的每一个都独立于另一个.繁荣 - 我现在创建了四个线程和100%CPU使用率(而不是只有一个核心的25%CPU使用率).我的"for"循环现在运行速度比没有并行化时快四倍.顺便说一下,对于"for"循环,我使用了Microsoft Visual Studio 2012上提供的自动并行化,如在线示例所示:( http://msdn.microsoft.com/en-us/library/hh872235. aspx).
相比之下,我甚至不知道我可以用于并行计算的笔记本电脑的GPU(英特尔图形媒体加速器HD,或英特尔高清显卡,1696MB共享内存)中的内核数量.我甚至不知道将GPU与CPU进行比较的有效方法.当我在我的显卡描述旁边看到"12 @ 500MHz"时,我想知道这是否意味着显卡有12个并行核心,可以像CPU中的4个内核一样工作,除了GPU核心运行在500MHz [慢而不是2.26GHz [快]？GPU使用率是否与Windows任务管理器中的CPU使用率相当？我是一个试图在visual studio 2012中使用C++库的新手,如果这有任何区别的话.当我编写实际的GPU软件时,并行化代码如下所示:( http://msdn.microsoft.com/en-us/library/hh265137.aspx).
那么,请您填写我的知识中的一些空白或错误,或者帮助我比较两者？我不需要一个非常复杂的答案,就像"由于空白空白而无法将CPU核心与GPU核心进行比较"或"GPU核心不像CPU核心那样真正的核心"这样简单非常感谢.
parallel-processing performance multithreading multicore gpgpu
我正在尝试使用OpenMP在以下函数中并行化循环
void CEnergymulti::forcetwobody(vector<CMolecule*> m_mols,CPnt force0,CPnt torque0)
{
const int nmol=m_mols.size();
vector<CMolecule*> twomols(2);
CPnt forcetemp,torquetemp;
twomols.clear();
force0.zero();
torque0.zero();
forcetemp.zero();
torquetemp.zero();
#pragma omp parallel for reduction(+:force0,torque0) private(twomols)
for(int j=1;j<nmol;j++)
{ twomols.push_back(m_mols[0]);
twomols.push_back(m_mols[j]);
CMolecule::polarize_mutual(twomols,false, 1000);
twomols[0]->computeMol_Force_and_Torque(forcetemp,torquetemp);
force0+=forcetemp;
torque0+=torquetemp;
forcetemp.zero();
torquetemp.zero();
twomols.clear();
}
REAL converter=COUL_K*IKbT;
force0*=converter;
torque0*=converter;
return;
}
当我编译代码时,它给出以下消息:
EnergyD_multi.cpp: In static member function ‘static void
CEnergymulti::forcetwobody(std::vector<CMolecule*,
std::allocator<CMolecule*> >, CPnt, CPnt)’: EnergyD_multi.cpp:226:
error: ‘torque0’ has invalid type for ‘reduction’
EnergyD_multi.cpp:226: error: ‘force0’ has invalid type for
‘reduction’
我知道变量'force0'和'torque0'既不是双重或整数类型的数据,而是类型'CPnt',这是一个定义为表示空间中三维向量的类.对于类'CPnt',运算符'+'和' - '已经由运算符重载定义.所以我的问题是:OpenMP的减少是否真的无法处理这样的重载运算符？有没有其他方法可以将此循环与OpenMP并行化而不减少'force0'和'torque0'的每个组件？
非常感谢.
我正在学习并行化,在一个练习中,我给出了一些我应该提高性能的算法.其中一个是Fibonacci序列生成器:
array[0] = 0;
array[1] = 1;
for (q = 2; q < MAX; q++) {
array[q] = array[q?1] + array[q?2];
}
我怀疑这是不能优化的(通过并行化),因为每个数字都取决于前两个数字(因此间接地取决于所有前面的数字).怎么可以并行化呢？
介绍
我想就我将要自己开始的新编程项目请求很多建议.对于我想要完成的事情以及我的基本要求,我将非常精确.因此,这将是一个长期的问题.请多多包涵.
我将把问题分为五个部分:
1.现实世界的问题
摩天大楼和大型桥梁受到动态风荷载的影响.这意味着,如果设计不正确,它们会因风引起的振动而崩溃(这实际上发生在1940年:http://www.youtube.com/watch？v = 3mclp9QmCGs).为了正确设计这样的结构,需要有效的数字运算软件进行分析和模拟.
2.模拟问题
存在许多能够模拟流体流动或结构力学的软件.许多已经开发了30多年,并且是经过验证和成熟的技术.因此,编写一个能够同时模拟流体流动和结构力学的多物理程序是不明智的.首先,在成熟之前需要多年的开发才能进入一个依赖特定软件超过30年的世界.但更重要的是......为什么在重用时重新创建？我不喜欢采用单片方法,而是采用分区方法,可以重用现有的仿真软件.
在分区方法中,我将使用软件X来模拟流程,我将使用软件Y来模拟结构.然后我将编写自己的耦合算法,建立X和Y之间的通信,并使用它们来模拟多物理问题(例如摩天大楼或桥梁的风引起的振动).我使用X和Y而不是实际软件名称的原因是因为X和Y应该是黑盒子.我的耦合算法决不依赖于X和Y的实现.算法将仅依赖于X和Y的输出.这样最终用户可以选择哪个X或Y可用于哪个或哪个永远X或Y能够做到最终用户想要实现的目标.
因为我想使用黑盒分区方法,软件X不知道Y,反之亦然.但是,如何在不知道周围气流的情况下模拟桥梁的变形,以及如何知道周围气流在不知道任何变形的情况下被周围气流扰动的方式？答案很简单:从猜测开始,使用迭代方法收敛到正确的解决方案.然而,这种方法在计算上非常昂贵.为了降低计算成本,可以使用非常有效的技术以巧妙的方式编写耦合算法,这里不再讨论.我想说的是需要一些重线性代数数字运算.
3.要求和偏好
我需要做的是:
我想要的软件是什么:
我打算用什么:
4.补充资料
事实:
商业模式:
5.建议请求清单
我想通过编写许多单独执行一项微小任务的函数来完成C++中的所有数字运算.程序逻辑将包含在CPython包中,该包执行整个模拟,同时依靠C++函数执行数字运算.C++/CPython算法将使用CPython(使用NumPy,SciPy,SymPy和Matplotlib)编写的脚本进行扩展,以生成和可视化原始数值数据的结果.我希望能够进行并行计算,我需要与几个第三方开源和专有软件进行通信.
要完成所有这些我将需要一大堆现有的库/包/技术等.对于所有相关问题,我知道我可以使用什么,但是我不知道我应该使用什么.最好的解决方案是一如既往地尝试一切,看看最有效的方法.但是,如果任何有经验的用户可以淘汰一些更不可能的候选人,我很乐意收到他或她的建议,建议,赞成/列表:
注意:我总结了上面的一些选项,但这些只是示例性而非限制.只要它是用C,C++,Fortran或Python编写的,我对所有东西都是开放的.此外,我不希望在一个人的上述所有五个类别中得到答案.让社区的集体知识来处理这个问题.
我感谢所有的贡献者,并祝你在自己的努力中一切顺利.
c++ python parallel-processing user-interface linear-algebra
我正在尝试使用并行处理来加速几个嵌套循环,但我无法正确获得语法.我试图计算一个位图中有多少像素是红色,白色或黑色,我在其他地方枚举的值.
在串行处理中,我有以下代码,工作正常:
Bitmap image = new Bitmap(@"Input.png");
var colourCount = new int[3];
for (var x = 0; x < image.Width; x++)
{
for (var y = 0; y < image.Height; y++)
{
switch (image.GetPixel(x, y).ToArgb())
{
case (int)colours.red: colourCount[0]++; break;
case (int)colours.white: colourCount[1]++; break;
case (int)colours.black: colourCount[2]++; break;
default: throw new ArgumentOutOfRangeException(string.Format("Unexpected colour found: '{0}'", image.GetPixel(x, y).ToArgb()));
}
}
}
我已经看到Microsoft和来自Stackoverflow的并行for循环代码,它们更新了一个共享变量,如下所示:
Parallel.For<int>(0, result.Count, () => 0, (i, loop, subtotal) =>
{
subtotal += result[i];
return subtotal;
},
(x) => Interlocked.Add(ref …有没有一种简单的方法来使用scala并行集合而无需将完整集合加载到内存中？
例如,我有一个大型集合,我想在一个小块上并行执行特定操作(折叠),这个块适合内存,而不是另一个块等等,最后重新组合所有块的结果.
我知道,可以使用actor,但是使用par-collections会非常好.
我写了一个解决方案,但它并不好:
def split[A](list: Iterable[A], chunkSize: Int): Iterable[Iterable[A]] = {
new Iterator[Iterable[A]] {
var rest = list
def hasNext = !rest.isEmpty
def next = {
val chunk = rest.take(chunkSize)
rest = rest.drop(chunkSize)
chunk
}
}.toIterable
}
def foldPar[A](acc: A)(list: Iterable[A], chunkSize: Int, combine: ((A, A) => A)): A = {
val chunks: Iterable[Iterable[A]] = split(list, chunkSize)
def combineChunk: ((A,Iterable[A]) => A) = { case (res, entries) => entries.par.fold(res)(combine) }
chunks.foldLeft(acc)(combineChunk)
}
val chunkSize = 10000000
val x = …我是使用GPU进行并行编程的新手,所以如果问题广泛或模糊,我会道歉.我知道CULA库中有一些并行的SVD功能,但是如果我有大量相对较小的矩阵来分解,应该采取什么策略呢？例如,我有n尺寸矩阵d,n大而d小.如何并行化这个过程？谁能给我一个提示？
我正在尝试编写一个函数,它接受一组未分类的键/值对,例如
<7, 4>
<2, 8>
<3, 1>
<2, 2>
<1, 5>
<7, 1>
<3, 8>
<7, 2>
并按键对它们进行排序,同时使用相同的键减少对的值:
<1, 5>
<2, 10>
<3, 9>
<7, 7>
目前,我正在使用__device__类似下面的一个函数,它本质上是一个bitonic排序,它将组合相同键的值并将旧数据设置为一个无限大的值(仅99用于现在),以便后续的bitonic排序将筛选它们到底部并且数组被int *删除的值切割.
__device__ void interBitonicSortReduce(int2 *sdata, int tid, int recordNum, int *removed) {
int n = MIN(DEFAULT_DIMBLOCK, recordNum);
for (int k = 2; k <= n; k *= 2) {
for (int j = k / 2; j > 0; j /= 2) {
int ixj = tid …受到statar包中的实验fuzzy_join函数的启发,我自己编写了一个函数,它结合了精确和模糊(通过字符串距离)匹配.我必须做的合并工作非常大(导致多个字符串距离矩阵,小于10亿个单元格),我的印象是函数编写效率不高(关于内存使用情况)和并行化以奇怪的方式实现(字符串距离矩阵的计算,如果存在多个模糊变量,而不是字符串距离本身的计算并行化).至于功能,想法是在可能的情况下匹配精确变量(以保持矩阵更小),然后在这个精确匹配的组内进行模糊匹配.我实际上认为这个功能是不言自明的.我在这里发布它是因为我希望得到一些反馈来改进它,因为我想我并不是唯一一个尝试在R中做类似事情的人(虽然我承认Python,SQL和类似的东西可能在这种情况下要更有效率.但是必须坚持一个人感觉最舒服的事情,并且使用相同的语言进行数据清理和准备在再现性方面是很好的) fuzzy_joinfuzzy_join
merge.fuzzy = function(a,b,.exact,.fuzzy,.weights,.method,.ncores) {
require(stringdist)
require(matrixStats)
require(parallel)
if (length(.fuzzy)!=length(.weights)) {
stop(paste0("fuzzy and weigths must have the same length"))
}
if (!any(class(a)=="data.table")) {
stop(paste0("'a' must be of class data.table"))
}
if (!any(class(b)=="data.table")) {
stop(paste0("'b' must be of class data.table"))
}
#convert everything to lower
a[,c(.fuzzy):=lapply(.SD,tolower),.SDcols=.fuzzy]
b[,c(.fuzzy):=lapply(.SD,tolower),.SDcols=.fuzzy]
a[,c(.exact):=lapply(.SD,tolower),.SDcols=.exact]
b[,c(.exact):=lapply(.SD,tolower),.SDcols=.exact]
#create ids
a[,"id.a":=as.numeric(.I),by=c(.exact,.fuzzy)]
b[,"id.b":=as.numeric(.I),by=c(.exact,.fuzzy)]
c <- unique(rbind(a[,.exact,with=FALSE],b[,.exact,with=FALSE]))
c[,"exa.id":=.GRP,by=.exact]
a <- merge(a,c,by=.exact,all=FALSE)
b <- merge(b,c,by=.exact,all=FALSE)
##############
stringdi <- function(a,b,.weights,.by,.method,.ncores) {
sdm <- list()
if (is.null(.weights)) {.weights <- …parallel-processing r fuzzy-comparison data.table stringdist