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

news2024/11/23 18:44:50

目录

  • 今日已完成任务列表
  • 遇到的问题及解决方案
  • 任务完成详细笔记
    • 传统性能优化
      • 从体系结构角度理解四种计算优化途径-主频/缓存/流水线/超标量
      • 优化途径的有效适用条件
      • 存储墙与层次式存储结构
      • 数据局部性与cache
      • 循环合并
      • 循环展开
      • 循环交换
      • 循环分布
      • 循环不变量外提
      • 循环分块
      • 循环分裂
    • 优化 jacobi 程序
  • 对自己的表现是否满意
  • 简述下次计划
  • 其他反馈

今日已完成任务列表

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 项目优化

其他反馈

无

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/457263.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

zabbix环境准备

zabbix环境准备

zabbix基础设置(运维笔记) 准备三台主机配置主机名hostnamectl set-hostname --static zabbixserver.cluster.comvi /etc/hosts192.168.126.143 zabbixserver.cluster.com 192.168.126.142 agent1.cluster.com 192.168.126.141 agent2.cluster.com三台机器同步时间 ntpdate…
阅读更多...
springboot中统一功能处理浅析

springboot中统一功能处理浅析

在springboot工程中实现统一功能的处理&#xff0c;主要分析以下3个统一功能场景&#xff1a; 1、统一用户登录权限验证 2、统一数据格式返回 3、统一异常处理 1、统一用户登录权限验证 用户登录权限验证从最初每个方法中自己验证用户登录权限&#xff0c;逐步发展到进行统一用…
阅读更多...
[HDU - 4578]Transformation（线段树+多重懒标记）

[HDU - 4578]Transformation（线段树+多重懒标记）

[HDU - 4578]Transformation&#xff08;线段树多重懒标记&#xff09; 一、问题二、分析1、节点定义2、pushup3、pushdown&#xff08;1&#xff09;每种标记如何下传&#xff1f;赋值乘法加法 &#xff08;2&#xff09;三种标记下传的优先级问题 三、代码 一、问题 二、分析…
阅读更多...
object.assgin,事件，screen。client,offset ，http等

object.assgin,事件，screen。client,offset ，http等

js进阶-对象和BOM-day02 今日学习目标 对象进阶&#xff08;***&#xff09; Date时间对象&#xff08;了解&#xff09; BOM对象&#xff08;location对象 history对象&#xff09; 1、对象进阶Object内置方法 1、Object.assign&#xff08;** ***&#xff09; 作用&#xf…
阅读更多...
GPT3.5, InstructGPT和ChatGPT的关系

GPT3.5, InstructGPT和ChatGPT的关系

GPT-3.5 GPT-3.5 系列是一系列模型&#xff0c;从 2021 年第四季度开始就使用文本和代一起进行训练。以下模型属于 GPT-3.5 系列&#xff1a; code-davinci-002 是一个基础模型&#xff0c;非常适合纯代码完成任务text-davinci-002 是一个基于 code-davinci-002 的 InstructG…
阅读更多...
【 动态SQL 的使⽤ 】

【 动态SQL 的使⽤ 】

文章目录 一、动态 SQL 是什么二、动 态 SQL 标签2.1 < if >标签2.2 < trim >标签2.3 < where >标签2.4 < set >标签2.5 < foreach >标签 一、动态 SQL 是什么 Mybatis 动态 sql 可以让我们在 Xml 映射文件内&#xff0c;以标签的形式编写动态 …
阅读更多...
【多微电网】含多微电网租赁共享储能的配电网博弈优化调度（Matlab代码实现）

【多微电网】含多微电网租赁共享储能的配电网博弈优化调度（Matlab代码实现）

&#x1f4a5; &#x1f4a5; &#x1f49e; &#x1f49e; 欢迎来到本博客 ❤️ ❤️ &#x1f4a5; &#x1f4a5; &#x1f3c6; 博主优势&#xff1a; &#x1f31e; &#x1f31e; &#x1f31e;博客内容尽量做到思维缜密&#xff0c;逻辑清晰&#xff0c;为了方便读者。 …
阅读更多...
计算机办公自动化——Python批量生成请假条

计算机办公自动化——Python批量生成请假条

Python使用openpyxl、docx批量生成请假条 前言第三方库的安装示例代码运行效果 前言 加入你有一个下图所示的表格&#xff0c;需要批量生成他们的请假条&#xff0c;你会选择如何做呢&#xff1f;是一步一步的手打&#xff0c;还是呼唤请假人手打呢&#xff1f; 下面我们来看…
阅读更多...
STM32学习，从点灯开始

STM32学习，从点灯开始

大家好&#xff0c;我是程序员小哈。 综合实例&#xff1a;自动洗碗机的分享&#xff0c;上周五的直播完成了核心板的焊接&#xff0c;板子设计好了&#xff0c;也焊接完毕了&#xff0c;那么如何验证是否正确呢&#xff0c;既然是从0到1的教程&#xff0c;那么我们就先实现一…
阅读更多...
PyTorch深度学习实战 | 基于深度学习的电影票房预测研究

PyTorch深度学习实战 | 基于深度学习的电影票房预测研究

