SIMD加速计算矩阵（组成原理实验5）

最新推荐文章于 2023-11-19 00:12:37 发布
最新推荐文章于 2023-11-19 00:12:37 发布
阅读量938 收藏 7
点赞数 2
文章标签： c++ 矩阵
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/horizon08/article/details/110678605
版权

介绍

实验5的文档内容：https://shimo.im/docs/4iV7Rw1nxLgeMsBe/

以下仅实现了第一部分的SIMD的功能。

  • a) 介绍
    并行化是计算机硬件的大趋势。然而，程序员不做任何修改，只依赖于计算机体系结构专家、编译器设计者和芯片工程师的工作就能让程序跑得更快，这样的日子已经一去不复返了。因此，如果想要让程序跑得更快，软件设计人员应该掌握并行编程的基本思想。
    在这部分实验中，你需要利用SIMD内蕴函数编写并行代码解决问题。
  • b) 熟悉实验代码
    你将拿到两个源文件 randomized.cpp 和 common.h, 你可以在你熟悉的开发平台上编译randomized.cpp，并观察运行效果。你需要优化的函数sum()放在common.h头文件中，这段代码完成的核心功能是对一个整型数组进行有条件求和，并对程序运行时间进行计时。由于核心函数的SIMD版本还未实现，你应该能够看到两个版本之间的运行结果是不一致的。
  • c) 使用SIMD内蕴函数对求和函数进行优化
    在common.h头文件中找到函数sum_simd(), 你需要根据以下代码进行相应的优化：

（注意：你仅仅需要对内层的循环体进行优化。）
在优化的过程中，你可能会用到以下内蕴函数：
在这里插入图片描述

  • d) 一些有益的提示

    • i. __m128i是Intel用于声明128-bit向量的数据类型，我们会用一个__m128i类型的变量存放四个32-bit的整形数；
    • ii. 代码中提供了一个叫做_127的变量，它当中包含了数字127的四份拷贝，你可以把它用在比较上；
    • iii. 在你完成内层循环体的计算之前，不要使用保存函数(_mm_storeu_si128)。这个函数的计算代价很高，如果你在每一次循环结束时都使用它，你会发现你的代码的性能不够好；
    • iv. 在访问__m128i类型的向量时，不推荐你直接地访问它当中的每一个元素，更好的方法是把__m128i类型的向量用storeu的方法存放到一个普通的数组当中，然后单独访问这个数组当中的元素；
    • e) 实验结果与实验报告
      当你完成代码之后，你应该能够观察到以下效果：

  • i. SIMD版本的代码与未优化的代码的计算结果保持一致；

  • ii. SIMD版本的代码应该要比未优化的代码快（快多少，记录下性能加速比，并且分析为什么你认为它是正确的结果）

    在你的实验报告中提供你的代码、运行结果和你的思考过程，并上传一个简短的带解说的演示视频（只给出代码截图和实验结果，但却不提供分析过程的不给分。）

  • 实验给出的源代码common.h：

#ifndef COMMON_H
#define COMMON_H

#include <x86intrin.h>

#define NUM_ELEMS ((1 << 15) + 10)
#define OUTER_ITERATIONS (1 << 15)

/* 不要修改这个函数 */
long long int sum(unsigned int vals[NUM_ELEMS]) {
	clock_t start = clock();

	long long int sum = 0;
	for(unsigned int w = 0; w < OUTER_ITERATIONS; w++) {
		for(unsigned int i = 0; i < NUM_ELEMS; i++) {
			if(vals[i] >= 128) {
				sum += vals[i];
			}
		}
	}
	clock_t end = clock();
	printf("Time taken: %f s\n", (double)(end - start) / CLOCKS_PER_SEC);
	return sum;
}

