【超算/先进计算学习】日报6

已于 2023-04-24 20:04:45 修改
阅读量501 收藏
点赞数
分类专栏： 【超算/先进计算学习】 文章标签： 学习 性能优化
于 2023-04-24 19:26:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yv_shu/article/details/130323254
版权

目录

今日已完成任务列表

4-3、传统性能优化

遇到的问题及解决方案

无

任务完成详细笔记

传统性能优化

从体系结构角度理解四种计算优化途径-主频/缓存/流水线/超标量

在这里插入图片描述
提高计算速度的技术途径：
1、提高主频
2、高速缓冲存储器
3、流水线技术
4、并行技术

  • 提高主频
    与硬件制造工艺有关
  • 高速缓存
    降低数据传输过程中的花费
  • 流水线技术
    同一周期多条指令 (不相互冲突) 重叠执行
  • 并行技术
    例如：存在多个加法部件

优化途径的有效适用条件

  • 提高主频
    在非理想情况下，运算速度与主频不成比例增长
  • 高速缓存
    经常出现缓存缺失的情况，需要找的数据不在高速缓存中 (缓存不命中)
  • 流水线技术
    当数据之间存在相关性时，并不能保持流水线指令的流水执行
  • 并行技术
    并性结果正在输出时会导致并行中断
    充分利用流水、并行工作的条件

指令间没有相关，即相互独立
结构相关：两条指令要用同一个部件
数据相关：一条指令要用另一条指令的结果
控制相关：条件转移指令影响其他指令

存储墙与层次式存储结构

在这里插入图片描述

  • CPU消耗数据的速率远大于存储器供数率

时钟频率增长的速度远大于访存时间缩短的速度
同时执行多条指令要求供数率进一步提高
多线程或芯片内多处理器要求访问多组数据

  • 已知的解决方案：存储器层次结构

片内 cache 的供数率能满足指令级并行的要求
片内 cache 的命中率足够高
为多个线程或处理器提供各自的 cache
如何通过程序或算法的改进增强访存的局部性

数据局部性与cache

  • 时间局部性
    指的是同一份数据在短时间内往往会被多次重复使用，例如：当我们读取了一个数据 a，在接下来一段时间可能会不断地访问数据 a
  • 空间局部性
    指的是如果访问了某个数据，那么往往也需要访问它附近的数据，例如：如果访问了一个数组里的元素 a[1]，那么接下来很有可能会访问 a[0] 或 a[2]
    cache 结构
    在这里插入图片描述
  • 一个一个的 cacheline 堆叠而成
    当前顺序的 cache 命中率至少 75%
  • cache 满了之后的替换
    整行替换 cacheline
    间隔访问数据容易导致 cache miss

循环合并

  • loop fusion，将具有相同迭代次序的两个循环合并成一个
for (i=0; i<N; i++)
	x[i] = a[i] + b[i]
for (i=0; i<N; i++)
	y[i] = a[i] - b[i]

for (i=0; i<N; i++)
{
	x[i] = a[i] + b[i];
	y[i] = a[i] - b[i];
}
  • 优点
    减少循环迭代的开销
    增强数据重用，寄存器重用
    减小并行化的启动开销

进行循环合并后不能影响最终的程序运行结果

循环展开

  • loop unrolling，是一种牺牲程序长度来加快程序执行速度的方法。可以由程序原完成，也可以由编译器完成。
    在这里插入图片描述
for (i=0; i<N; i++)
{
	A[i] = A[i] + B[i];
}

for (i=0; i<N; i+=4)
{
	A[i] = A[i] + B[i];
	A[i+1] = A[i+1] + B[i+1];
	A[i+2] = A[i+2] + B[i+2];
	A[i+3] = A[i+3] + B[i+3];
}
  • 优点
    减少循环指令分支的次数
    获得更多的指令级并行
    增加了寄存器的重用

循环交换

