C++性能优化系列——矩阵转置(七)Intrinsic 内存预取与OpenMP多线程并行化

最新推荐文章于 2022-05-21 22:20:53 发布
最新推荐文章于 2022-05-21 22:20:53 发布
阅读量1.1k 收藏 3
点赞数
分类专栏： Intrinsic # C++性能调优 Cache 文章标签： 多线程 performance hpc openmp 并行计算
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yan31415/article/details/108080285
版权
C++性能调优 同时被 3 个专栏收录
20 篇文章 19 订阅
订阅专栏
Cache
6 篇文章 4 订阅
订阅专栏
Intrinsic
4 篇文章 1 订阅
订阅专栏

上一篇C++性能优化系列——矩阵转置(六)Intrinsic转置实现与Core Bound优化中通过Intrinsic 实现了矩阵转置功能，同时针对寄存器使用导致的spilling问题，对每次处理的数据块尺寸进行调整。本篇将基于之前的优化版本，在内存访问方面与多线程并行化方面做进一步优化。

内存访问优化

上一篇中主要针对寄存器使用问题优化代码，未针对内存访问问题 L3 Latency做处理。考虑Advance2版本中对内存访问的模式，写内存操作是连续执行的，读内存操作是交叉执行的。因此加载内存方式导致该问题的可能性最大。同时转置功能逻辑导致加载内存必须要交叉执行，因此要从别的方面考虑优化这个问题。
SSE指令集中提供内存预取指令。考虑每次循环中加载下一次要用到的数据。
代码实现：

