在使用 C/C + + 编写嵌入式系统和代码的情况下，我尽量避免使用 动态内存分配动态内存分配。我这样做的主要原因不一定是性能，但是这个经验法则确实有性能影响。

用于管理堆的算法在某些平台(例如 vxworks)上非常慢。更糟糕的是，从调用 malloc 返回所需的时间高度依赖于堆的当前状态。因此，任何调用 malloc 的函数都会受到不容易解释的性能影响。如果堆仍然是干净的，但是在设备运行一段时间之后，堆可能会变得支离破碎，那么性能损失可能是最小的。这些调用将花费更长的时间，而且您无法轻易计算出性能将如何随着时间的推移而下降。你不可能真的做出一个更糟糕的情况估计。在这种情况下，优化器也不能为您提供任何帮助。更糟糕的是，如果堆变得过于碎片化，那么调用将开始完全失败。解决方案是使用内存池(例如 油嘴滑舌的切片)而不是堆。如果处理得当，分配调用将会更快，并且具有确定性。

你在这里得到了很好的答案，但是他们假设你的程序从一开始就非常接近最优，然后你说

假设程序已经 编写正确，编译完整 优化，测试和投入 制作。

根据我的经验，一个程序可能编写正确，但这并不意味着它接近最优。要做到这一点需要付出额外的努力。

If I can give an example, 这个答案 shows how a perfectly reasonable-looking program was made over 40 times faster by 宏观优化. Big speedups can't be done in 每个 program as first written, but in many (except for very small programs), it can, in my experience.

在这之后，micro-optimization(热点)可以给你一个很好的回报。

i use intel compiler. on both Windows and Linux.

当我或多或少完成了我的代码配置文件。然后挂在热点和尝试改变代码，让编译器作出更好的工作。

如果一个代码是计算性的，并且包含大量的循环-英特尔编译器中的向量化报告是非常有用的-在帮助中寻找“ vec-report”。

所以主要的思想是——润色性能关键代码。至于其余的-优先权是正确的和可维护的-短的功能，明确的代码，可以理解1年后。

在80年代的 cobol 中，我依稀记得的一件事是，有一些链接选项，可以让你按照函数链接在一起的顺序进行操作。这允许您(可能)增加代码局部性。

沿着同样的想法。如果有疑问，如果一个可能的优化可以通过使用模式

for (some silly loop)
if (something)
if (somthing else)
if (somthing else)
if (somthing else)
/* This is the normal expected case */
else error 4
else error 3
else error 2
else error 1

For 头和 if 可能适合一个缓存块, 理论上可以导致更快的循环执行。

我猜想其他类似的东西可以在某种程度上被优化。

有意见吗？ 我是在做梦吗？

One optimization i have used in C++ is creating a constructor that does nothing. One must manually call an init() in order to put the object into a working state.

在我需要这些类的大型向量的情况下，这样做是有好处的。

我调用 reserve ()为向量分配空间，但是构造函数实际上并没有触及对象所在的内存页面。因此，我花费了一些地址空间，但实际上并没有消耗大量的物理内存。我避免了页面错误相关的相关建设成本。

当我生成对象来填充向量时，我使用 init ()来设置它们。这限制了页面错误的总数，并避免了在填充向量时调整()大小的需要。

当 DEC 推出 alpha 处理器时，有人建议将函数的参数数量保持在7以下，因为编译器总是试图在寄存器中自动放置最多6个参数。

我在上面的列表中没有看到的两种编码技术:

通过编写作为唯一源代码的代码绕过链接器

虽然单独的编译对于编译时间来说是非常好的，但是当您谈到优化时，它是非常糟糕的。基本上编译器不能优化超出编译单元，即链接器保留域。

但是如果你设计好了你的程序，你也可以通过一个独特的通用源来编译它。也就是说，不再编译 unit1.c 和 unit2.c，然后链接两个对象，而是编译 all.c，其中只包含 unit1.c 和 unit2.c。因此，您将受益于所有的编译器优化。

It's very like writing headers only programs in C++ (and even easier to do in C).

如果您从一开始就编写程序来启用它，那么这项技术就足够简单了，但是您还必须意识到它改变了 C 语义的一部分，并且您可能会遇到一些问题，比如静态变量或宏冲突。对于大多数程序来说，克服发生的小问题是很容易的。还要注意，作为唯一源进行编译要慢得多，而且可能占用大量内存(现代系统通常不会出现这种问题)。

使用这个简单的技术，我碰巧使我写的一些程序快了十倍！

与 register 关键字一样，这个技巧也可能很快就会过时。编译器 Gcc: 链接时间优化开始支持通过链接器进行优化。

在循环中分离原子任务