当一个循环体中包含一个以上的循环，且循环语句之间不包含其他语句，则称这个循环为紧嵌套循环，交换紧嵌套中两个循环的嵌套顺序是提高程序性能最有效的变换之一。实际上，循环交换是一个重排序变换，仅改变了参数化迭代的执行顺序，但是并没有删除任何语句或产生任何新的语句，所以循环交换的合法性需要通过循环的依赖关系进行判定。

for (j=0; j<N; j++)
{
	for (k=0; k<N; k++)
	{
		for (i=0; i<N; i++)
		{
			A[i][j] = a[i][j] + B[i][k] * C[k][j];
		}
	}
}

for (j=0; j<N; j++)
	for (i=0; i<N; i++)
		for (k=0; k<N; k++)
			A[i][j] = A[i][j] + B[i][k] * C[k][j];
  • 优点
    增强数据局部性
    增强向量化和并行化的识别

循环分布

  • Loop Distribute，是指将一个循环分解为多个循环，且每个循环都有与原循环相同的迭代空间，但只包含原循环的语句子集，常用于分解出可向量化或者可并行化的循环，进而将可向量化部分的代码转为向量执行
for (i=0; i<N; i++)
{
	A[i] = i;
	B[i] = 2 + B[i];
	C[i] = 3 + C[i-1];
}

for (i=0; i<N; i++)
{
	A[i] = i;
	B[i] = 2 + B[i];
}
for (i=0; i<N; i++)
	C[i] = 3 + C[i-1];
  • 优点
    将串行循环转变为多个并行循环
    实现循环的部分并行化
    增加循环的优化范围
  • 缺点
    减小了并行粒度，增加了额外的通信和同步开销

循环不变量外提

  • 循环不变量是指在迭代过程中不发生变化的量。由于不发生变化，可以将循环不变量提到循环外面，避免重复计算
for (i=0; i<N; i++)
	for (j=0; j<M; j++)
		U[i] = U[i] + W[i] * W[i] * D[j] / (dt * dt);

T1 = dt * dt;
for (i=0; i<N; i++)
{
	T2 = W[i] * W[i];
	for (j=0; j<M; j++)
		U[i] = U[i] + T2 * D[j]/T1;
}
  • 优点
    减小循环内的计算量

循环分块

  • 思路：一个 cache line 现在被用过以后，后面什么时候还会被用，按照循环默认的执行方式，可能到下次再被用到的时候已经被替换了。于是我们就把循环重排一下，使得一个 cache line 在被替换之前就被再次使用
    在这里插入图片描述
  • A[i] 在每一轮 j 循环中被重用
  • B[j] 当 M 数值比较大时，无法全部缓存在 cache 里。所以当 i 进入到下一层循环时，B[0] 已经被清出 cache，无法重用
  • 假设 cache line 大小为 b。理想情况下，则可计算出 A 的 cache miss 次数是 N/b，B 的 cache miss 次数是 N*M/b
    在这里插入图片描述
  • 分块 j 层循环，将 B 的访问模式变成如下，令块大小为 T，T 一般是 b 的倍数，也足够小，可以认为 N，M>>b, T，T 的取值应该使得当 B(T) 被访问时 B(0) 也依然还在缓存中
  • 分块 j 层循环的时候，分块后 j 层循环变到了外面，该操作会影响 A 的缓存命中率。A 的 cache miss 次数：(M/T) x (N/b)，B 的 cache miss 次数是 T/b x M/T = M/b

矩阵乘法
在这里插入图片描述
矩阵分块算法可以提高缓存的命中率
在这里插入图片描述

inline void do_block(int n, float *A, float *B, float *C)
{
	for (int i=0; i<BLOCKSIZE; i++)
	{
		for (int j=0; j<BLOCKSIZE; j++)
		{
			float cij = C[i*n + j];
			for (int k=0; k<BLOCKSIZE; k++)
			{
				cij += A[i*n + k] * B[k*n + j];  // C[i][j] = A[i][:] * B[:][j]
			}
			C[i*n + j] = cij;
		}
	}
}
inline void degmm_block(int n, float *A, float *B, float *C)
{
	for (int sj=0; sj<n; sj += BLOCKSIZE)              
		for (int si=0; si<n; si += BLOCKSIZE)
			for (int sk=0; sk<n; sk += BLOCKSIZE)
				do_block(n, A + si*n + sk, B + sk*n + sj, C + si*n +sj);
}

