什么？你说这些东西没用？
那你就大错特错了。WC考过的东西怎么可能没用
开O2之后FFT会比不开快几倍
不开O2：NTT比FFT快
开O2：FFT比NTT快
常数尽量声明成常量
有一道NTT的题，模数声明成变量跑了\(1166\)ms，模数声明成常量跑了不到\(300\)ms
//6s
const int p=10;
int main()
{
open("orzzjt");
int a;
scanf("%d",&a);
int i;
for(i=1;i<=1000000000;i++)
a=(a*a+10)%p;
printf("%d\n",a);
return 0;
}//10s
int p=10;
int main()
{
open("orzzjt");
int a;
scanf("%d",&a);
int i;
for(i=1;i<=1000000000;i++)
a=(a*a+10)%p;
printf("%d\n",a);
return 0;
}能用位运算尽量用位运算
当然，编译器大多数情况下会帮你优化掉。
少用除法和取模
加法运算只要\(1\)个时钟周期，乘法运算只要\(3\)个时钟周期，而除法和取模运算要几到几十个时钟周期。
\(3\times 3\)的矩阵乘法：边加边取模：\(27\)次取模运算；全部算完再取模：\(9\)次取模运算。
优化高位数组的寻址
用指针保存上一次使用的地址，直接加偏移。
对于一个值的重复运算，存入临时变量中
消除条件跳转
a：对于适合分治预测的数据，测得平均一次循环需要\(4.0\)个时钟周期；对于随机数据，测得平均一次循环需要\(12.8\)个时钟周期。可见，分支预测错误的惩罚为\(2\times (12.8-4.0)=17.6\)个时钟周期。
b：用三元运算符重写，让编译器生成一种基于条件传送的汇编代码。测得不论数据如何，平均一次循环只需要\(4.1\)个时钟周期。
//a.cpp
void minmax1(int *a,int *b,int n)
{
for(int i=1;i<=n;i++)
if(a[i]>b[i])
{
int t=a[i];
a[i]=b[i];
b[i]=t;
}
}//b.cpp
void minmax2(int *a,int *b,int n)
{
for(int i=1;i<=n;i++)
{
int mi=a[i]<b[i]?a[i]:b[i];
int ma=a[i]<b[i]?b[i]:a[i];
a[i]=mi;
b[i]=ma;
}
}循环展开
a：平均每个元素需要\(3.65\)个时钟周期。
b：平均每个元素需要\(1.36\)个时钟周期。
这样能够刺激CPU并行。
当展开次数过多时，性能反而会下降，因为寄存器不够用\(\longrightarrow\)寄存器溢出
注意每部分要独立以及处理非展开次数的倍数的部分
//a.cpp
double sum(double *a,int n)
{
double s=0;
for(int i=1;i<=n;i++)
{
s+=a[i];
}
return s;
}//b.cpp
double sum(double *a,int n)
{
double s0=0,s1=0,s2=0,s3=0;
for(int i=1;i<=n;i+=4)
{
s0+=a[i];
s1+=a[i+1];
s2+=a[i+2];
s3+=a[i+3];
}
return s0+s1+s2+s3;
}编写缓存友好的代码
空间局部性好
尽量使用步长为\(1\)的访问模式，即访问的内存是连续的。
在遍历高维数组是很重要
时间局部性好
是内存访问的工作集尽量小
在统计整数二进制表示中\(1\)的个数时，分两段查表有时不如分三段好。
避免使用步长为较大的\(2\)的幂的访问模式
避免缓存冲突。
在状压DP、使用高位数组时很重要
解决方法：把数组稍微开大一些
一些数据
| 类型 | 延迟（周期数） |
|---|---|
| CPU寄存器 | \(0\) |
| TLB | \(0\) |
| L1高速缓存 | \(4\) |
| L2高速缓存 | \(10\) |
| L3高速缓存 | \(50\) |
| 虚拟内存 | \(200\) |
在某Intel Core i5 CPU上，有这些高速缓存：
| 高速缓存类型 | 访问时间（周期） | 高速缓存大小 | 相联度 | 块大小 | 组数 |
|---|---|---|---|---|---|
| L1 I-Cache | \(4\) | \(32\)KB | \(8\) | \(64\)B | \(64\) |
| L1 D-Cache | \(4\) | \(32\)KB | \(8\) | \(64\)B | \(64\) |
| L2 Cache | 约\(12\) | \(256\)KB | \(4\) | \(64\)B | \(512\) |
| L3 Cache | 约\(50\) | \(6\)MB | \(12\) | \(64\)B | \(8192\) |
对于不同的\(n\)和\(d\)，反复调用这个程序，具有不同的时空局部性。
容易得知，\(n\)越小，时间局部性越好，\(d\)越小，空间局部性越好。
int sum(int *a,int n,int d)
{
int s=0;
for(int i=0;i<n;i++)
s+=a[i*d];
return s;
}空间局部性
\(n\)足够大时结果如下
与理论相符
| \(d\) | \(1\) | \(2\) | \(3\) | \(4\) | \(8\) | \(16\) | \(32\) | \(64\) |
|---|---|---|---|---|---|---|---|---|
| 周期数 | \(1.50\) | \(2.34\) | \(3.46\) | \(4.73\) | \(9.70\) | \(15.00\) | \(19.76\) | \(20.26\) |
时间局部性
\(n=200\)时结果如下
| \(d\) | \(2^{19}\) | \(2^{19}+1\) |
|---|---|---|
| 周期数 | \(159\) | \(1.18\) |
这是为什么呢？
\(200\)个整数，显然能在L1缓存装得下？
对于\(d=2^{19}\)，每次内存访问时，地址的后\(19\)位都是一样的。
根据CPU高速缓存的原理，这些地址必然会被映射到同一个组
因此，缓存只有一组，\(159\)周期就是内存访问速度。
p.s.：后\(19\)位一样的是虚拟地址，在映射成物理地址之后，由于操作系统的特性，也至少有后\(12\)位是一样的。
原文地址：https://www.cnblogs.com/ywwyww/p/8511463.html