如何改善/加快这种频繁的功能？
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define M 10 // This is fixed
#define N 8 // This is NOT fixed
// Assumptions: 1. x, a, b and c are all arrays of 10 (M).
// 2. y and z are all matrices of 8 x 10 (N x M).
// Requirement: 1. return the value of ret;
// 2. get all elements of array c
float fnFrequentFunction(const float* x, const float* const* y, const float* const* z,
const float* a, const float* b, float *c, int n)
{
register float tmp;
register float sum;
register float ret = 0;
register const float* yy;
register const float* zz;
int i;
for (i = 0; i < n; i++) // M == 1, 2, 4, or 8
{
sum = 0;
yy = y[i];
zz = z[i];
tmp = x[0] - yy[0]; sum += tmp * tmp * zz[0];
tmp = x[1] - yy[1]; sum += tmp * tmp * zz[1];
tmp = x[2] - yy[2]; sum += tmp * tmp * zz[2];
tmp = x[3] - yy[3]; sum += tmp * tmp * zz[3];
tmp = x[4] - yy[4]; sum += tmp * tmp * zz[4];
tmp = x[5] - yy[5]; sum += tmp * tmp * zz[5];
tmp = x[6] - yy[6]; sum += tmp * tmp * zz[6];
tmp = x[7] - yy[7]; sum += tmp * tmp * zz[7];
tmp = x[8] - yy[8]; sum += tmp * tmp * zz[8];
tmp = x[9] - yy[9]; sum += tmp * tmp * zz[9];
ret += (c[i] = log(a[i] * b[i]) + sum);
}
return ret;
}
// In the main function, all values are just example data.
int main()
{
float x[M] = {0.001251f, 0.563585f, 0.193304f, 0.808741f, 0.585009f, 0.479873f, 0.350291f, 0.895962f, 0.622840f, 0.746605f};
float* y[N];
float* z[N];
float a[M] = {0.870205f, 0.733879f, 0.711386f, 0.588244f, 0.484176f, 0.852962f, 0.168126f, 0.684286f, 0.072573f, 0.632160f};
float b[M] = {0.871487f, 0.998108f, 0.798608f, 0.134831f, 0.576281f, 0.410779f, 0.402936f, 0.522935f, 0.623218f, 0.193030f};
float c[N];
float t1[M] = {0.864406f, 0.709006f, 0.091433f, 0.995727f, 0.227180f, 0.902585f, 0.659047f, 0.865627f, 0.846767f, 0.514359f};
float t2[M] = {0.866817f, 0.581347f, 0.175542f, 0.620197f, 0.781823f, 0.778588f, 0.938688f, 0.721610f, 0.940214f, 0.811353f};
int i, j;
int n = 10000000;
long start;
// Initialize y, z for test example:
for(i = 0; i < N; ++i)
{
y[i] = (float*)malloc(sizeof(float) * M);
z[i] = (float*)malloc(sizeof(float) * M);
for(j = 0; j < M; ++j)
{
y[i][j] = t1[j] * j;
z[i][j] = t2[j] * j;
}
}
// Speed test here:
start = clock();
while(--n)
fnFrequentFunction(x, y, z, a, b, c, 8);
printf("Time used: %ld\n", clock() - start);
// Output the result here:
printf("fnFrequentFunction == %f\n", fnFrequentFunction(x, y, z, a, b, c, 8));
for(j = 0; j < N; ++j)
printf(" c[%d] == %f\n", j, c[j]);
printf("\n");
// Free memory
for(j = 0; j < N; ++j)
{
free(y[j]);
free(z[j]);
}
return 0;
}
欢迎任何建议： - ）
我觉得我的功能犯了很大的错误。上面的代码是新的代码。我现在正在重新检查以确保这是我需要的。
答案 0 :(得分：13)
把它放在循环之外
sum = 0;
tmp = x[0] - y[0]; sum += tmp * tmp * z[0];
tmp = x[1] - y[1]; sum += tmp * tmp * z[1];
tmp = x[2] - y[2]; sum += tmp * tmp * z[2];
tmp = x[3] - y[3]; sum += tmp * tmp * z[3];
tmp = x[4] - y[4]; sum += tmp * tmp * z[4];
tmp = x[5] - y[5]; sum += tmp * tmp * z[5];
tmp = x[6] - y[6]; sum += tmp * tmp * z[6];
tmp = x[7] - y[7]; sum += tmp * tmp * z[7];
tmp = x[8] - y[8]; sum += tmp * tmp * z[8];
tmp = x[9] - y[9]; sum += tmp * tmp * z[9];
答案 1 :(得分：2)
sum变量的依赖链。而不是单个sum累加器，交替使用两个累加器sum1和sum2 - 一个用于偶数，一个用于奇数索引。之后再添加它们。log()功能。检查近似值是否足够。计算也可以进行矢量化 - 我相信英特尔发布了一个高性能的数学库 - 包括像log()这样的函数的矢量化版本。你可能想用这个。float处开始操作，log()使用double精度。请改用logf()。它可能（或可能不）更快。它肯定不会慢。restrict限定符。这告诉编译器这些数组不重叠，可能有助于它生成更高效的代码。所以，要把它放在一起，这就是函数应该是这样的。这是便携式C99。使用特定于编译器的SIMD内在函数，可以使WAAAAY更快。
更新：请注意，我更改了输入矩阵的定义方式。矩阵是单个大型数组。
float fnFrequentFunction(const float *restrict x, const float *restrict y,
const float *restrict z, const float *restrict a,
const float *restrict b, float *restrict c, int n)
{
float ret = 0;
const float *restrict yy = y; //for readability
const float *restrict zz = z; // -||-
for (int i = 0; i < n; i++, yy += M, zz += M) // n == 1, 2, 4, or 8
{
float sum = 0;
float sum2 = 0;
for(int j = 0; j < 10; j += 2)
{
float tmp = x[j] - yy[j]; sum += tmp * tmp * zz[j];
float tmp2 = x[j+1] - yy[j+1]; sum2 += tmp2 * tmp2 * zz[j+1];
}
sum += sum2;
ret += (c[i] = logf(a[i] * b[i]) + sum);
}
return ret;
}
答案 2 :(得分：1)
使用memoization缓存结果。这是时间/空间权衡优化。
使用 memoize 包在Perl中执行此操作非常容易，可能还有很多其他动态语言。在C中，你需要自己动手。
使用包装函数创建参数的哈希值并使用它来检查值是否已经计算过。如果有，请退货。如果没有，则传递给原始函数并缓存返回的结果。
或者，您可以在程序启动时预先计算查找表，或者甚至计算一次，然后根据您的需要保留它。
答案 3 :(得分：0)
上述强度降低tmp值的建议是正确的。我甚至可以考虑将这10行放入他们自己的for循环中，因为这可以提高代码缓存效率。
除此之外，您还要开始了解您想要了解的目标处理器类型。如果它具有本机SIMD支持，FPU，它使用什么样的缓存等。还取决于通过寄存器传递多少参数，通过组合成单个结构并通过引用传递来减少参数可能会给你一个小的提升。将vars声明为注册可能会有所帮助，也可能没有帮助。再次分析和检查汇编器输出将回答这个问题。
由于在循环之前已知总和，因此您可以在循环之后添加M *其值以进行提升。只留下2 log muls在里面。
如果M总是为8或者有其他已知模式，你可以进行一些小的循环展开，但是对于日志调用，那里的增益几乎为零。
唯一需要注意的主要事情是log（）。这是如何实现的？如果您的输入范围已知，您是否可以通过表查找滚动自己更快的版本。更好的是，如果有足够的RAM可用，请列出日志产品。
只是一些想法。
答案 4 :(得分：0)
您是否使用编译器优化？
在变量复制之前注册现代编译器。如果将它们与编译器优化一起使用，甚至可能会损害编译器性能。例如gcc simple compilation提供：
Time used: 8720000
没有寄存器浮动：
Time used: 8710000
我知道这并不多。
我假设你做了所有这些总和以避免for循环，因为你认为这要慢得多。它不是。现代编译器也会为您进行优化。
我认为一个很大的优化就是使用一个表来记录日志，如果你不介意记忆，那就会更快，只有当你超出范围时才使用日志。
答案 5 :(得分：0)
我想知道如果按比例缩放而不是花车可能会加快速度。我不知道数据范围，所以我不知道这是否可能
答案 6 :(得分：0)
除了Andrey的答案，你可以在循环中添加一些预取：
float fnFrequentFunction(const float* x, const float* y, const float* z,
const float *a, const float *b, float *c, int M)
{
register float tmp;
register float sum;
register float ret = 0;
int i;
sum = 0;
tmp = x[0] - y[0]; sum += tmp * tmp * z[0];
tmp = x[1] - y[1]; sum += tmp * tmp * z[1];
tmp = x[2] - y[2]; sum += tmp * tmp * z[2];
tmp = x[3] - y[3]; sum += tmp * tmp * z[3];
tmp = x[4] - y[4]; sum += tmp * tmp * z[4];
tmp = x[5] - y[5]; sum += tmp * tmp * z[5];
tmp = x[6] - y[6]; sum += tmp * tmp * z[6];
tmp = x[7] - y[7]; sum += tmp * tmp * z[7];
tmp = x[8] - y[8]; sum += tmp * tmp * z[8];
tmp = x[9] - y[9]; sum += tmp * tmp * z[9];
for (i = 0; i < M; i++) // M == 1, 2, 4, or 8
{
//----------------------------------------
// Prefetch data into the processor's cache
//----------------------------------------
float a_value = a[i];
float b_value = b[i];
float c_value = 0.0;
//----------------------------------------
// Calculate using prefetched data.
//----------------------------------------
c_value = log(a_value * b_value) + sum;
c[i] = c_value;
ret += c_value;
}
return ret;
}
您也可以尝试展开循环：
float a_value = 0.0;
float b_value = 0.0;
float c_value = 0.0;
--M;
switch (M)
{
case 7:
a_value = a[M];
b_value = b[M];
c_value = log(a_value * b_value) + sum;
c[M] = c_value;
ret += c_value;
--M;
case 6:
a_value = a[M];
b_value = b[M];
c_value = log(a_value * b_value) + sum;
c[M] = c_value;
ret += c_value;
--M;
case 5:
a_value = a[M];
b_value = b[M];
c_value = log(a_value * b_value) + sum;
c[M] = c_value;
ret += c_value;
--M;
case 4:
a_value = a[M];
b_value = b[M];
c_value = log(a_value * b_value) + sum;
c[M] = c_value;
ret += c_value;
--M;
case 3:
a_value = a[M];
b_value = b[M];
c_value = log(a_value * b_value) + sum;
c[M] = c_value;
ret += c_value;
--M;
case 2:
a_value = a[M];
b_value = b[M];
c_value = log(a_value * b_value) + sum;
c[M] = c_value;
ret += c_value;
--M;
case 1:
a_value = a[M];
b_value = b[M];
c_value = log(a_value * b_value) + sum;
c[M] = c_value;
ret += c_value;
--M;
case 0:
a_value = a[M];
b_value = b[M];
c_value = log(a_value * b_value) + sum;
c[M] = c_value;
ret += c_value;
break;
}
查看展开的版本，您可以从“循环”中取出“+ sum”并将其添加到最后：
ret += (M + 1) * sum;
因为sum没有改变。
最后，另一种方法是一次执行所有乘法，然后进行所有log计算，然后总结所有内容：
float product[8];
for (i = 0; i < M; ++i)
{
product[i] = a[i] * b[i];
}
for (i = 0; i < M; ++i)
{
c[i] = log(product);
ret += c[i];
}
ret += M * sum;
答案 7 :(得分：0)
如果你在a和b没有改变的情况下多次调用它，那么将a和b组合成logab，其中logab [i] = log（a [i] * b [i]）因为a和b没有被使用其他任何地方。
答案 8 :(得分：0)
这似乎是高斯混合模型计算。几年前，我致力于优化同一算法，该算法被用作语音处理程序的一部分。我调查了一些像你试图做的优化，但从未发现任何使用直接C获得超过百分之几的优势。我最大的收获来自使用SIMD指令重新编码基本GMM内核。由于仍未提供我所寻求的性能，下一步（也是最后一步）是使用Nvidia GPU。这种方式很有效，但编程本身就很令人头疼。
很抱歉，我不能提供更多帮助，但如果您坚持使用常规CPU，我认为您不会仅仅获得额外的速度。