分块要点
1、根据矩阵大小选择是否分块
2、处理不能整除的情况
3、保证计算结果的正确性
4、基于不同矩阵大小测试不同块大小对性能的影响

循环分裂

  • 循环分裂是将循环的迭代次数拆成两段或者多段，拆分后的循环不存在主体循环之说，也就是拆分成迭代次数都比较多的两个或者多个循环
for (i=0; i<N; i++)
	vec[i] = vec[i] + vec[M];

for (i=0; i<M; i++)
	vec[i] = vec[i] + vec[M];
for (i=M; i<N; i++)
	vec[i] = vec[i] + vec[M];
  • 优点
    增加编译器向量化可能 -O3 -fopt-info

优化 jacobi 程序

  • 未采用任何优化手段
    在这里插入图片描述
    根据上次的分析，程序的热点函数为 LaplasEquationSolver，所以重点考虑对其进行优化
  • 进行循环展开
	do {
		for (uint8_t i = 1; i < N - 1; ++i){
			for (uint8_t j = 1; j < K - 1; j+=2) {
				u1[i][j] = (1.0 / 4.0) * (u1[i - 1][j] + u1[i + 1][j] + u1[i][j - 1] + u1[i][j + 1]);	
				u1[i][j+1] = (1.0 / 4.0) * (u1[i - 1][j+1] + u1[i + 1][j+1] + u1[i][j] + u1[i][j + 2]);	
			}
		}

		for (uint8_t i = 1; i < N - 1; ++i){
			for (uint8_t j = 1; j < K - 1; j+=2) {
				u2[i][j] = (1.0 / 4.0) * (u1[i - 1][j] + u1[i + 1][j] + u1[i][j - 1] + u1[i][j + 1]);
				u2[i][j+1] = (1.0 / 4.0) * (u1[i - 1][j+1] + u1[i + 1][j+1] + u1[i][j] + u1[i][j + 2]);
			}
		}

		for (uint8_t i = 0; i < N; ++i){
			for (uint8_t j = 0; j < K; j+=2) {
				u_new[i][j] = u1[i][j] + w * (u2[i][j] - u1[i][j]);
				u_new[i][j+1] = u1[i][j+1] + w * (u2[i][j+1] - u1[i][j+1]);
			}
		}

		for (uint8_t i = 0; i < N; ++i) {
			for (uint8_t j = 0; j < K; j+=2) {
				errors.push_back(fabs(u_new[i][j] - u1[i][j]));
				errors.push_back(fabs(u_new[i][j+1] - u1[i][j+1]));
			}
		}
		max_error = *std::max_element(errors.begin(), errors.end());
		//if(k%100==0)std::cout<<k<<" "<<max_error<<"\n";
		errors.clear();
		for (uint8_t i = 0; i < N; ++i) {
			for (uint8_t j = 0; j < K; j+=2) {
				u1[i][j] = u_new[i][j];
				u1[i][j+1] = u_new[i][j+1];
			}
		}
		k++;
	} while (max_error > eps);

在这里插入图片描述

  • 进行循环合并
	do {
		for (uint8_t i = 1; i < N - 1; ++i) {
			for (uint8_t j = 1; j < K - 1; ++j) {
				u1[i][j] = (1.0 / 4.0) * (u1[i - 1][j] + u1[i + 1][j] + u1[i][j - 1] + u1[i][j + 1]);
			}
		}
		for (uint8_t i = 1; i < N - 1; ++i) {
			for (uint8_t j = 1; j < K - 1; ++j) {
				u2[i][j] = (1.0 / 4.0) * (u1[i - 1][j] + u1[i + 1][j] + u1[i][j - 1] + u1[i][j + 1]);
			}
		}
		for (uint8_t i = 0; i < N; ++i) {
			for (uint8_t j = 0; j < K; ++j) {
				u_new[i][j] = u1[i][j] + w * (u2[i][j] - u1[i][j]);
				errors.push_back(fabs(u_new[i][j] - u1[i][j]));;
				u1[i][j] = u_new[i][j];
			}
		}
		max_error = *std::max_element(errors.begin(), errors.end());
		//if(k%100==0)std::cout<<k<<" "<<max_error<<"\n";
		errors.clear();
		k++;
	} while (max_error > eps);

