blocks|key|2709291|text|根据我的经验，优化C代码最非常规的方法是分析应用程序，识别缓慢执行的结构和或db+hits，然后使用Big分析设计合理的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2709292|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

In my experience the most unorthodox way of optimizing C code is to profile the application, identify slowly performing structures and or db hits and then design reasonable solutions around them using Big O analysis.

blocks|key|2709313|text|达夫装置是一个典型的例子。汤姆·达夫(+Tom+)承认，“这段代码在关于万一陈述的辩论中形成了某种争论，但我不确定这是赞成还是反对”，这是非常奇怪的。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2709314|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Duff's_device^0|0|4|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

<a href="http://en.wikipedia.org/wiki/Duff&#39;s_device" rel="nofollow noreferrer">Duff's Device</a> is the canonical example. It's so weird that Tom Duff admitted, "This code forms some sort of argument in [the debate about fall-through in case statements], but I'm not sure whether it's for or against".

blocks|key|2709409|text|滥用常数0x5f3759df快速计算逆平方根必须排名相当高.|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2709410|entityMap|0|LINK|mutability|MUTABLE|url|http://betterexplained.com/articles/understanding-quakes-fast-inverse-square-root/^0|0|E|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

<a href="http://betterexplained.com/articles/understanding-quakes-fast-inverse-square-root/" rel="nofollow noreferrer">Abusing the constant 0x5f3759df</a> to compute inverse square roots quickly has to rank pretty high...

blocks|key|2709505|text|使用内联程序集？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2709506|但是，说真的，如果仅仅通过更改C代码就可以提高性能，那么很有可能您就可以干净利落地做到这一点。|2709507|有几个例外：|2709508|1)如果对不同类型的指针依赖对齐语义，则可以对指针执行块操作，这些指针在技术上使应用程序处于边界溢出状态，但实际上并不是因为系统的对齐特性。因此，可以执行内存复制，通过对初始字符的对齐，然后可以使用一个长*指针来完成内部块。|2709509|2)如果您知道编译器分配局部变量的内存顺序，就可以巧妙地复制堆栈帧。这可能允许您实现其他语言不支持的协同例程。协同控制通常是实现某些循环控制的一种更简单、更快的方法。|2709510|3)工会总是有点“无趣”，不管你怎么使用它们。这是一种通过比较松散的类型检查来实现多态性的方法。|2709511|4)使用C预处理器作为一种自动生成代码的方法，通常很难调试和读取。因此，人们倾向于避免这样做。|2709512|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|S|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|T|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|U|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|V|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|O|$]]

Use inline assembly?

Seriously though, if by merely changing the C code you can improve performance, chances are you can do it cleanly.

A few exceptions: 

1) If you are relying on alignment semantics for pointers of different types often you can perform block operations on pointers that technically expose your application to a bounds overrun condition, but in practice does not because of your system's alignment characteristics. So a memory copy can be performed, by aligning initial char's then the inner block can be done using a long* pointer.

2) It may be possible to copy stack frames in clever ways if you know the memory order in which your compiler assigns local variables. This may allow you to implement co-routines which the language doesn't otherwise support. Coroutines are often a simpler and faster way of implementing some kinds of loop control.

3) Unions are always a bit "hacky" however you use them. Its a way of implementing polymorphism with fairly loose type checking.

4) Use of the C preprocessor as a way of auto-generating code is usually very difficult to debug and read. As such people tend to avoid this.

blocks|key|2709326|text|分析您的代码，找出慢点，并使用内联程序集来优化它们。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2709327|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Profile your code, find the slow spots, and use inline assembly to optimize them.

blocks|key|1122700|text|1)环行展开。如果不实际循环，则保存每次迭代时的跳转、比较和增量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1122701|2)避免双重间接。执行算法通常要快得多，所以“高度%2Bx”通常比“y”更快。此外，与尺寸为MxN的矩形矩阵相比，尺寸为MxN的一维数组节省了指针的M(或N)字。|1122702|3)尽可能使用荒谬的装配优化。例如，在x86体系结构上，您可以使用BSWAP指令在一个操作中交换字节，而不是普通的temp=a;+a=b;+b=temp;模式。|offset|length|style|CODE|1122703|当然，别忘了：|1122704|4)不要进行边界检查或错误处理。|1122705|话虽如此，但在实践中，除了(2)之外，我会避免所有这些。|1122706|entityMap^0|0|0|1L|K|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|T|8|@$F|U|G|V|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|W|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|X|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|Y|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|Q|$]]

1) Loop unrolling. You save a jump, comparison, and increment every iteration if you don't actually loop. 
2) Avoid double-indirection. It's usually faster to perform arithmetic that retrieval, so a[y*height + x] is usually faster than a[y][x]. Plus a one-dimensional array of size MxN saves M (or N) words worth of pointers compared to a rectangular matrix of dimensions MxN. 
3) Use ridiculous assembly optimizations whenever possible. For instance, on the x86 architecture, you can use the BSWAP instruction to swap bytes in one operation instead of the normal <code>temp=a; a=b; b=temp;</code> pattern.