基于深度学习的映前票房预测模型(Cross&Dense网络结构模型)&#xff0c;该模型通过影片基本信息如&#xff1a;电影类型、影片制式、档期和电影的主创阵容和IP特征等信息对上映影片的票房进行预测。 本篇采用451部电影作为训练模型&#xff0c;最后再在194部影片上进行测试…
阅读更多...
Spring AOP实现原理

Spring AOP实现原理

从入口 org.springframework.context.support.AbstractApplicationContext#refresh 开始看 找到Bean的创建方法进入: 再进入详细方法: 找到getBean(beanName)&#xff1a; 找到doGetBean(xxx,xxx,xxx,xxx); 找到实际的Bean创建方法createBean(beanName, mdb, args);可以非常明显…
阅读更多...
【C++学习笔记】变量和基本类型

【C++学习笔记】变量和基本类型

2.1 基本内置类型 C中包括 算数类型(arithmetic type) 和 空类型(void) 的数据类型&#xff0c;其中&#xff0c;算数类型包括字符、整型数、布尔值和浮点数&#xff1b;空类型不对应具体的值&#xff0c;当函数不返回值时用void作为返回类型 2.1.1算数类型 对于数组或者字符…
阅读更多...
一篇搞定CDH 5.x 核心概念与集群部署

一篇搞定CDH 5.x 核心概念与集群部署

一、概述 1.1 Hadoop发行商 Apache:开源免费 CDH: Clouder公司研发。只支持64位操作系统。更加详细信息后面会介绍。 HDP: Hortonworks公司研发。 1.2 公司常用版本及介绍 apache -> cdh | hdp 常见问题&#xff1a; apache与cdh的比较&#xff1f;&#xf…
阅读更多...
在国内怎么玩chatgpt，有可行的gpt游玩攻略么

在国内怎么玩chatgpt，有可行的gpt游玩攻略么

首先你想玩chatgpt&#xff0c;你要明白一点这是一个国外的软件&#xff0c;所以你懂的&#xff0c;如果你不会魔法&#xff0c;那么就必须要改其他途径去探索游玩咯。今天我们就来探讨一下国内怎么玩chatgpt&#xff0c;可行的gpt游玩攻略。 一.Chatgpt的版本 我们先来认识一…
阅读更多...
61 openEuler 22.03-LTS 搭建MySQL数据库服务器-管理数据库用户

61 openEuler 22.03-LTS 搭建MySQL数据库服务器-管理数据库用户

文章目录 61 openEuler 22.03-LTS 搭建MySQL数据库服务器-管理数据库用户61.1 创建用户示例 61.2 查看用户示例 61.3 修改用户61.3.1 修改用户名61.3.2 修改用户示例61.3.3 修改用户密码61.3.4 修改用户密码示例 61.4 删除用户示例 61.5 用户授权示例 61.6 删除用户权限示例 61…
阅读更多...
看完这篇文章你就彻底懂啦｛保姆级讲解｝-----（面试刷题链表相交） 2023.4.24

看完这篇文章你就彻底懂啦｛保姆级讲解｝-----（面试刷题链表相交） 2023.4.24

目录 前言面试题&#xff08;链表相交&#xff09;—&#xff08;保姆级别讲解&#xff09;分析题目&#xff1a;链表相交代码&#xff1a;算法思想 结束语 前言 本文章一部分内容参考于《代码随想录》----如有侵权请联系作者删除即可&#xff0c;撰写本文章主要目的在于记录自…
阅读更多...
LVS负载均衡—DR模式

LVS负载均衡—DR模式

DR模式的特点 &#xff08;1&#xff09;Director Server&#xff08;调度器&#xff09; 和 Real Server&#xff08;节点服务器&#xff09; 必须在同一个物理网络中。 &#xff08;2&#xff09;Real Server可以使用私有地址&#xff0c;也可以使用公网地址。如果使用公网…
阅读更多...
零代码平台如何帮助服装企业实现数字化转型？

零代码平台如何帮助服装企业实现数字化转型？

随着互联网的不断发展&#xff0c;数字化转型已经成为各行各业必须跨越的一道坎&#xff0c;而服装行业也不例外。 但是&#xff0c;服装行业相对于其他行业来说&#xff0c;数字化转型面临着更多的挑战&#xff1a; 生产环节复杂&#xff1a;服装制造涉及到复杂的生产工序&a…
阅读更多...
问题定位及解决方案

问题定位及解决方案

1.视频沉浸页快速滑动后&#xff0c;必现不能向下划动 复现步骤&#xff1a; 进入视频沉浸页&#xff0c;快速向下划动&#xff0c;滑动到第一页最后一个时&#xff0c;不能再向下划动。 解决步骤&#xff1a; 1.确定请求API&#xff1a; mtop.aliexpress.ugc.feed.video.lis…
阅读更多...
Vivado关联第三方编辑器的方法

Vivado关联第三方编辑器的方法

​Vivado是一个非常强大的工具&#xff0c;但是在一些方面可能不能完全满足我们的需求&#xff0c;比如代码编辑器的功能。幸运的是&#xff0c;Vivado允许我们关联第三方编辑器来扩展其代码编辑器的功能。在本文将介绍如何配置Vivado与第三方编辑器一起使用&#xff0c;并提供…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023