在这里插入图片描述

  • 进行循环分裂
	do {
		for (uint8_t i = 1; i < N - 1; ++i) {
			for (uint8_t j = 1; j < 101; ++j) {
				u1[i][j] = (1.0 / 4.0) * (u1[i - 1][j] + u1[i + 1][j] + u1[i][j - 1] + u1[i][j + 1]);
			}
			for (uint8_t j = 101; j < K - 1; ++j) {
				u1[i][j] = (1.0 / 4.0) * (u1[i - 1][j] + u1[i + 1][j] + u1[i][j - 1] + u1[i][j + 1]);
			}
		}
		for (uint8_t i = 1; i < N - 1; ++i) {
			for (uint8_t j = 1; j < 101; ++j) {
				u2[i][j] = (1.0 / 4.0) * (u1[i - 1][j] + u1[i + 1][j] + u1[i][j - 1] + u1[i][j + 1]);
			}
			for (uint8_t j = 101; j < K - 1; ++j) {
				u2[i][j] = (1.0 / 4.0) * (u1[i - 1][j] + u1[i + 1][j] + u1[i][j - 1] + u1[i][j + 1]);
			}
		}
		for (uint8_t i = 0; i < N; ++i) {
			for (uint8_t j = 0; j < 100; ++j) {
				u_new[i][j] = u1[i][j] + w * (u2[i][j] - u1[i][j]);
			}
			for (uint8_t j = 100; j < K; ++j) {
				u_new[i][j] = u1[i][j] + w * (u2[i][j] - u1[i][j]);
			}
		}
		for (uint8_t i = 0; i < N; ++i) {
			for (uint8_t j = 0; j < 100; ++j) {
				errors.push_back(fabs(u_new[i][j] - u1[i][j]));;
			}
			for (uint8_t j = 100; j < K; ++j) {
				errors.push_back(fabs(u_new[i][j] - u1[i][j]));;
			}
		}
		max_error = *std::max_element(errors.begin(), errors.end());
		//if(k%100==0)std::cout<<k<<" "<<max_error<<"\n";
		errors.clear();
		for (uint8_t i = 0; i < N; ++i) {
			for (uint8_t j = 0; j < 100; ++j) {
				u1[i][j] = u_new[i][j];
			}
			for (uint8_t j = 100; j < K; ++j) {
				u1[i][j] = u_new[i][j];
			}
		}
		k++;
	} while (max_error > eps);

在这里插入图片描述

  • 循环交换+循环合并+循环展开

