Consider this simple C++ function to calculate the prefix sum of an array:
void prefix_sum(const uint32_t* input, uint32_t* output, size_t size) {
uint32_t total = 0;
for (size_t i = 0; i < size; i++) {
total += input[i];
output[i] = total;
}
}
The loop compiles to the following assembly on gcc 5.5:
.L5:
add ecx, DWORD PTR [rdi+rax*4]
mov DWORD PTR [rsi+rax*4], ecx
add rax, 1
cmp rdx, rax
jne .L5
I don't see anything that would prevent …
我希望采用IEEE双精度并以最有效的方式删除它的任何整数部分.
我想要
1035 ->0
1045.23->0.23
253e-23=253e-23
我不关心正确处理非正规,无穷大或NaN.我不介意有点麻烦,因为我知道我正在使用IEEE双打,所以它应该适用于各种机器.
无分支代码将是更优选的.
我的第一个念头是(伪代码)
char exp=d.exponent;
(set the last bit of the exponent to 1)
d<<=exp*(exp>0);
(& mask the last 52 bits of d)
(shift d left until the last bit of the exponent is zero, decrementing exp each time)
d.exponent=exp;
但问题是我想不出一个有效的方法来向左移动指数的最后一位为零,如果没有设置所有最后一位,它似乎需要输出零.这似乎与基数2对数问题有关.
对此算法或任何更好的算法的帮助将非常感激.
我应该注意到我想要无分支代码的原因是因为我希望它能有效地进行矢量化.
我正在研究一个软实时事件处理系统.我希望尽可能减少代码中具有非确定性时序的调用次数.我需要构造一个由字符串,数字,时间戳和GUID组成的消息.大概std::vector的boost::variant的.
我一直想用alloca在过去类似性质的代码中.然而,当人们研究系统编程文献时,总是会对这个函数调用提出大量警告.就个人而言,我不能想到过去15年中没有虚拟内存的服务器类机器,而且我知道Windows堆栈一次增长一个虚拟内存页面,所以我假设Unices也是如此.这里没有砖墙(再也没有),堆栈就像堆一样可能耗尽空间,那么是什么给出了？为什么人们没有超过阿洛卡？我可以想到许多负责任地使用alloca的用例(字符串处理任何人？).
无论如何,我决定测试性能差异(见下文),并且alloca和malloc之间存在5倍的速度差异(测试捕获了我将如何使用alloca).那么,有变化吗？我们是否应该谨慎对待风并使用alloca(包裹在a中std::allocator)每当我们完全可以确定物体的使用寿命时？
我厌倦了生活在恐惧中!
编辑:
好吧有限制,对于Windows来说这是一个链接时间限制.对于Unix来说,它似乎是可调的.似乎页面对齐的内存分配器是有序的:D任何人都知道通用的便携式实现:D？
码:
#include <stdlib.h>
#include <time.h>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <iostream>
using namespace boost::posix_time;
int random_string_size()
{
return ( (rand() % 1023) +1 );
}
int random_vector_size()
{
return ( (rand() % 31) +1);
}
void alloca_test()
{
int vec_sz = random_vector_size();
void ** vec = (void **) alloca(vec_sz * sizeof(void *));
for(int i = 0 ; i < vec_sz ; i++)
{
vec[i] = alloca(random_string_size()); …c++ memory-management real-time micro-optimization systems-programming
首先:
我问这个问题只是为了好玩和渴望学习.我不得不承认我喜欢搞微观优化(虽然他们从未在我的任何开发中导致任何显着的速度提升).
该DateTime.DayOfWeek方法并不代表我的任何应用中的瓶颈.
并且它不太可能 成为任何其他问题.如果有人认为这种方法对他的应用程序的性能有影响,他应该考虑何时进行优化,然后,他应该进行分析.
DateTime使用ILSpy 反编译类,我们了解如何DateTime.DayOfWeek实现:
[__DynamicallyInvokable]
public DayOfWeek DayOfWeek
{
[__DynamicallyInvokable, TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
get
{
return (DayOfWeek)((this.InternalTicks / 864000000000L + 1L) % 7L);
}
}
public long Ticks
{
[__DynamicallyInvokable, TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
get
{
return this.InternalTicks;
}
}
此方法执行以下操作:
与当天相对应的刻度除以一天中现有的刻度数.
我们在前面的结果中加1,以便除数7的余数在0和6之间.
这是计算星期几的唯一方法吗？
是否有可能重新实现它以使其运行更快？
我经常看到代码将int转换为双精度转换为双精度并再次转换(有时候出于好的理由,有时候没有),而且我刚刚想到这似乎是我程序中的"隐藏"成本.我们假设转换方法是截断.
那么,它有多贵？我确定它会因硬件而异,所以让我们假设一个新的英特尔处理器(Haswell,如果你愿意,虽然我会采取任何措施).我会感兴趣的一些指标(虽然一个好的答案不需要全部):
我还假设我们最敏锐地体验慢转换的影响的方式是关于功率使用而不是执行速度,因为我们每秒可以执行多少次计算相对于实际到达的数据量的差异在每秒CPU.
我想知道各种大小的循环如何在最近的x86处理器上执行,作为uop数的函数.
以下是彼得·科德斯(Peter Cordes)的一句话,他在另一个问题中提出了非多数的问题:
我还发现,如果循环不是4 uop的倍数,则循环缓冲区中的uop带宽不是每个循环的常数4.(即它是abc,abc,......;不是abca,bcab,......).遗憾的是,Agner Fog的microarch doc对循环缓冲区的这种限制并不清楚.
问题是关于循环是否需要是N uop的倍数才能以最大uop吞吐量执行,其中N是处理器的宽度.(即最近的英特尔处理器为4).在谈论"宽度"和计算微动时,有很多复杂因素,但我大多想忽略这些因素.特别是,假设没有微观或宏观融合.
Peter给出了以下一个循环,其中包含7个uop的循环:
一个7-uop循环将发出4 | 3 | 4 | 3 | ...的组我没有测试更大的循环(不适合循环缓冲区),看看是否有可能从下一个指令开始迭代发布在与其分支相同的组中,但我不假设.
更一般地说,声称是x在其体内具有uops 的循环的每次迭代将至少进行ceil(x / 4)迭代,而不是简单地迭代x / 4.
对于部分或全部最新的x86兼容处理器,这是真的吗？
performance x86 assembly cpu-architecture micro-optimization
想象一下,您希望将一系列x86汇编指令与某些边界对齐.例如,您可能希望将循环对齐到16或32字节的边界,或者将指令打包以使它们有效地放置在uop缓存中或其他任何位置.
实现这一目标的最简单方法是单字节NOP指令,紧接着是多字节NOP.虽然后者通常效率更高,但这两种方法都不是免费的:NOP使用前端执行资源,并且还计入现代x86上的4宽1重命名限制.
另一个选择是以某种方式延长一些指令以获得所需的对齐.如果这样做没有引入新的停顿,它似乎比NOP方法更好.如何在最近的x86 CPU上有效地延长指令？
在理想的世界中,延长技术同时是:
有一种方法不可能同时满足所有上述要点,因此很好的答案可能会解决各种权衡问题.
1 AMD Ryzen的限制为5或6.
假设我有一个如下的switch语句
switch(alphabet) {
case "f":
//do something
break;
case "c":
//do something
break;
case "a":
//do something
break;
case "e":
//do something
break;
}
现在假设我知道Alphabete 的频率最高,然后分别是a,c和f.所以,我只是重新构建了case语句顺序,并按如下方式进行了修改:
switch(alphabet) {
case "e":
//do something
break;
case "a":
//do something
break;
case "c":
//do something
break;
case "f":
//do something
break;
}
第二个switch陈述会比第一个switch陈述更快吗？如果是的话,如果在我的计划中,我需要switch多次称这个声明,这会是一个实质性的改进吗？或者,如果没有,我如何使用我的频率知识来提高性能？
在程序的一个时间关键部分,有一个类的成员看起来像这样:std :: vector m_vLinks; 在分析期间,我注意到大约99.98%的执行此向量仅包含0或1个项目.然而,在极少数情况下它可能会持有更多.根据探查器,这个向量肯定是一个瓶颈,所以我正在考虑如下优化:
在开始对这个东西进行原型设计以确定它是否有帮助之前,我想知道是否有人在某些第三方库中遇到了具有类似功能的自定义容器？
我已经考虑过boost :: array,但是不希望它强加的大小限制
为什么c ++文件中函数的位置会影响其性能？具体来说,在下面给出的示例中,我们有两个相同的功能,具有不同的,一致的性能配 如何调查这一点并确定性能如此不同？
这个例子很简单,因为我们有两个函数:a和b.每个都在紧密循环中运行多次并优化(-O3 -march=corei7-avx)和定时.这是代码:
#include <cstdint>
#include <iostream>
#include <numeric>
#include <boost/timer/timer.hpp>
bool array[] = {true, false, true, false, false, true};
uint32_t __attribute__((noinline)) a() {
asm("");
return std::accumulate(std::begin(array), std::end(array), 0);
}
uint32_t __attribute__((noinline)) b() {
asm("");
return std::accumulate(std::begin(array), std::end(array), 0);
}
const size_t WARM_ITERS = 1ull << 10;
const size_t MAX_ITERS = 1ull << 30;
void test(const char* name, uint32_t (*fn)())
{
std::cout << name << ": ";
for (size_t i = 0; i < WARM_ITERS; i++) …