/* 不要修改这个函数 */
long long int sum_unrolled(unsigned int vals[NUM_ELEMS]) {
	clock_t start = clock();
	long long int sum = 0;

	for(unsigned int w = 0; w < OUTER_ITERATIONS; w++) { 
		for(unsigned int i = 0; i < NUM_ELEMS / 4 * 4; i += 4) {
			if(vals[i] >= 128) sum += vals[i];
			if(vals[i + 1] >= 128) sum += vals[i + 1];
			if(vals[i + 2] >= 128) sum += vals[i + 2];
			if(vals[i + 3] >= 128) sum += vals[i + 3];
		}

		//This is what we call the TAIL CASE
		//For when NUM_ELEMS isn't a multiple of 4
		//NONTRIVIAL FACT: NUM_ELEMS / 4 * 4 is the largest multiple of 4 less than NUM_ELEMS
		for(unsigned int i = NUM_ELEMS / 4 * 4; i < NUM_ELEMS; i++) {
			if (vals[i] >= 128) {
				sum += vals[i];
			}
		}
	}
	clock_t end = clock();
	printf("Time taken: %f s\n", (double)(end - start) / CLOCKS_PER_SEC);
	return sum;
}

long long int sum_simd(unsigned int vals[NUM_ELEMS]) {
	clock_t start = clock();
	
	//这句代码会为你生成一个含有若干个127的向量
	//思考题：为什么你需要它？
	__m128i _127 = _mm_set1_epi32(127);		
	
	long long int result = 0;// 将最终计算的结果保存在这里 
	
	//不要修改此行之上的任何代码！！！ 
	
	for(unsigned int w = 0; w < OUTER_ITERATIONS; w++) {
		/* 你的代码从这里开始 */

		/* 你的代码在这里结束 */

	}
	clock_t end = clock();
	printf("Time taken: %f s\n", (double)(end - start) / CLOCKS_PER_SEC);
	return result;
}

/* 不要修改这个函数 */
int int_comparator(const void* a, const void* b) {
	if(*(unsigned int*)a == *(unsigned int*)b) return 0;
	else if(*(unsigned int*)a < *(unsigned int*)b) return -1;
	else return 1;
}

#endif
  • 源代码randomized.cpp
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include "common.h"

/* ***不要修改这个文件！只能修改common.h的内容！*** */

int main(int argc, char* argv[]) {
	printf("Let's generate a randomized array.\n");
	unsigned int vals[NUM_ELEMS];
	long long int reference;
	long long int simd;
	long long int simdu;
	for(unsigned int i = 0; i < NUM_ELEMS; i++) vals[i] = rand() % 256;

	printf("Starting randomized sum.\n");
	printf("Sum: %lld\n", reference = sum(vals));

	printf("Starting randomized unrolled sum.\n");
	printf("Sum: %lld\n", sum_unrolled(vals));

	printf("Starting randomized SIMD sum.\n");
	printf("Sum: %lld\n", simd = sum_simd(vals));
	if (simd != reference) {
		printf("OH NO! SIMD sum %lld doesn't match reference sum %lld!\n", simd, reference);
	}
}
题目要求只修改common.h

我实现的代码，如下：

#ifndef COMMON_H
#define COMMON_H

#include <x86intrin.h>
#include <stdint.h>
#define NUM_ELEMS ((1 << 15) + 10)
#define OUTER_ITERATIONS (1 << 15)

/* 不要修改这个函数 */
long long int sum(unsigned int vals[NUM_ELEMS]) {
	clock_t start = clock();

	long long int sum = 0;
	for(unsigned int w = 0; w < OUTER_ITERATIONS; w++) {
		for(unsigned int i = 0; i < NUM_ELEMS; i++) {
			if(vals[i] >= 128) {
				sum += vals[i];
			}
		}
	}
	clock_t end = clock();
	printf("Time taken: %f s\n", (double)(end - start) / CLOCKS_PER_SEC);
	return sum;
}

/* 不要修改这个函数 */
long long int sum_unrolled(unsigned int vals[NUM_ELEMS]) {
	clock_t start = clock();
	long long int sum = 0;

	for(unsigned int w = 0; w < OUTER_ITERATIONS; w++) { 
		for(unsigned int i = 0; i < NUM_ELEMS / 4 * 4; i += 4) {
			if(vals[i] >= 128) sum += vals[i];
			if(vals[i + 1] >= 128) sum += vals[i + 1];
			if(vals[i + 2] >= 128) sum += vals[i + 2];
			if(vals[i + 3] >= 128) sum += vals[i + 3];
		}

		//This is what we call the TAIL CASE
		//For when NUM_ELEMS isn't a multiple of 4
		//NONTRIVIAL FACT: NUM_ELEMS / 4 * 4 is the
		// largest multiple of 4 less than NUM_ELEMS
		for(unsigned int i = NUM_ELEMS / 4 * 4; i < NUM_ELEMS; i++) {
			if (vals[i] >= 128) {
				sum += vals[i];
			}
		}
	}
	clock_t end = clock();
	printf("Time taken: %f s\n", (double)(end - start) / CLOCKS_PER_SEC);
	return sum;
}