这里进行循环分裂与不进行循环分裂效果似乎差不多

	do {
		for (uint8_t i = 1; i < N - 1; ++i) {
			for (uint8_t j = 1; j < 101; j+=2) {
				u1[i][j] = (1.0 / 4.0) * (u1[i - 1][j] + u1[i + 1][j] + u1[i][j - 1] + u1[i][j + 1]);
				u1[i][j+1] = (1.0 / 4.0) * (u1[i - 1][j+1] + u1[i + 1][j+1] + u1[i][j] + u1[i][j + 2]);
			}
			for (uint8_t j = 101; j < K - 1; j+=2) {
				u1[i][j] = (1.0 / 4.0) * (u1[i - 1][j] + u1[i + 1][j] + u1[i][j - 1] + u1[i][j + 1]);
				u1[i][j+1] = (1.0 / 4.0) * (u1[i - 1][j+1] + u1[i + 1][j+1] + u1[i][j] + u1[i][j + 2]);
			}
		}
		for (uint8_t i = 1; i < N - 1; ++i) {
			for (uint8_t j = 1; j < 101; j+=2) {
				u2[i][j] = (1.0 / 4.0) * (u1[i - 1][j] + u1[i + 1][j] + u1[i][j - 1] + u1[i][j + 1]);
				u2[i][j+1] = (1.0 / 4.0) * (u1[i - 1][j+1] + u1[i + 1][j+1] + u1[i][j] + u1[i][j + 2]);
			}
			for (uint8_t j = 101; j < K - 1; j+=2) {
				u2[i][j] = (1.0 / 4.0) * (u1[i - 1][j] + u1[i + 1][j] + u1[i][j - 1] + u1[i][j + 1]);
				u2[i][j+1] = (1.0 / 4.0) * (u1[i - 1][j+1] + u1[i + 1][j+1] + u1[i][j] + u1[i][j + 2]);
			}
		}
		for (uint8_t i = 0; i < N; ++i) {
			for (uint8_t j = 0; j < 100; j+=2) {
				u_new[i][j] = u1[i][j] + w * (u2[i][j] - u1[i][j]);
				u_new[i][j+1] = u1[i][j+1] + w * (u2[i][j+1] - u1[i][j+1]);
				errors.push_back(fabs(u_new[i][j] - u1[i][j]));;
				errors.push_back(fabs(u_new[i][j+1] - u1[i][j+1]));;
				u1[i][j] = u_new[i][j];
				u1[i][j+1] = u_new[i][j+1];
			}
			for (uint8_t j = 100; j < K; j+=2) {
				u_new[i][j] = u1[i][j] + w * (u2[i][j] - u1[i][j]);
				u_new[i][j+1] = u1[i][j+1] + w * (u2[i][j+1] - u1[i][j+1]);
				errors.push_back(fabs(u_new[i][j] - u1[i][j]));;
				errors.push_back(fabs(u_new[i][j+1] - u1[i][j+1]));;
				u1[i][j] = u_new[i][j];
				u1[i][j+1] = u_new[i][j+1];
			}
		}
		max_error = *std::max_element(errors.begin(), errors.end());
		//if(k%100==0)std::cout<<k<<" "<<max_error<<"\n";
		errors.clear();
		k++;
	} while (max_error > eps);

在这里插入图片描述

对自己的表现是否满意

最近对传统性能优化的一些方法进行了学习，了解了传统性能优化的原理 (与计算机体系结构和缓存的关系)，通过这些优化方法程序的执行效率确实得到了显著的提高，是非常重要且实用的技术。

简述下次计划

Darknet 项目优化

其他反馈

无