And of course, don't forget: 
4) Don't do bounds checking or error handling.

That having been said, I'd avoid all of these except (2) in practice.

blocks|key|1123037|text|你在寻找一种非正统的，无限制的，但通用的优化C的解决方案？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1123038|用汇编语言重写。|1123039|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

You're looking for an unorthodox, no holds-barred, yet general-purpose solution to optimizing C?

Rewrite it in assembly language.

blocks|key|2709448|text|几乎可以肯定，您的编译器比丑陋的尝试在优化方面要好得多。大多数历史上的小把戏现在都是毫无意义的。忽视可读性和可维护性的人往往会编写效率较低的代码，因为真正的优化变得更加困难。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2709449|当代码已经以各种可能的方式优化并且仍然需要性能增益时，重写ASM中的关键部分是最好的希望。|2709450|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Your compiler is almost certainly better at optimizing than your ugly attempts would give you. Most of the historical little tricks are now pointless. People ignoring readability and maintainability tend to write code that ends up less efficient because the real optimizations are made more difficult. 

When code has been optimized in all ways possible and still needs performance gain, rewriting critical portions in ASM is the best hope to have any effect.

blocks|key|1185019|text|对于C代码的性能，没有什么可做的了。所有有效的技术都是“正统的”。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1185020|我发现最好的方法是使用一个具有CPU性能计数器访问权限的分析器，并特别注意缓存和分支丢失。尽可能添加缓存预取，并尽可能删除不可预测的分支。|1185021|不要费心于循环展开。如果分支是可预测的，它几乎是免费的。让编译器来担心它。|1185022|在一些非常并行的体系结构上，比如IA64，可以更快地展开循环直到结束。其中一个例子是避免使用C字符串函数。使用memset将字符串数组为零，使用memcpy设置字符串，并使用memcmp将整个数组与另一个类似的数组进行比较。这可以使用64位负载，无需检查零终止符，如果使用64或128的“小”数组大小，则可以优化为not循环或分支。memxxx()函数通常是编译器内置的，并且非常优化。|1185023|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

There is nothing unorthodox left to do for C code performance. All of the effective techniques have been "orthodoxed".

The best I've found is to use a profiler with access to CPU performance counters and pay special attention to cache and branch misses. Add cache prefetches wherever you can and remove unpredictable branches wherever you can.

Don't bother with loop unrolling. If the branch is predictable it is almost free. Let the compiler worry about it.

On some very parallel architectures like IA64 it can be faster to unroll a loop all the way to the end. One example of this is avoiding the C string functions. Use memset to zero a string array, memcpy to set the string and memcmp to compare the entire array against another similar array. This can use 64-bit loads, never has to check for the zero terminator and can be optimized to not loop or branch at all if using a "small" array size of 64 or 128. The memxxx() functions are usually compiler built-ins and very optimized.

blocks|key|1185099|text|我听到了很多关于“尝试做X，Y或Z”的回答，但这就像说“听，吃一条鱼，吃一天好”。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1185100|我宁愿教你如何捕鱼-为性能问题。那些说“侧写第一”的人是在正确的轨道上，但是(IMHO)太胆小了。|1185101|这里是一个积极的性能调优的例子。|offset|length|1185102|以下是对其工作原理的简短解释。|1185103|以下是对其工作原理的详细解释。|1185104|这将教你如何捕鱼，告诉你如何找出鱼在哪里和它们有多大。一旦你找到了它们，你就可以用许多奇妙的方法把它们做好(修理)。最重要的是，一旦你发现并处理了一条鱼(性能问题)，其他的鱼就会变得更大更容易抓到。|1185105|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/926266/performance-optimization-strategies-of-last-resort/927773#927773|1|https://stackoverflow.com/questions/406760/whats-your-most-controversial-programming-opinion/1562802#1562802|2|https://stackoverflow.com/questions/375913/what-can-i-use-to-profile-c-code-in-linux/378024#378024^0|0|0|0|G|0|0|0|F|1|0|0|F|2|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|10|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|11|8|@]|9|@$F|12|G|13|1|14]]|A|$]]|$1|H|3|I|5|6|7|15|8|@]|9|@$F|16|G|17|1|18]]|A|$]]|$1|J|3|K|5|6|7|19|8|@]|9|@$F|1A|G|1B|1|1C]]|A|$]]|$1|L|3|M|5|6|7|1D|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|O|$P|$5|Q|R|S|A|$T|U]]|V|$5|Q|R|S|A|$T|W]]|X|$5|Q|R|S|A|$T|Y]]]]

I hear a lot of answers of the form "Try doing X, Y, or Z", but that's like saying "Hear, have a fish, and eat well for a day".