void SimdTransposeBlock8RowPadPrefetch(unsigned char* pSource, unsigned char* pTarget)
	{
		clock_t begin = clock();
		int iblock = 128;
		int iwsize = NCOL / iblock;
		int ihsize = NROW / iblock;
		for (int i = 0; i < REPEAT; ++i)
		{
			for (int ibcol = 0; ibcol < iwsize; ++ibcol)
			{
				for (int ibrow = 0; ibrow < ihsize; ++ibrow)
				{
					for (int icol = 0; icol < iblock; icol += 8)
					{
						for (int irow = 0; irow < iblock; irow += 16)
						{
							__m128i A0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 0) * NREALCOL + ibcol * iblock + icol));
							__m128i B0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 1) * NREALCOL + ibcol * iblock + icol));
							__m128i C0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 2) * NREALCOL + ibcol * iblock + icol));
							__m128i D0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 3) * NREALCOL + ibcol * iblock + icol));
							__m128i E0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 4) * NREALCOL + ibcol * iblock + icol));
							__m128i F0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 5) * NREALCOL + ibcol * iblock + icol));
							__m128i G0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 6) * NREALCOL + ibcol * iblock + icol));
							__m128i H0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 7) * NREALCOL + ibcol * iblock + icol));
							__m128i I0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 8) * NREALCOL + ibcol * iblock + icol));
							__m128i J0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 9) * NREALCOL + ibcol * iblock + icol));
							__m128i K0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 10) * NREALCOL + ibcol * iblock + icol));
							__m128i L0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 11) * NREALCOL + ibcol * iblock + icol));
							__m128i M0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 12) * NREALCOL + ibcol * iblock + icol));
							__m128i N0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 13) * NREALCOL + ibcol * iblock + icol));
							__m128i O0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 14) * NREALCOL + ibcol * iblock + icol));
							__m128i P0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 15) * NREALCOL + ibcol * iblock + icol));


							//unpack2
							__m128i AB0_7 = _mm_unpacklo_epi8(A0_7, B0_7);
							__m128i CD0_7 = _mm_unpacklo_epi8(C0_7, D0_7);
							__m128i EF0_7 = _mm_unpacklo_epi8(E0_7, F0_7);
							__m128i GH0_7 = _mm_unpacklo_epi8(G0_7, H0_7);
							__m128i IJ0_7 = _mm_unpacklo_epi8(I0_7, J0_7);
							__m128i KL0_7 = _mm_unpacklo_epi8(K0_7, L0_7);
							__m128i MN0_7 = _mm_unpacklo_epi8(M0_7, N0_7);
							__m128i OP0_7 = _mm_unpacklo_epi8(O0_7, P0_7);


							//unpack4
							__m128i ABCD0_3 = _mm_unpacklo_epi16(AB0_7, CD0_7);
							__m128i EFGH0_3 = _mm_unpacklo_epi16(EF0_7, GH0_7);
							__m128i IJKL0_3 = _mm_unpacklo_epi16(IJ0_7, KL0_7);
							__m128i MNOP0_3 = _mm_unpacklo_epi16(MN0_7, OP0_7);
							__m128i ABCD4_7 = _mm_unpackhi_epi16(AB0_7, CD0_7);
							__m128i EFGH4_7 = _mm_unpackhi_epi16(EF0_7, GH0_7);
							__m128i IJKL4_7 = _mm_unpackhi_epi16(IJ0_7, KL0_7);
							__m128i MNOP4_7 = _mm_unpackhi_epi16(MN0_7, OP0_7);

							//unpack8
							__m128i A_H0_1 = _mm_unpacklo_epi32(ABCD0_3, EFGH0_3);
							__m128i I_P0_1 = _mm_unpacklo_epi32(IJKL0_3, MNOP0_3);
							__m128i A_H2_3 = _mm_unpackhi_epi32(ABCD0_3, EFGH0_3);
							__m128i I_P2_3 = _mm_unpackhi_epi32(IJKL0_3, MNOP0_3);
							__m128i A_H4_5 = _mm_unpacklo_epi32(ABCD4_7, EFGH4_7);
							__m128i I_P4_5 = _mm_unpacklo_epi32(IJKL4_7, MNOP4_7);
							__m128i A_H6_7 = _mm_unpackhi_epi32(ABCD4_7, EFGH4_7);
							__m128i I_P6_7 = _mm_unpackhi_epi32(IJKL4_7, MNOP4_7);

							//unpack16			
							__m128i AP0 = _mm_unpacklo_epi64(A_H0_1, I_P0_1);
							__m128i AP1 = _mm_unpackhi_epi64(A_H0_1, I_P0_1);
							__m128i AP2 = _mm_unpacklo_epi64(A_H2_3, I_P2_3);
							__m128i AP3 = _mm_unpackhi_epi64(A_H2_3, I_P2_3);
							__m128i AP4 = _mm_unpacklo_epi64(A_H4_5, I_P4_5);
							__m128i AP5 = _mm_unpackhi_epi64(A_H4_5, I_P4_5);
							__m128i AP6 = _mm_unpacklo_epi64(A_H6_7, I_P6_7);
							__m128i AP7 = _mm_unpackhi_epi64(A_H6_7, I_P6_7);

							//store
							_mm_storeu_si128((__m128i*)(pTarget + (ibcol * iblock + icol + 0) * NROW + ibrow * iblock + irow), AP0);
							_mm_storeu_si128((__m128i*)(pTarget + (ibcol * iblock + icol + 1) * NROW + ibrow * iblock + irow), AP1);
							_mm_storeu_si128((__m128i*)(pTarget + (ibcol * iblock + icol + 2) * NROW + ibrow * iblock + irow), AP2);
							_mm_storeu_si128((__m128i*)(pTarget + (ibcol * iblock + icol + 3) * NROW + ibrow * iblock + irow), AP3);
							_mm_storeu_si128((__m128i*)(pTarget + (ibcol * iblock + icol + 4) * NROW + ibrow * iblock + irow), AP4);
							_mm_storeu_si128((__m128i*)(pTarget + (ibcol * iblock + icol + 5) * NROW + ibrow * iblock + irow), AP5);
							_mm_storeu_si128((__m128i*)(pTarget + (ibcol * iblock + icol + 6) * NROW + ibrow * iblock + irow), AP6);
							_mm_storeu_si128((__m128i*)(pTarget + (ibcol * iblock + icol + 7) * NROW + ibrow * iblock + irow), AP7);

							//prefetch
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 0) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 1) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 2) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 3) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 4) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 5) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 6) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 7) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 8) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 9) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 10) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 11) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 12) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 13) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 14) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 15) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);


						}
					}
				}
			}
		}
		clock_t end = clock();
		std::cout << "SimdTransposeBlock8RowPadPrefetch 10240 Time " << (end - begin) << std::endl;
		std::cout << "SimdTransposeBlock8RowPadPrefetch each Transpose (ms) " << ((float)(end - begin)) / (float)REPEAT << std::endl;
	}

执行时间：

SimdTransposeBlock8RowPadPrefetch 10240 Time 686
SimdTransposeBlock8RowPadPrefetch each Transpose (ms) 0.0669922

程序在执行时间上有了进一步提升。

VTune分析

在这里插入图片描述
可以看到内存访问方面没有明显的性能问题。
在这里插入图片描述
因为实现中添加了prefetch指令，因此总的执行指令数量增加了。但是CPI相对而言是下降的。
在这里插入图片描述
之前的L3 Latency问题已经不是主要的性能热点。