long long int sum_simd(unsigned int vals[NUM_ELEMS]) {
	clock_t start = clock();
	
	//这句代码会为你生成一个含有若干个127的向量
	//思考题：为什么你需要它？
	//用来实现比较对应的128， (>127) == (>=128)
	__m128i _127 = _mm_set1_epi32(127);		
	//用来比较数字是否>=128 
	long long int result = 0;// 将最终计算的结果保存在这里 
	
	//不要修改此行之上的任何代码！！！ 
	 
	__m128i p =  _mm_setzero_si128( );//用来保存从数组中读取的数据
	
	for(unsigned int w = 0; w < OUTER_ITERATIONS; w++) {
		/* 你的代码从这里开始 */
		__m128i sum = _mm_setzero_si128( );//需要sum的值
		for(unsigned int i = 0; i < NUM_ELEMS / 4 * 4; i += 4){

			__m128i* h = (__m128i*)(vals+i);//地址强制类型转换
			p = _mm_loadu_si128( h );//从指针中获取值,获取128位,即4Byte,恰好是vals[0-3]
			__m128i flag =  _mm_setzero_si128( ); 
		 	flag = _mm_cmpgt_epi32( p , _127 ); //大于127时应该是oxfffff，
		 	//一下子比较四个向量, 4Byte的每一bits都是应该是十进制的-1,而但小于时则会出现ox0000,
		 	//所以就是0, 在flag中的四个部分中分别比较后的结果会变成四个部分保存, 
		 	//所以只存在-1和0的结果.如果都大于,(-1,-1,-1,-1).
		 	
		 	//这样子的话,-1时是每一bis都是1, 那么我们取大于的时候,
		 	//直接用flag和我们的p来做and与计算, 那么如果大于,直接保留不变,
		 	//小于的话是0,与完后变成0,相当于跳过计算,不影响我们的计算结果.

			__m128i hi = _mm_setzero_si128( );
			hi = _mm_and_si128( p, flag );
			
			sum = _mm_add_epi32(sum, hi);
				 
		}
			//int 一般为32位, 4*32 = 128
			int32_t *k = (int *)&sum;//将_m128i转换为4个int型的数组 (
			result = result + k[0] + k[1] + k[2] + k[3];//将其全部加入result
		
		for(unsigned int i = NUM_ELEMS / 4 * 4; i < NUM_ELEMS; i++) {
			if (vals[i] >= 128) {
				result += vals[i];
			}
			
		}
		//result *= OUTER_ITERATIONS;
		/* 你的代码在这里结束 */
	}
	clock_t end = clock();
	printf("Time taken: %f s\n", (double)(end - start) / CLOCKS_PER_SEC);
	return result;
}

/* 不要修改这个函数 */
int int_comparator(const void* a, const void* b) {
	if(*(unsigned int*)a == *(unsigned int*)b) return 0;
	else if(*(unsigned int*)a < *(unsigned int*)b) return -1;
	else return 1;
}

#endif
运行结果

在这里插入图片描述

Nice

在这里插入图片描述