I would rather teach you how to fish - for performance problems. People who say "Profile First" are on the right track but (IMHO) are far too timid.

<a href="https://stackoverflow.com/questions/926266/performance-optimization-strategies-of-last-resort/927773#927773">Here's an example of aggressive performance tuning.</a>

<a href="https://stackoverflow.com/questions/406760/whats-your-most-controversial-programming-opinion/1562802#1562802">Here's a short explanation of why it works.</a>

<a href="https://stackoverflow.com/questions/375913/what-can-i-use-to-profile-c-code-in-linux/378024#378024">Here's a long explanation of why it works.</a>

That will teach you to fish by showing you how to find out where the fish are and how big they are. Once you find them, you can cook them up (fix them) in many wonderful ways.
The great thing is, once you find and dispose of one fish (performance problem), the others get bigger and easier to catch.

blocks|key|2709342|text|达夫装置+&+InvSqrt.|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2709343|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Duff's_device|1|http://en.wikipedia.org/wiki/Fast_inverse_square_root^0|7|7|0|4|0|7|7|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@$9|S|A|T|1|U]|$9|V|A|W|1|X]]|E|$]]|$1|F|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]|N|$5|I|J|K|E|$L|O]]]]

<a href="http://en.wikipedia.org/wiki/Duff&#39;s_device" rel="nofollow noreferrer">Duff's Device</a> &amp; <a href="http://en.wikipedia.org/wiki/Fast_inverse_square_root" rel="nofollow noreferrer">Carmack's Fast <code>InvSqrt</code></a>.

blocks|key|1184943|text|在DSP应用程序中，仍然值得使用汇编语言来获得C编译器并不擅长的SIMD指令的最佳性能。但这并不是真正的C解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1184944|我经常做的事情是用曲线拟合软件来代替函数，用更快的近似来计算。有时LUTs仍然比做一堆计算更快，但不像以前那样频繁了。|1184945|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

In DSP applications, it's still worth going to assembly language to get the best performance out of the SIMD instructions that C compilers don't do very well with. But that's not really a "C" solution.

Something I do pretty often is use curve-fitting software to replace functions with approximations that are faster to calculate. Sometimes LUTs are still faster than doing a bunch of calculations, but not as often as they used to be.

blocks|key|1184998|text|参见本章，这是一种平凡而美好的生活+by+Abrash+(大约5页:单击每个屏幕底部的“Next”)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1184999|摘要(文章中的一些引文)：|1185000|表驱动的魔法(庞大的查找表和难以置信的状态机)|unordered-list-item|1185001|一种性能编程方法，它在比以往任何时候都更高效、集成更紧密的水平上运行。|1185002|惊人的努力经济|1185003|entityMap|0|LINK|mutability|MUTABLE|url|http://www.phatcode.net/res/224/files/html/ch18/18-01.html^0|5|C|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|Z|8|@]|9|@]|C|$]]|$1|I|3|J|5|H|7|10|8|@]|9|@]|C|$]]|$1|K|3|L|5|H|7|11|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|12|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

See this chapter, <a href="http://www.phatcode.net/res/224/files/html/ch18/18-01.html" rel="nofollow noreferrer">It’s a plain Wonderful Life</a> by Abrash (it's about 5 pages: click 'Next' at the bottom of each screen).

Summary (some quotes from the article):

<ul>
<li>Table-driven magic (huge lookup table and incredible state machine)</li>
<li>An approach to performance programming that operates at a more efficient, tightly integrated level than you may ever see again</li>
<li>Astonishing economy of effort</li>
</ul>

blocks|key|2709775|text|内嵌组件。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2709776|entityMap|0|LINK|mutability|MUTABLE|url|http://www.ibiblio.org/gferg/ldp/GCC-Inline-Assembly-HOWTO.html^0|0|4|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

<a href="http://www.ibiblio.org/gferg/ldp/GCC-Inline-Assembly-HOWTO.html" rel="nofollow noreferrer">Inline Assembly</a>.

What is the most unorthodox way to improve the performance of C code? This is no-holds-barred! Everything goes including changing loop structures to gotos, hardcoding anything and everything, using case statements in bizarre ways etc. Don't worry at all about maintainability, readability etc.

p.s. This is practical... and I'm well aware of how to improve the performance of code in reasonable ways (improve algorithms, profile before you optimize etc)

Improving the performance of C code

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

提高C代码性能的最非正统的方法是什么？这是无障碍的！每件事都包括改变gotos的循环结构，对任何事情进行硬编码，以奇怪的方式使用case语句等等。不要担心可维护性、可读性等等。附注：这很实用..。我很清楚如何以合理的方式提高代码的性能(改进算法，优化之前的配置文件等等)

问提高C代码的性能
EN

回答 14

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问提高C代码的性能EN

回答 14

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问提高C代码的性能
EN