OpenMP并行化

基于本文中之前实现版本，对程序做多线程并行化优化。因为每次循环中处理的数据块没有交集，因此对for循环做并行化可以保证结果的正确性。
代码实现：

void SimdTransposeBlock8RowPPP(unsigned char* pSource, unsigned char* pTarget)
	{
		//PPP -> Pad Prefetch Parallel
		clock_t begin = clock();
		int iblock = 128;
		int iwsize = NCOL / iblock;
		int ihsize = NROW / iblock;
		for (int i = 0; i < REPEAT; ++i)
		{
#pragma omp parallel for num_threads(8) schedule(dynamic)
			for (int ibcol = 0; ibcol < iwsize; ++ibcol)
			{
				for (int ibrow = 0; ibrow < ihsize; ++ibrow)
				{
					for (int icol = 0; icol < iblock; icol += 8)
					{
						for (int irow = 0; irow < iblock; irow += 16)
						{
							__m128i A0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 0) * NREALCOL + ibcol * iblock + icol));
							__m128i B0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 1) * NREALCOL + ibcol * iblock + icol));
							__m128i C0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 2) * NREALCOL + ibcol * iblock + icol));
							__m128i D0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 3) * NREALCOL + ibcol * iblock + icol));
							__m128i E0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 4) * NREALCOL + ibcol * iblock + icol));
							__m128i F0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 5) * NREALCOL + ibcol * iblock + icol));
							__m128i G0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 6) * NREALCOL + ibcol * iblock + icol));
							__m128i H0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 7) * NREALCOL + ibcol * iblock + icol));
							__m128i I0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 8) * NREALCOL + ibcol * iblock + icol));
							__m128i J0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 9) * NREALCOL + ibcol * iblock + icol));
							__m128i K0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 10) * NREALCOL + ibcol * iblock + icol));
							__m128i L0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 11) * NREALCOL + ibcol * iblock + icol));
							__m128i M0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 12) * NREALCOL + ibcol * iblock + icol));
							__m128i N0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 13) * NREALCOL + ibcol * iblock + icol));
							__m128i O0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 14) * NREALCOL + ibcol * iblock + icol));
							__m128i P0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 15) * NREALCOL + ibcol * iblock + icol));


							//unpack2
							__m128i AB0_7 = _mm_unpacklo_epi8(A0_7, B0_7);
							__m128i CD0_7 = _mm_unpacklo_epi8(C0_7, D0_7);
							__m128i EF0_7 = _mm_unpacklo_epi8(E0_7, F0_7);
							__m128i GH0_7 = _mm_unpacklo_epi8(G0_7, H0_7);
							__m128i IJ0_7 = _mm_unpacklo_epi8(I0_7, J0_7);
							__m128i KL0_7 = _mm_unpacklo_epi8(K0_7, L0_7);
							__m128i MN0_7 = _mm_unpacklo_epi8(M0_7, N0_7);
							__m128i OP0_7 = _mm_unpacklo_epi8(O0_7, P0_7);


							//unpack4
							__m128i ABCD0_3 = _mm_unpacklo_epi16(AB0_7, CD0_7);
							__m128i EFGH0_3 = _mm_unpacklo_epi16(EF0_7, GH0_7);
							__m128i IJKL0_3 = _mm_unpacklo_epi16(IJ0_7, KL0_7);
							__m128i MNOP0_3 = _mm_unpacklo_epi16(MN0_7, OP0_7);
							__m128i ABCD4_7 = _mm_unpackhi_epi16(AB0_7, CD0_7);
							__m128i EFGH4_7 = _mm_unpackhi_epi16(EF0_7, GH0_7);
							__m128i IJKL4_7 = _mm_unpackhi_epi16(IJ0_7, KL0_7);
							__m128i MNOP4_7 = _mm_unpackhi_epi16(MN0_7, OP0_7);

							//unpack8
							__m128i A_H0_1 = _mm_unpacklo_epi32(ABCD0_3, EFGH0_3);
							__m128i I_P0_1 = _mm_unpacklo_epi32(IJKL0_3, MNOP0_3);
							__m128i A_H2_3 = _mm_unpackhi_epi32(ABCD0_3, EFGH0_3);
							__m128i I_P2_3 = _mm_unpackhi_epi32(IJKL0_3, MNOP0_3);
							__m128i A_H4_5 = _mm_unpacklo_epi32(ABCD4_7, EFGH4_7);
							__m128i I_P4_5 = _mm_unpacklo_epi32(IJKL4_7, MNOP4_7);
							__m128i A_H6_7 = _mm_unpackhi_epi32(ABCD4_7, EFGH4_7);
							__m128i I_P6_7 = _mm_unpackhi_epi32(IJKL4_7, MNOP4_7);

							//unpack16			
							__m128i AP0 = _mm_unpacklo_epi64(A_H0_1, I_P0_1);
							__m128i AP1 = _mm_unpackhi_epi64(A_H0_1, I_P0_1);
							__m128i AP2 = _mm_unpacklo_epi64(A_H2_3, I_P2_3);
							__m128i AP3 = _mm_unpackhi_epi64(A_H2_3, I_P2_3);
							__m128i AP4 = _mm_unpacklo_epi64(A_H4_5, I_P4_5);
							__m128i AP5 = _mm_unpackhi_epi64(A_H4_5, I_P4_5);
							__m128i AP6 = _mm_unpacklo_epi64(A_H6_7, I_P6_7);
							__m128i AP7 = _mm_unpackhi_epi64(A_H6_7, I_P6_7);

							//store
							_mm_storeu_si128((__m128i*)(pTarget + (ibcol * iblock + icol + 0) * NROW + ibrow * iblock + irow), AP0);
							_mm_storeu_si128((__m128i*)(pTarget + (ibcol * iblock + icol + 1) * NROW + ibrow * iblock + irow), AP1);
							_mm_storeu_si128((__m128i*)(pTarget + (ibcol * iblock + icol + 2) * NROW + ibrow * iblock + irow), AP2);
							_mm_storeu_si128((__m128i*)(pTarget + (ibcol * iblock + icol + 3) * NROW + ibrow * iblock + irow), AP3);
							_mm_storeu_si128((__m128i*)(pTarget + (ibcol * iblock + icol + 4) * NROW + ibrow * iblock + irow), AP4);
							_mm_storeu_si128((__m128i*)(pTarget + (ibcol * iblock + icol + 5) * NROW + ibrow * iblock + irow), AP5);
							_mm_storeu_si128((__m128i*)(pTarget + (ibcol * iblock + icol + 6) * NROW + ibrow * iblock + irow), AP6);
							_mm_storeu_si128((__m128i*)(pTarget + (ibcol * iblock + icol + 7) * NROW + ibrow * iblock + irow), AP7);

							//prefetch
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 0) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 1) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 2) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 3) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 4) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 5) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 6) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 7) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 8) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 9) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 10) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 11) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 12) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 13) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 14) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);
							_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 15) * NREALCOL + ibcol * iblock + icol + 8), _MM_HINT_T0);


						}
					}
				}
			}
		}
		clock_t end = clock();
		std::cout << "SimdTransposeBlock8RowPPP 1024 Time " << (end - begin) << std::endl;
		std::cout << "SimdTransposeBlock8RowPPP each Transpose (ms) " << ((float)(end - begin)) / (float)REPEAT << std::endl;
	}