horizon08
关注
C语言实现矩阵乘法（包括使用SIMD）
代码演奏家
12-13 702
实现三种不同的矩阵乘法，并研究它们所消耗的时间。并且使用SIMD实现了矩阵乘法
奇妙之旅：SIMD加速矩阵运算
ayww的博客
03-20 5367
奇妙之旅：SIMD加速矩阵运算1.前言2.预备知识3.计算逻辑4.代码实战 1.前言   游戏会涉及到大量4x4的矩阵乘法运算，而乘法最简单直观的实现就是循环4×4×4次乘法，以及若干次加法，得到结果。   在计算量较少时，cpu并不是很紧张。然而游戏通常每秒伴随着大量运算，此时，计算的效率就显得尤为重要。   通过查阅文献，我发现了一种SIMD（Single Instruction Multip...
27 | SIMD：如何加速矩阵乘法？
qyf__123的博客
08-21 1846
27 | SIMD：如何加速矩阵乘法？ 上一讲里呢，我进一步为你讲解了 CPU 里的“黑科技”，分别是超标量（Superscalar）技术和超长指令字（VLIW）技术。 超标量（Superscalar）技术能够让取指令以及指令译码也并行进行；在编译的过程，超长指令字（VLIW）技术可以搞定指令先后的依赖关系，使得一次可以取一个指令包。 不过，CPU 里的各种神奇的优化我们还远远没有说完。这一讲里，...
SIMD学习 -- 用SSE2指令作点乘和累加计算
weixin_33889665的博客
03-25 734
这几天在做学校的一个学习小项目，需要用到SIMD指令计算提速。也是第一次碰这个，看了一些资料和代码，模仿着写了两个函数。 void sse_mul_float(float *A, float *B, int cnt)：两段内存float数据点乘，结果覆盖第一组内存。 float sse_acc_float(float *A, int cnt)：一组内存float值累加。 注： 1. 没...
SIMD单指令多数据（并行计算）
最新发布
weixin_49520696的博客
11-19 500
一个简单的 SIMD 操作可能是将这两个向量相加，结果是一个新的向量，其元素是原始向量元素的和。在一个非 SIMD 架构中，您可能需要四个独立的加法指令来完成这个任务。然而，编写利用 SIMD 的代码需要更多的注意和经验，因为不是所有的算法和数据结构都可以轻易地适应并行处理。能够在一个周期内处理多个数据元素通常可以大大加快处理速度，特别是对于像图形、音频处理和其他多媒体任务这样的工作负载，它们经常涉及到大块数据。在 SIMD 中，数据通常被组织成“向量”，而不是传统的单个“标量”。
perflab实验报告.doc
03-27
这篇实验报告是关于湖南大学计算机组成与结构课程的一项实验，名为"perflab"，旨在通过程序性能调优提高代码效率。实验主要关注两个函数：rotate和smooth，它们分别用于图像90度旋转和模糊处理。实验者需要优化这两...
关于操作系统设计的基本原理和设计原则
tugouxp的专栏
03-09 6857
操作系统设计的精妙之处就在于，在底层硬件之上创造了新的抽象， 对于系统初始化来说， 它呈现了执行流到线程转化这一概念，该概念远远比它的实现细节更加重要，处理器以“取指-执行”为周期开始串行执行指令，而初始化代码将自身转化为一个并发处理系统， 这里的关键之处在于，初始化代码并不是创建一个独立的并发系统，然后跳转到新的系统。
计算机体系结构的一些总结
tugouxp的专栏
02-05 1173
广义上来说，按照不同层次的授权等级，可把芯片IP分类为指令集、IP核、芯片架构等。如果说指令集是一本“字典”，那么IP核提供了“段落”的写作方式，芯片架构则可被视作是“整篇文章的提纲”。芯片IP企业作为芯片设计企业的上游供应商，通常以授权的方式，向后者收取专利费用。而芯片设计企业通过购买不同层级的IP授权，可以设计出不同自研程度的芯片产品。
Python 高性能编程
GitChat
04-13 4732
你将获得 通过阅读本书，你将能够： 更好地掌握 numpy、Cython 和剖析器； 了解 Python 如何抽象化底层的计算机架构； 使用剖析手段来寻找 CPU 时间和内存使用的瓶颈； 通过选择合适的数据结构来编写高效的程序； 加速矩阵和矢量计算； 使用工具把 Python 编译成机器代码； 管理并发的多 I O 和计算操作； 把多进程代码转换到在本地或者远程集群上运行； 用更少的内存...
TPU原理技术与xPU
吴建明wujianming_110117
06-01 2250
TPU原理技术与xPU
C# 使用SIMD向量类型加速浮点数组求和运算（1）：使用Vector4、Vector＜T＞
「 虚幻私塾」
08-20 468
大小固定的向量类型，是以下3种结构体——Vector2：表示一个具有两个单精度浮点值的向量。Vector3：表示一个具有三个单精度浮点值的向量。Vector4：表示一个具有四个单精度浮点值的向量。它们实际上是对数学（线性代数分支）里“向量”（Vector）的封装。命名规则为“‘Vector’ + [维数]”，例如 Vector2是数学里的“二维向量”、Vector3是数学里的“三维向量”、Vector4是数学里的“四维向量”。
CC算法设计(1)
SevenXueQY的博客
03-28 1364
算法设计存在的难点： 1. 如何部署初始的服务器 2. 如何对服务器进行有效的迭代 3. 路径如何选择？局部最优和整体最优的权衡 部署初始的服务器算法来源于模拟退火算法，选择一定的节点部署服务器，然后进行迭代。 模拟退火算法对初始值要求高，初始值的设计来自上一篇文章的总结，选择消费节点的1/4（取整）为初始数量，同时将消费节点布置在边数最多的节点上。如何对服务器进行有效的迭代对初始服务器有三
Opencv 仿射变换原理代码解析
u010796650的博客
05-22 2830
仿射变换原理 仿射变换是线性变换，有一张图可以很好地展示放射变换的效果 其实仿射变换是透视变换的一种特例，但是透视变换的自由度更高，3*3的矩阵表示，透视变换的自由度是8，而放射变换可以用2*3的矩阵表示，【A B】 A是2*2的旋转部分+缩放因子S，而B是平移部分+缩放因子，是一个5个自由度的参数矩阵。 典型的放射变换包括平移，缩放和旋转。 其中Opencv中的旋转由于是绕某个图像坐标...
SSE指令集学习
sinat_41612591的博客
12-07 6376
一、SSE简介 SSE指令，被包含在头文件：“emmintrin.h”（SSE2）中，且大多数SSE操作需要所给的数据是16-bytes对齐； SSE（Streaming SIMD Extensions），是一种SIMD（单指令，多数据）指令集，即利用一个指令同时对多个资料进行相同的动作.SSE指令主要包含了四个部分：单精度浮点数运算指令，整数运算指令，缓存控制指令和状态控制指令。 SSE指...
大数据与算法——累加求和、求最大值、排序加速（二)
lc1852109的博客
02-03 1882
大数据与算法——累加求和、求最大值、排序加速大数据与算法作业介绍及加速方法解析1.作业介绍及初始化代码1.1 作业要求1.2 概念解析1.2.1 算法累加求和求最大值排序快速排序（递归实现）冒泡排序折半插入排序归并排序堆排序1.2.2 加速手段多线程（多进程）SSE指令集Openmp加速Cuda加速1.2.3 扩展ubuntu介绍2.初始化代码2.1初始化数据2.2建立通信连接 大数据与算法作业介绍及加速方法解析 1.作业介绍及初始化代码 1.1 作业要求 利用多种加速方式，实现对64*2000000个数据
Intel 平台编程总结----SIMD技术
无敌三脚猫的专栏
06-12 6324
SIMD是指单指令多数据技术，它已经成为Intel处理器的重要性能扩展。目前Intel处理器支持的SIMD技术包括MMX,SSE,AVX. MMX提供了8个64bit的寄存器进行SIMD操作，SSE系列提供了128bit的8个寄存器进行SIMD指令操作。而最新的AVX指令则支持256bit的SIMD操作。 目前SIMD指令可以有四种方法进行使用分别是汇编语言，C++类，编译器Intrisinc
SSE2 Intrinsics各函数介绍
架构设计
01-18 864
SIMD相关头文件包括： //#include &lt;ivec.h&gt;//MMX //#include &lt;fvec.h&gt;//SSE(also include ivec.h) //#include &lt;dvec.h&gt;//SSE2(also include fvec.h) #include &lt;mmintrin.h&gt; //MMX #inclu...
__m128i的理解[转]
weixin_30316097的博客
10-21 1204
__m128i被称为128bits的整数，当我们对其赋值时，调用 __m128i_mm_set1_epi32(int i) Sets the four signed 32-bit integer values toi. R0 R1 R2 R3 i i i ...
王道计算机组成原理笔记：七章解析
"这是一份详细的计算机组成原理学习笔记，基于王道计算机组成原理课程视频制作，涵盖了七章内容，旨在帮助学习者深入理解计算机系统的基础构造和工作原理。笔记内容包括计算机的发展历程、计算机系统层次结构、冯·...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值