- android - 多次调用 OnPrimaryClipChangedListener
- android - 无法更新 RecyclerView 中的 TextView 字段
- android.database.CursorIndexOutOfBoundsException : Index 0 requested, 光标大小为 0
- android - 使用 AppCompat 时,我们是否需要明确指定其 UI 组件(Spinner、EditText)颜色
我已经实现了一个简单的 n x n 矩阵乘法,以使用 OpenMp 在 c 中测试相同的性能调整。我的初始代码如下:
#pragma omp parallel for shared(a,b,c) private(h,i,j,k)
for( i = 0; i < n; i++ )
{
for( j = 0; j < n; j++)
{
for( k = 0; k < n; k++ )
{
a[i*n+j]+= b[i*n+k] * c[k*n+j];
编译器切换 j 和 k 循环,所以我得到了 ikj 算法。我想要实现的第一件事是填充以将每一行对齐到 64 字节以进行对齐的缓存访问。因此,我计算了每一行所需的额外大小。行长度为 5900,新尺寸为 5904(引用号为 ISBN-9780124104143)。我的新代码如下:
#pragma omp parallel for shared(a,b,c) private(h,i,j,k)
for( i = 0; i < n; i++ )
{
for( k = 0; k < n; k++ )
{
#pragma simd
#pragma unroll(4)
for( j = 0; j < n; j++)
{
a[i*pn+j]+= b[i*pn+k] * c[k*pn+j];
其中 pn 是新的填充行长度。我不得不手动置换我的循环,因为编译器拒绝这样做。在普通的 Xeon 处理器上运行这段代码,我得到的性能几乎与以前相同,也许更好一点。这就是我所期望的。但是当我在 Xeon Phi 上运行代码时,它大约是初始代码的 1/10。
经过进一步的编译器调查,我注意到,内部循环不再展开和向量化。所以我添加了以下#pragmas:
#pragma simd
#pragma unroll
矢量化工作正常,但余数循环没有展开。性能要好得多,但仍然只有普通版本的 1/2 左右。
这是正常代码的编译器 (-O3) 输出:
LOOP BEGIN at mm_par.c(75,3)
remark #25444: Loopnest Interchanged: ( 1 2 3 ) --> ( 1 3 2 )
LOOP BEGIN at mm_par.c(79,5)
remark #25460: No loop optimizations reported
LOOP BEGIN at mm_par.c(77,4)
remark #15301: PERMUTED LOOP WAS VECTORIZED
LOOP END
LOOP BEGIN at mm_par.c(77,4)
<Remainder>
remark #25436: completely unrolled by 4
LOOP END
LOOP END
LOOP END
这里是带有 simd 和展开编译指示的填充输出:
LOOP BEGIN at mm_ali.c(76,3)
remark #25460: No loop optimizations reported
LOOP BEGIN at mm_ali.c(78,4)
remark #25460: No loop optimizations reported
LOOP BEGIN at mm_ali.c(82,10)
remark #15301: SIMD LOOP WAS VECTORIZED
LOOP END
LOOP END
LOOP END
所以展开被忽略了。有没有办法强制它?我也质疑自己,如果那是表现不佳的唯一原因..
编辑:没有填充的快速矩阵乘法的汇编如下所示:
vmovapd c(%r15,%rbx,8), %zmm1 #81.28 c1
vprefetche1 2048+a(%r11,%rbx,8) #81.6 c5
vmovapd 64+c(%r15,%rbx,8), %zmm3 #81.28 c9
vprefetch0 768+a(%r11,%rbx,8) #81.6 c13
vmovapd 128+c(%r15,%rbx,8), %zmm4 #81.28 c17
vprefetch1 2048+c(%r15,%rbx,8) #81.28 c21
vmovapd 192+c(%r15,%rbx,8), %zmm5 #81.28 c25
vprefetch0 768+c(%r15,%rbx,8) #81.28 c29
vfmadd213pd a(%r11,%rbx,8), %zmm0, %zmm1 #81.6 c33
vprefetche1 2112+a(%r11,%rbx,8) #81.6 c37
vfmadd213pd 64+a(%r11,%rbx,8), %zmm0, %zmm3 #81.6 c41
vprefetch0 832+a(%r11,%rbx,8) #81.6 c45
vfmadd213pd 128+a(%r11,%rbx,8), %zmm0, %zmm4 #81.6 c49
vprefetch1 2112+c(%r15,%rbx,8) #81.28 c53
vfmadd213pd 192+a(%r11,%rbx,8), %zmm0, %zmm5 #81.6 c57
vprefetch0 832+c(%r15,%rbx,8) #81.28 c61
vmovaps %zmm1, a(%r11,%rbx,8) #81.6 c65
vprefetche1 2176+a(%r11,%rbx,8) #81.6 c69
vmovaps %zmm3, 64+a(%r11,%rbx,8) #81.6 c73
vprefetch0 896+a(%r11,%rbx,8) #81.6 c77
vmovaps %zmm4, 128+a(%r11,%rbx,8) #81.6 c81
vprefetch1 2176+c(%r15,%rbx,8) #81.28 c85
vmovaps %zmm5, 192+a(%r11,%rbx,8) #81.6 c89
vprefetch0 896+c(%r15,%rbx,8) #81.28 c93
vprefetche1 2240+a(%r11,%rbx,8) #81.6 c97
vprefetch0 960+a(%r11,%rbx,8) #81.6 c101
vprefetch1 2240+c(%r15,%rbx,8) #81.28 c105
vprefetch0 960+c(%r15,%rbx,8) #81.28 c109
addq $32, %rbx #77.4 c113
cmpq %rsi, %rbx #77.4 c117
jb ..B1.51 # Prob 99% #77.4 c117
带有填充的慢速乘法看起来像这样:
vloadunpackld (%rbx), %zmm0 #83.6 c1
addl $32, %r15d #81.10 c1
vprefetch1 2048+c(%rcx) #83.30 c5
vloadunpackhd 64(%rbx), %zmm0 #83.6 c9
addq $256, %rbx #81.10 c9
vprefetch0 512+c(%rcx) #83.30 c13
vbroadcastsd b(%r12,%r13,8), %zmm2 #83.18 c17
vprefetch1 2112+c(%rcx) #83.30 c21
vfmadd132pd c(%rcx), %zmm0, %zmm2 #83.6 c25
vprefetch0 576+c(%rcx) #83.30 c29
vpackstoreld %zmm2, (%rsi) #83.6 c33
vprefetch1 2176+c(%rcx) #83.30 c37
vpackstorehd %zmm2, 64(%rsi) #83.6 c41
addq $256, %rsi #81.10 c41
vprefetch0 640+c(%rcx) #83.30 c45
vloadunpackld (%rdi), %zmm3 #83.6 c49
vprefetch1 2240+c(%rcx) #83.30 c53
vloadunpackhd 64(%rdi), %zmm3 #83.6 c57
addq $256, %rdi #81.10 c57
vprefetch0 704+c(%rcx) #83.30 c61
vbroadcastsd b(%r12,%r13,8), %zmm4 #83.18 c65
vfmadd132pd 64+c(%rcx), %zmm3, %zmm4 #83.6 c69
nop #83.6 c73
vpackstoreld %zmm4, (%r8) #83.6 c77
vpackstorehd %zmm4, 64(%r8) #83.6 c81
addq $256, %r8 #81.10 c81
vloadunpackld (%r9), %zmm5 #83.6 c85
vloadunpackhd 64(%r9), %zmm5 #83.6 c89
addq $256, %r9 #81.10 c89
vbroadcastsd b(%r12,%r13,8), %zmm6 #83.18 c93
vfmadd132pd 128+c(%rcx), %zmm5, %zmm6 #83.6 c97
nop #83.6 c101
vpackstoreld %zmm6, (%r10) #83.6 c105
vpackstorehd %zmm6, 64(%r10) #83.6 c109
addq $256, %r10 #81.10 c109
vloadunpackld (%r11), %zmm7 #83.6 c113
vloadunpackhd 64(%r11), %zmm7 #83.6 c117
addq $256, %r11 #81.10 c117
vbroadcastsd b(%r12,%r13,8), %zmm8 #83.18 c121
vfmadd132pd 192+c(%rcx), %zmm7, %zmm8 #83.6 c125
addq $256, %rcx #81.10 c129
movb %al, %al #83.6 c129
vpackstoreld %zmm8, (%rdx) #83.6 c133
vpackstorehd %zmm8, 64(%rdx) #83.6 c137
addq $256, %rdx #81.10 c137
cmpl $5888, %r15d #81.10 c141
jb ..B1.42 # Prob 99% #81.10 c141
这是我的解决方案的完整代码。同样,如果我将 np 与 n 交换,性能会快两倍以上。
#include <sys/time.h>
#include <omp.h>
#ifndef max
#define max(a,b) (((a) (b)) ? (a) : (b))
#define min(a,b) (((a) < (b)) ? (a) : (b))
#endif
#define n 5900
#define pn ((((n*sizeof(double))+63)/64)*(64/sizeof(double))) //padding
#define threadNum 144
#define loops 1
double dtime()
{
double tseconds = 0.0;
struct timeval mytime;
gettimeofday(&mytime, (struct timezone*)0);
tseconds = (double)(mytime.tv_sec + mytime.tv_usec*1.0e-6);
return tseconds;
}
double a[n*pn] __attribute__((aligned(64)));
double b[n*pn] __attribute__((aligned(64)));
double c[n*pn] __attribute__((aligned(64)));
main(int argc, char **argv){
int threadNumber, loopNumber;
if(argc == 3)
{
threadNumber = atoi(argv[1]);
loopNumber = atoi(argv[2]);
} else
{
threadNumber = threadNum;
loopNumber = loops;
}
double tstart, tstop, ttime;
int i,j,k,h;
// initialize matrices
#pragma omp parallel for
for(i = 0; i < pn*n; i++)
{
a[i]=0.0;
b[i]=2.0;
c[i]=2.0;
}
omp_set_num_threads(threadNumber);
tstart = dtime();
//parallelize via OpenMP on MIC
for(h = 0; h < loopNumber; h++){
#pragma omp parallel for shared(a,b,c) private(h,i,j,k)
for( i = 0; i < n; i++ )
{
for( k = 0; k < n; k++ )
{
#pragma omp simd aligned( a, b, c: 64 )
for( j = 0; j < n; j++)
{
a[i*pn+j]+= b[i*pn+k] * c[k*pn +j];
}
}
}
}
tstop = dtime();
double elapsed = tstop - tstart;
double mFlops = ((double)n)*n*n*2.0*loopNumber/elapsed*1.0e-06;
#pragma omp parallel
#pragma omp master
printf("%d %.3f\n", omp_get_num_threads(), mFlops);
}
最佳答案
您提供的代码片段太小,无法进行适当的测试我可以在不进行适当测试的情况下提出解决方案,因此它可能会惨败。无论如何,这里什么都没有。
您说您确实填充了数据以对齐行,但是,AFAICS,此信息永远不会传输到编译器,因此无法利用它。为此,您有多种解决方案,但由于您已经拥有用于并行化的 OpenMP 指令,因此使用更多指令进行矢量化似乎是显而易见的选择。
所以这会给你这样的东西:
#pragma omp parallel for private( i, j, k )
for( i = 0; i < n; i++ ) {
double *aa = &a[i * pn];
double *bb = &b[i * pn];
for( k = 0; k < n; k++ ) {
double *cc = &c[k * pn];
#pragma omp simd aligned( aa, bb, cc: 64 )
for( j = 0; j < n; j++) {
aa[j] += bb[k] * cc[j];
}
}
}
这里我假设你的数组是 double
所以你可能需要改变它们不是。除此之外,我认为这个想法是存在的。我不知道它是否适合您,但这绝对值得一试。
关于c - 至强融核 : slower performance with padding,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/37663541/
我对 iPhone/iPad 编程还很陌生。我对 for 循环有疑问,就像我在本例中使用的那样。该程序可以正常工作。只是,在每次调用该函数(在本例中为 (void) writeLabels)之后,它变
背景资料 目前我正在为每个 UITableViewCell 设置文本在我的UITableView使用以下代码: 情景一:cell.textLabel.attributedText = [news fo
我在我的应用程序中使用 UIPinchGestureRecognizer 来放大 View (是的,我不使用 UIScrollView 是有原因的)。当我用手指向外捏合时, View 会按预期放大,如
我编写了一个示例程序来模仿我正在处理的数据结构类型。也就是说,我有 n 对象,我需要在每个可能的对之间迭代一次并执行(对称)计算。此操作涉及将数据写入两对。在串行中,这将采用这样的循环形式 for(i
我正在用 java 制作游戏,并使用 BufferedImages 将内容呈现到屏幕上。我在应该运行游戏的低端机器上遇到了性能问题,所以我切换到通常更快的 VolatileImage。除了它们实际上减
我目前正在研究图像编辑器,偶然发现了 V8 中有关像素操作和/或函数调用的奇怪行为。 http://jsperf.com/canvas-pixelwise-manipulation-performan
我在 Apache Spark 2.x 中有两个表。每个表都有一个公共(public)行“IDNUM”。称它们为表 A 和表 B。 这在 Apache SparkSQL 中很快: SELECT COU
我正在使用基于 ubuntu 构建的 Docker 镜像,其中包含我在 future 几个月的工作中将需要的标准软件。 假设我有一个耗时的程序来对用 C++ 编写的十亿个数字进行排序。假设我想比较笔记
This site给出了具有类间方差的方法的实现。但是,我想用类内方差来实现该方法(不幸的是,我无法发布公式,但您可以请在网站上查看),这被认为速度较慢。这是我的方法: double varb,var
我有这个方法: @DebugLog private synchronized int insertInOrderedFromBottom(ItemWithTime itemWithTime, Arra
我正在使用带有以下代码的 jQuery 热键插件: $(document).bind('keydown', 'right', function(){ console.log('fire
考虑 events 这里有大约 48,000 个字典对象: keyed_events = { gid: [ r for r in events if r['gid'] == gid ] for gid
我已经实现了一个简单的 n x n 矩阵乘法,以使用 OpenMp 在 c 中测试相同的性能调整。我的初始代码如下: #pragma omp parallel for shared(a,b,c) pr
我已经实现了两种不同的算法,它们的作用基本相同,检查节点树中一个节点到另一个节点的可见性,规则很简单——一个节点只有在另一个节点之前才对它可见同一个分支。 第一种方法沿着树从子节点到父节点,跳过父节点
我刚刚测试了一些东西。我一直认为在 OR 条件下,一旦计算机/浏览器发现某些东西是真的,它就会返回它并且不会测试其他条件。我围绕这个假设构建了我的代码。 但是,我对它进行了计时,看起来长测试花费了 x
这是一个带有普通增量运算符“i++”的普通空循环 import Foundation let start = CFAbsoluteTimeGetCurrent() for var i = 0; i <
我一直在使用 Python 的多处理模块分析一些代码('job' 函数只是数字的平方)。 data = range(100000000) n=4 time1 = time.time() process
所以最近几天我一直在摆弄 python 的多处理库,我真的很喜欢处理池。它很容易实现,我可以想象出很多用途。我已经完成了几个我以前听说过的项目来熟悉它,最近完成了一个暴力破解刽子手游戏的程序。 任何人
我正在使用 scipy-0.17 进行简单的稀疏矩阵求幂 a**16。 (注意,不是元素乘法)。但是,在我的机器上(运行 Debian 稳定版和 Ubuntu LTS),这比使用 for 循环或做一些
我最近购买了一台双启动计算机,可以用 C++ 编写代码。在 Windows 上,我在 linux 上使用英特尔 C++ 编译器和 g++。 我的程序主要由计算组成(具有数值积分的定点迭代算法等)。 我
我是一名优秀的程序员,十分优秀!