这个更棘手。它是关于算法设计和优化器管理缓存和寄存器分配的方式之间的交互。程序经常需要遍历一些数据结构，并对每个项执行一些操作。所执行的操作通常可以在两个逻辑上独立的任务之间进行分割。如果是这种情况，您可以编写完全相同的程序，在相同的边界上使用两个循环执行完全相同的任务。在某些情况下，这样写可能比唯一循环更快(细节更复杂，但可以解释的是，在简单的任务情况下，所有变量都可以保存在处理器寄存器中，而在更复杂的情况下，这是不可能的，一些寄存器必须写入内存并在以后读取回来，成本高于额外的流控制)。

小心这一个(配置文件性能使用此技巧或没有) ，因为像使用寄存器，它可能会给较少的性能比改进的。

尝试尽可能多地使用静态单一赋值编程。SSA 与大多数函数式编程语言中的结果完全相同，而且大多数编译器都会将代码转换为 SSA 来进行优化，因为它更容易使用。通过这样做，编译器可能会混淆的地方被揭示出来。除了最差的寄存器分配器之外，它还可以让所有的寄存器分配器和最好的寄存器分配器一样好用，并且可以让你更容易地进行调试，因为你几乎不需要考虑变量的值是从哪里来的，因为它只被分配到了一个地方。
避免全局变量。

当通过引用或指针处理数据时，将其拉入局部变量，完成工作，然后将其复制回来。(除非你有充分的理由不这样做)

Make use of the almost free comparison against 0 that most processors give you when doing math or logic operations. You almost always get a flag for ==0 and <0, from which you can easily get 3 conditions:

x= f();
if(!x){
a();
} else if (x<0){
b();
} else {
c();
}

几乎总是比测试其他常量便宜。

另一个技巧是使用减法来消除范围测试中的一个比较。

#define FOO_MIN 8
#define FOO_MAX 199
int good_foo(int foo) {
unsigned int bar = foo-FOO_MIN;
int rc = ((FOO_MAX-FOO_MIN) < bar) ? 1 : 0;
return rc;
}

这通常可以避免在布尔表达式上进行短路的语言中出现跳转，并避免编译器必须试图弄清楚如何处理保持 在进行第二次比较的同时，将第一次比较的结果上升，然后将它们相结合。 这可能看起来有可能用完一个额外的寄存器，但它几乎从来没有这样做。通常情况下，你不再需要 foo 了，如果你这样做 rc 还没有使用，所以它可以去那里。

在 c (strcpy、 memcpy、 ...)中使用字符串函数时，请记住它们返回的是什么——目标！通常，你可以通过“忘记”目标指针的副本来获得更好的代码，然后从这些函数的返回值中把它抓回来。

永远不要忽略返回与上次调用的函数返回的内容完全相同的机会。编译器不是很擅长识别:

foo_t * make_foo(int a, int b, int c) {
foo_t * x = malloc(sizeof(foo));
if (!x) {
// return NULL;
return x; // x is NULL, already in the register used for returns, so duh
}
x->a= a;
x->b = b;
x->c = c;
return x;
}

当然，如果并且只有一个返回点，您可以逆转这个逻辑。

(技巧，我回忆后)

尽可能将函数声明为静态函数总是一个好主意。如果编译器能够证明自己已经考虑到了某个特定函数的每个调用者，那么它就可以以优化的名义打破该函数的调用约定。编译器通常可以避免将参数移动到调用函数的寄存器或堆栈位置，这些寄存器或堆栈位置通常期望函数的参数在其中(为此，编译器必须偏离被调用函数和所有调用方的位置)。编译器还可以利用知道被调用函数需要什么内存和寄存器的优势，避免生成代码来保存寄存器或被调用函数不会干扰的内存位置中的变量值。当对函数的调用很少时，这种方法特别有效。这就获得了内联代码的许多好处，但是没有实际的内联。

我所做的一件事情就是尝试将代价高昂的操作保持在用户可能希望程序稍微延迟的位置。总体性能与响应性有关，但并不完全相同，对于许多事情来说，响应性是性能中更重要的部分。

上次我不得不提高整体性能时，我留意了次优算法，并寻找可能存在缓存问题的地方。我首先对性能进行分析和测量，然后在每次更改后再次进行分析和测量。后来这家公司倒闭了，但不管怎样，这都是一项有趣且具有指导意义的工作。

将数据与本机/自然边界对齐。

不要一遍又一遍地做同样的工作！

我看到的一个常见的反模式是这样的:

void Function()
{
MySingleton::GetInstance()->GetAggregatedObject()->DoSomething();
MySingleton::GetInstance()->GetAggregatedObject()->DoSomethingElse();
MySingleton::GetInstance()->GetAggregatedObject()->DoSomethingCool();
MySingleton::GetInstance()->GetAggregatedObject()->DoSomethingReallyNeat();
MySingleton::GetInstance()->GetAggregatedObject()->DoSomethingYetAgain();
}

编译器实际上必须一直调用所有这些函数。假设你，程序员，知道聚合对象不会在这些调用过程中改变，看在上帝的份上..。