执行时间

SimdTransposeBlock8RowPPP 1024 Time 205
SimdTransposeBlock8RowPPP each Transpose (ms) 0.0200195

通过多线程加速，获得的加速比为3.43.

总结

本文通过内存预取技术，对矩阵转置功能中内存加载的L3 Cache问题进行优化。同时，通过OPenMP对程序做多线程并行化优化，获得3.43倍的加速比。

USST_Coder
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++实现矩阵压缩存储与（快速）转置
snow_5288的博客
12-10 1万+
注意：以下所有代码均在VS2010环境下运行测试             了解了C语言以后，我们都知道，要存储一个矩阵，用一个二维数组即可实现，今天，由我来带领大家玩点新鲜的，对矩阵进行压缩存储并对其进行转置。 一、对称矩阵及对称矩阵的压缩存储 1、什么是对称矩阵？        设一个N*N的方阵A，A中任意元素Aij，当且仅当Aij == Aji(0 && 0
基于AVX256指令集和多线程优化的双机计算加速程序
01-28
【基于AVX256指令集和多线程优化的双机计算加速程序】是一个C++编程项目，利用了先进的处理器指令集AVX256和多线程技术来提升计算性能，尤其适用于大规模数据处理和高性能计算场景。在VS2019环境下开发，项目实现了...
__builtin_prefetch()
chrysanthemumcao的专栏
05-09 6513
__builtin_prefetch() 是 gcc 的一个内置函数。它通过对数据手工预取的方法，减少了读取延迟，从而提高了性能，但该函数也需要 CPU 的支持。 该函数的原型为： void __builtin_prefetch (const void *addr, ...) 其中参数 addr 是个内存指针，它指向要预取的数据，我们人工需要判定这些数据是很快能访问到的，或者说是
数值计算优化方法C/C++(五)——矩阵转置优化示例(访存优化和SIMD的使用)
artorias123的博客
05-24 6740
C++数值计算简单加速技术(五)——矩阵转置优化示例(访存优化和SIMD的使用)
C++性能优化系列——矩阵转置(一)访问内存顺序带来的性能差异
yan31415的博客
07-27 3029
矩阵转置代码实现 说明：实现两种矩阵转置方法，其中测试平台9900k，为了让程序执行时间足够长，重复执行代码1024次。矩阵尺寸1024*1024。将矩阵按照128X128分块转置处理。每个块内部分别按照方式 按行索引读取和按列索引写 与 按列索引读和按行索引写 实现，即方法一 写行连续，方法二 读连续。 int main(int argc, char* argv[]) { #define NROW 1024 #define NCOL 1024 #define NSLICE NROW*NCOL #defin
c++矩阵的转置和快速转置
weixin_34380296的博客
05-26 818
矩阵的转置 将原矩阵的行、列对换，也就是将[i][j]和[j][i]位置上的数据对换。程序代码：#include<vector>//稀疏矩阵pushpopoperator[]和顺序表一致 template<classT> structTriple//定义一个三元组可以直接访问的定义成struct { size_t_row; ...
C++进行代码加速、多线程等知识点。pthread、openomp进行多线程加速、SSE进行加速
yangdeshun888的博客
07-10 4558
1、关于多线性进行全局变量的使用的时候为什么需要加锁？ a、在多线程中对全局变量进行处理的时候，如果涉及到在线程中对全局变量进行赋值的话，则需要进行加锁。 如果不加锁的话，容易导致全局变量在某个线程中被修改后，影响另一线程的数据处理。 b、全局变量不加锁主要是为了数据处理的正正确性，而不是为了防止导致多个线程同时操作同一个数据时出现程序崩溃。因为这种情况是不会产生的。 下面是一个多线程对多...
Redis硬核性能优化
04-14
Redis硬核性能优化主要关注如何识别和解决Redis性能下降的问题，以及如何进行系统性的优化流程。Redis作为一款高性能的键值存储数据库，广泛应用于缓存和数据存储场景，但其性能受到多种因素影响。 一、Redis变慢的...
VS2010 C++ 配置优化方案
09-04
在使用Visual Studio 2010 (VS2010)进行C++开发时，配置优化对于提升开发效率和代码质量至关重要。以下是一些关键的配置优化方案，可以帮助你更好地应对在VS2010中遇到的问题。 1. **减少项目文件大小**：新建的...
X86优化之Intrinsic汇编基础.docx
08-15
这个文档是x86架构Intrinsic汇编优化的知识总结，通过学习这个文档，可以掌握x86 Intrinsic基础知识，包括示例demo。
矩阵转置的并行算法mpi实现
06-25
矩阵转置的并行化实现，用的的是c语言，mpi实现的，可以参考下
Intrinsic3D -高质量的3D重建通过联合外观和几何优化与空间变化的照明(ICCV 2017) - NVlabs/ Intrinsic3D
01-27
《Intrinsic3D：高质量3D重建的联合外观与几何优化及空间变化照明技术》 Intrinsic3D是由NVlabs开发的一种创新的3D重建技术，它在2017年的国际计算机视觉会议（ICCV）上进行了展示。这项技术的核心在于通过联合优化...
C++系列11：openmp多线程编程
kittyzc的博客
05-16 1479
我们在系列6里面已经说了多线程(使用std::thread库)，然而项目里面竟然还用到了openmp，不得已只能看下。 1. 入门介绍 openmp是由一系列#paragma指令组成，这些指令控制如何多线程的执行程序。另外，即使编译器不支持omp，程序也也能够正常运行，只是程序不会多线程并行运行。 首先要在cmake中添加上openmp，cmake3.9之后内置了openmp，按照下述语句写即可： 然后看一个简单例子： 2. 语法解释 2.1 紧跟for omp中的for指令用于告诉编译器，拆分接下来的
C++性能优化系列——矩阵转置(四)OpenMP并行计算
yan31415的博客
08-05 2071
C++版本 c++版本并行化实现 unsigned char* pSource; pSource = (unsigned char*)malloc(sizeof(unsigned char) * NREALCOL * NROW); for (int irow = 0; irow < NROW; ++irow) { memset(pSource + irow * NREALCOL, irow % 256, sizeof(unsigned char) * NREALCOL);//按照字节
OpenMP实现矩阵转置
renbaifen的博客
02-22 533
矩阵转置实际上是很简单的，但是数据类型是虚数的时候，编译器会认为实部虚部有数据依赖从而不能自动向量化，通过编译指导#pragma ivdep可以解除这种貌似的数据依赖，但是自动向量化的执行速度应该没有OpenMP快，干脆改成OpenMP并行得了。 #include <stdio.h> #include <stdlib.h> #include <omp.h> ...
DDR 内存基础知识（2）- DDR预取
weixin_43858632的博客
07-31 9014
对预取概念理解之前，先来复习下DDR颗粒位宽的概念。上一篇文章说了，一个Memory Array中由行地址和列地址的交叉选中一个位，若两个Array叠加在一起，就同时选中了两个Bit，位宽是X2。若四个Array叠加到一起，就能够同时选中四个Bit，位宽则是X4。也就是说，对一个X4位宽的DDR 颗粒，如果给出行地址和列地址，就会同时输出4个Bit到DQ数据线上。 进入DDR时代之后，就有了prefetch技术，DDR1是两位预取（2-bit Prefetch）有的公司则贴切的称之为2-n Prefetc
《高性能科学与工程计算》——3.4　案例分析：稠密矩阵转置
weixin_33853827的博客
07-03 198
本节书摘来自华章计算机《高性能科学与工程计算》一书中的第3章，第3.4节,作者:(德）Georg Hager Gerhard Wellein 更多章节内容可以访问云栖社区“华章计算机”公众号查看。 3.4　案例分析：稠密矩阵转置 在下面的实例分析中，假定矩阵按列存储。计算一个稠密矩阵的转置（A = BT），根据循环的组织顺序，矩阵A或者B会有一个矩阵的...
利用GPU内存的预获取功能加速应用
专注于人工智能领域的小何尚
05-21 666
利用GPU内存的预获取功能加速应用 NVIDIA GPU 具有巨大的计算能力，通常必须高速输入数据才能部署这种能力。 原则上这是可能的，因为 GPU 也具有高内存带宽，但有时它们需要您的帮助才能使带宽饱和。 在这篇文章中，我们研究了一种特定的方法来实现这一点：预取。 我们解释了预取在哪些情况下可以正常工作，以及如何确定这些情况是否适用于您的工作负载。 Context NVIDIA GPU 的强大功能来自大规模并行性。许多 32 个线程的 warp 可以放置在流式多处理器 (SM) 上，等待轮到它们执行。当
C++与OMP配合的最简线程池
丁劲犇技术发布空间
07-04 4356
最近在写算法时，发现OpenMP + C++ functional 可以瞬间构造一个线程池，并执行风马牛不相及的事情。看来，有必要好好思考一下今后算法优化的事情了！
高性能计算实验——矩阵乘法
最新发布
01-03
矩阵乘法是高性能计算中的一个重要问题。在高性能计算实验中，矩阵乘法的实现和优化是一个常见的研究方向。通过使用并行计算技术，如OpenMP和Pthreads，可以显著提高矩阵乘法的计算效率。 在实验中，首先通过OpenMP实现通用矩阵乘法。这可以通过使用OpenMP的并行for循环来实现。通过将矩阵的计算任务分解为多个子任务，并在多个线程上并行执行，可以加速矩阵乘法的计算过程。 其次，可以对通用矩阵乘法进行优化。优化的方法包括使用SIMD Intrinsic函数和矩阵分块技术。SIMD Intrinsic函数是一组特殊的函数，可以直接利用CPU的SIMD指令集来进行向量化计算，从而提高计算效率。矩阵分块技术可以将大矩阵分解为多个小矩阵，并通过优化内存访问模式来减少缓存访问的次数，从而提高计算效率。 最后，可以评估矩阵大小对加速比的影响。通过逐渐增加矩阵的规模，可以观察到加速比的变化情况。通常情况下，随着矩阵规模的增加，加速比会逐渐增加，但可能会达到一个饱和点。 总结来说，高性能计算实验中的矩阵乘法主要包括通过OpenMP实现通用矩阵乘法、优化矩阵乘法的计算效率，并评估矩阵大小对加速比的影响。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值