鱼树C
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
国科大超算中心介绍.pdf
08-24
中国科学院大学超级计算中心介绍
深度学习与计算机视觉
06-22
[本课程属于AI完整学习路线套餐，该套餐已“硬核”上线，点击立即学习！] 【为什么要学习深度学习和计算机视觉？】 AI人工智能现在已经成为人类发展中最火热的领域。而计算机视觉（CV）是AI中最热门，也是落地最多的一个应用方向（人脸识别，自动驾驶，智能安防，车牌识别，证件识别）。所以基于人工智能的计算视觉行业必然会诞生大量的工作和创业的机会。如何能快速的进入CV领域，同时兼备理论基础和实战能力，就成了大多数学习者关心的事情，而这门课就是因为这个初衷而设计的。 【讲师介绍】 CHARLIE 老师 1、人工智能算法科学家2、深圳市海外高层次人才认定(孔雀人才)3、美国圣地亚哥国家超算中心博士后4、加利福尼亚大学圣地亚哥全奖博士5、参与美国自然科学基金(NSF)及加州能源局 (CEC)资助的392MWIVANPAH等智慧电网项目6、21篇国际期刊文章(sci收录17篇)，总引用接近10007、第一作者发明专利11份【推荐你学习这门课的理由：知识体系完整+丰富学习资料】 1、本课程总计9大章节，是一门系统入门计算机视觉的课程，未来将持续更新。 2、课程从计算机视觉理论知识出发，理论
中国超算云服务独立市场研究.pdf
04-08
中国超算云服务独立市场研究.pdf
如何在超算中心使用fluent做并行计算——入门
11-27
LSF计算环境下使用fluent做并行计算。
【超算/先进计算学习】日报1
Yv_shu的博客
04-17 900
使用C语言编写的神经网络框架支持训练和测试各种计算机视觉算法可用于进行实时物体检测1、相比于TensorFlow等具有更好的移植性2、灵活性高，可以便捷的从底层对其进行代码改进与扩展3、结构明晰，可以方便的对源代码进行查看、解读和修改4、安装简单方便，通过自带的makefile可进行附加项的选择Makefile变量中各种开关的作用GPU=0：是否使用GPU加速CUDNN=0：是否使用nvidia官方的cudnn神经网络OPENCV=0：是否使用opencv。
【超算/先进计算学习】日报3
Yv_shu的博客
04-19 706
对于一个可执行文件 saxpy.exe，通过 slurm 系统，编写 shell 脚本 yhrun.sh，通过 yhrun 命令把程序二进制文件提交到计算节点进行串行计算，使用 yhbatch 命令，提交 yhrun.sh 脚本，使程序在后台运行。今天的学习内容较少，初次了解作业管理系统slurm，感觉这种远程计算的方式还是挺新鲜的，期待之后的学习内容 (≧∇≦)ﾉ。-n：指定程序使用的总进程数目，每个节点启动约 n/N 个进程，整除。frame [n]，简写 f [n]，查看调用栈的 #n 层。
【超算/先进计算学习】日报2
Yv_shu的博客
04-18 523
现有一个程序，包含main.cpp、kernel.cpp源文件，并使用了/home/opt/路径下的第三方库mymath，其中opt路径下包含头文件./include/mymath.h和库文件./lib/libmymath.so。示例：需要编译 main.c、kernel.c 成 exe，其使用了 /home/opt/ 路径下的第三方库 math，其中 opt 目录下包含：/include/mymath.h、/lib/mymath.so。前面那个 -l 是大写的 i，后面那个 -l 是小写的 L。
【超算/先进计算学习】日报7
Yv_shu的博客
04-25 314
通过对 darknet 项目进行优化，了解了传统程序优化的基本流程，并对之前所学的内容有了很好的检验，个人认为学习阶段最终结果并不重要，重要的是掌握项目优化的思路和所用的工具。这个是 去掉 -pg 选项的执行情况，个人认为提升不是很大就没有再继续了，想要优化到极致的可以反复上述过程，不断寻找耗时长的函数对其使用尽可能多的优化手段！注意：每次对源码进行修改之后都要重新 make，加上 -pg 选项只是为了之后方便了解程序运行的详情，方便优化，但这本身会产生一定的开销，最终版需要去掉。
【超算/先进计算学习】日报4
Yv_shu的博客
04-21 737
基于块划分的方式，例如：如果有两个进程，会把一个向量的上半部分划给 P0，下半部分划给 P1，同样将矩阵的上半部分划给 P0，下半部分划给 P1，中间需要进行信息交换处会由 PETSc 自动进行管理。SpMV 优化的重点在于改良稀疏矩阵的存储结构，提升稀疏矩阵向量乘时的 Cache 命中率，并充分利用 CPU 内部硬件特性，或者多核平台来改善效率。1、如果 A 的性质不那么好，是病态的，或者主对角线上的元素很小，或者特征值很小，那么收敛起来就会非常慢。算法库：是计算领域的基础软件库，是发挥硬件算力的基石。
Fluent TUI 加载UDF 计算 超算
03-26
编写TUI的文件
【超算/先进计算学习】日报8
Yv_shu的博客
04-28 1074
在学习的第一阶段，我们首先对需要优化的程序——Darknet框架进行了了解，其具有灵活性高、结构明晰、安装简单方便等特点；rm [-rf] [filename or directoryName] 目录以及文件的删除。mv [filename] [object_directiryName] 文件/目录的移动。cp [source_filename] [dest_filename] 文件/目录的拷贝。mv [old_filename] [new_filename] 文件/目录的重命名。
【超算/先进计算学习】日报5
Yv_shu的博客
04-22 712
main函数分别调用了testfunc1函数（ 10 ）次，testfunc4函数（ 1 ）次，testfunc3函数（ 1 ）次，testfunc2函数（ 1 ）次。Gprof 是一款易用的动态分析工具，除了函数的调用关系，同时还能给出函数的调用时间分布，为我们的性能分析提供参考，快速定位程序的热点函数位置。今天主要对程序性能分析的概念和常用工具进行了了解，并使用 gprof 对一些简单程序进行了分析和解读，还是挺有收获的。静态分析，即利用代码静态分析工具，对代码进行数据对象、函数接口封装和调用分析。
郑州计算机未来发展,郑州开建国内第七个国家超算中心 配10亿亿次自主超算
weixin_32691823的博客
06-30 288
从2018年上半年开始，IBM、NVIDIA研发的Summit超算取代中国的神威·太湖之光成为TOP500超算冠军，并且蝉联了两次冠军，预计今年上半年依然是冠军。在Summit超算之前，中国的天河2号、太湖之光两台超算接力把持了TOP500十连冠，这期间也是国内超算大发展的时期，国内陆续建设了6个国家级超算中心。国内已有的国家级超算中心分别是国家超级计算天津中心、国家超级计算长沙中心、国家超级计算...
神威太湖之光——世界超算冠军
c198038的博客
10-11 5847
学号：16340022 【数据科学与计算机学院】 http://sdcs.sysu.edu.cn/ 在每年6月和11月发布的超级计算机排行榜上，“天河二号”自2013年至去年连续六次排名第一。而在今年六月发布的榜单上，由国家并行计算机工程技术研究中心研制的超级计算机“神威太湖之光”以超第二名“天河二号”近三倍的运算速度夺得第一，也成为世界上首台运算速度超过十亿亿次的超级计算机。 目录榜单
FME学习之旅---day27
最新发布
summer_corner的博客
05-17 195
我们付出一些成本，时间的或者其他，最终总能收获一些什么。
使用多实例学习进行乳腺癌组织病理学图像分类和定位
qq_47896523的博客
05-16 1096
乳腺癌是女性最主要的死亡原因，病理学家根据病理切片中观察到的各种视觉特征（例如细胞核的形态特征、细胞核的微观和宏观结构等）做出决定。计算机辅助诊断（CAD）系统可以帮助病理学家自动做出决策。卷积神经网络是最广泛使用的深度学习框架，用于学习图像类别之间的复杂判别特征。多年来，VGG16 [3] 和 ResNet18 [4] 等各种 CNN 架构在海量 ImageNet 数据集上产生了出色的结果。CNN 被用于医学图像以产生最先进的结果。为图像中存在的所有类别提供了定位信息。
微信小程序学习（第八章作业）
weixin_74181724的博客
05-13 575
留言板是一款能实现浏览留言、发表留言、删除留言和编辑留言的小程序，用户能够浏览当前的已留言内容，并且能按照时间的升序来查看最新的留言内容;能够发表自己的留言内容，在留言发表页填写相关项后即可发表，并能查看到新留言内容;能够删除不需要的留言;能够修改留言内容。因此，简单留言板的功能主要为显示留言、发表留言删除留言和编辑留言。
WEB转Flutter基础学习笔记（内含vue和flutter对比）
小易不止于搬砖的博客
05-17 670
笔者是一名web前端，记录在转栈flutter时的学习笔记，内涵和vue的对比，能够辅助前端同学更容易理解flutter
超算并列计算matlab
08-11
通过并列计算，可以将Matlab的计算任务划分成多个子任务，并在超算的多个计算节点上同时进行计算。这样可以充分利用超级计算机的并行计算能力，提高计算速度和效率。并且，超级计算机通常配备了大容量的内存和高速的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

鱼树C

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值