void Function()
{
MySingleton* s = MySingleton::GetInstance();
AggregatedObject* ao = s->GetAggregatedObject();
ao->DoSomething();
ao->DoSomethingElse();
ao->DoSomethingCool();
ao->DoSomethingReallyNeat();
ao->DoSomethingYetAgain();
}

在单例 getter 的情况下，调用的开销可能不会太大，但是它肯定是一个开销(通常，“检查对象是否已经创建，如果没有，创建它，然后返回它)。这条获取链变得越复杂，我们浪费的时间就越多。

有人提醒我曾经遇到过这样的情况，症状很简单，就是内存不足，但结果是性能大大提高(内存占用也大大减少)。

这个案例中的问题在于我们使用的软件分配了大量的资源。比如，这里分配四个字节，那里分配六个字节，等等。还有很多小对象，在8-12字节范围内运行。问题不在于程序需要很多小东西，而在于它分配了很多单独的小东西，这使得每次分配都膨胀到(在这个特定的平台上)32个字节。

这个解决方案的一部分是将 Alexandrescu 风格的小对象池组合在一起，但是扩展了它，这样我就可以分配小对象数组和单个项目。这也极大地提高了性能，因为在任何时候缓存中都可以容纳更多的项。

解决方案的另一部分是用 SSO (小字符串优化)字符串替代手动管理的 char * 成员的猖獗使用。最小分配是32字节，我构建了一个字符串类，它在 char * 后面嵌入了一个28个字符的缓冲区，所以95% 的字符串不需要做额外的分配(然后我用这个新类手动替换了这个库中 char * 的几乎所有外观，不管是否有趣)。这也帮助了大量的内存碎片，然后增加了其他指向对象的访问局部性，同样也提高了性能。

一个愚蠢的小提示，但是可以为你节省一些微小的速度和代码。

总是以相同的顺序传递函数参数。

如果有调用 f _ 2的 f _ 1(x，y，z) ，声明 f _ 2为 f _ 2(x，y，z)。不要声明为 f _ 2(x，z，y)。

其原因是 C/C + + 平台 ABI (AKA 调用约定)承诺在特定的寄存器和堆栈位置传递参数。当参数已经在正确的寄存器中时，它就不必移动它们。

While reading disassembled code I've seen some ridiculous register shuffling because people didn't follow this rule.

我从@MSalters 对 这个答案的评论中学到的一个简洁的技巧允许编译器在根据某些条件返回不同对象时进行复制省略:

// before
BigObject a, b;
if(condition)
return a;
else
return b;


// after
BigObject a, b;
if(condition)
swap(a,b);
return a;

将小函数和/或经常调用的函数放在源文件的顶部。这使得编译器更容易找到内联的机会。

我写了一个优化的 C 编译器，这里有一些非常有用的东西需要考虑:

1. 使大多数函数是静态的。这允许过程间常量传播和别名分析来完成它的工作，否则编译器需要假定可以从转换单元外部调用函数，并且参数的值是完全未知的。如果你看一下众所周知的开源库，它们都标记了静态函数，除了那些真正需要外部的函数。

2. 如果使用全局变量，请尽可能将其标记为静态和常量。如果它们被初始化一次(只读) ，最好使用初始化列表，比如 static const int VAL [] = {1,2,3,4} ，否则编译器可能不会发现变量实际上是初始化的常量，并且将无法用常量替换来自变量的负载。

3. 永远不要使用 goto 到循环的内部，循环将不再被大多数编译器识别，并且不会应用任何最重要的优化。

4. 仅在必要时使用指针参数，并在可能的情况下标记它们的限制。这对别名分析很有帮助，因为程序员保证不存在别名(过程间别名分析通常非常原始)。非常小的结构对象应该通过值传递，而不是通过引用传递。

5. 尽可能使用数组代替指针，特别是在循环(a [ i ])中。数组通常为别名分析提供更多的信息，经过一些优化之后，仍然会生成相同的代码(如果好奇，可以搜索减少循环强度的代码)。这也增加了循环不变的代码运动被应用的机会。

6. 尝试在循环之外提升对没有副作用的大型函数或外部函数的调用(不依赖于当前的循环迭代)。在许多情况下，小函数内联或转换为内部函数，这些函数很容易提升，但是对于编译器来说，大函数可能会有副作用，而实际上并没有。外部函数的副作用是完全未知的，除了一些来自标准库的函数，有时由一些编译器建模，使循环不变的代码运动成为可能。

7. 当编写具有多个条件的测试时，将最有可能的条件放在第一位。如果(a | | b | | c)应该是如果(b | | a | | c)如果 B比其他的更可能为真。编译器通常不知道条件的可能值以及哪些分支采用得更多(可以通过使用配置文件信息了解它们，但很少有程序员使用它)。

8. 使用 开关比执行 if (a | | b | | ... | | z)这样的测试更快。首先检查你的编译器是否自动执行这个操作，有些编译器是这样做的，但是使用 如果更具可读性。