标签: micro-optimization

我理解大部分的微优化,但它们真的有用吗？

Exempli特惠:不这样做++i,而不是i++,或while(1)还是for(;;)真的导致性能改进(在内存指纹或CPU周期)？

所以问题是,在C中可以进行哪些微优化？它们真的有用吗？

偶尔我需要在一组值中检查重复的ID,通常我会使用一个字典 - 只使用键并将值留空.

请注意,这是严格且高度优化的代码,因此请不要"过早优化"!假设CPU和RAM被挤压到极限的情况,我想收集关于更优化解决方案的意见; 大概类似于Lookup类会避免不必要的RAM分配,因此会稍快一些.是否有这样的课程要么是第三方,要么是我在BCL中忽略的一些课程？

我知道google已经发布了快速和紧凑字典类的代码 - 也许那里有东西可以移植到C#/ .Net？

谢谢.

编译器:linux上的clang ++ x86-64.

已经有一段时间了,因为我编写了任何复杂的低级系统代码,并且我对系统原语(windows和pthreads/posix)进行了编程.所以,#s和out的内容已经从我的记忆中消失了.我正在boost::asio和boost::thread目前一起工作.

为了模拟针对异步函数执行器的同步RPC(在请求被编辑的地方boost::io_service有多个线程),我正在使用boost同步原语.为了好奇,我决定使用这些原语.这就是我所看到的.io::service::runio_serviced::postsizeof

struct notification_object
{
  bool ready;
  boost::mutex m;
  boost::condition_variable v;
};
...
std::cout << sizeof(bool) << std::endl;
std::cout << sizeof(boost::mutex) << std::endl;
std::cout << sizeof(boost::condition_variable) << std::endl;
std::cout << sizeof(notification_object) << std::endl;
...

输出:

1
40
88
136

互斥锁的四十个字节?? ?? ？WTF!88为条件_变量!!! 请记住,我被这个体积臃肿击退,因为我想,可能造成上百的应用程序notification_object的

这种便携性开销似乎很荒谬,有人可以证明这一点吗？据我所知,这些原语应该是4或8字节宽,具体取决于CPU的内存模型.

我正在优化矩阵数值热点.

目前,我正在进行阻塞和循环展开以提高性能.但是,我故意避免剥掉边界.相反,我让阻塞步骤溢出,当然,算法然后触及未初始化的值.

然而,矩阵被慷慨地预先分配以应对溢出,所以我实际上并不是非法访问内存位置.

剥皮有几个原因:

• 怠惰
• 由于剥离边框的非常糟糕的位置,性能受到打击.
• 避免复杂的边框剥离代码.

但是,我想知道这些触及未初始化值的溢出访问是否会导致性能下降？

我可以预见地知道未初始化的访问发生在哪里,并且它们也通过valgrind报告.我还使用英特尔的VTune对代码进行了分析,并且看不出有任何迹象表明由此导致的性能下降.

我需要检查传递的变量是否是字符串的类型,并且它不是空的.我有以下功能:

function isNonEmptyStr($var)
{
    if(isset($var)) {
        if(is_string($var)) {
            if(strlen($var) > 0) {
                return true;
            }
        }
    }
    return false;
}

结果我期待:

echo(isNonEmptyStr(''));// false
echo(isNonEmptyStr(' '));// true
echo(isNonEmptyStr('a'));// true
echo(isNonEmptyStr('1'));// true
echo(isNonEmptyStr(1));// false
echo(isNonEmptyStr(0));// false
echo(isNonEmptyStr(0.0));// false
echo(isNonEmptyStr(0.1));// false
echo(isNonEmptyStr(array()));// false
echo(isNonEmptyStr(new myObj()));// false
echo(isNonEmptyStr(true));// false
echo(isNonEmptyStr(false));// false
echo(isNonEmptyStr(null));// false

功能正常.

我的问题:有没有办法在不影响结果的情况下提高功能性能？

我说的是"微优化"(我非常重视这个功能).

编辑:

对于那些要求的人:

echo(isNonEmptyStr(0));// should return false, because it's not a string
echo(isNonEmptyStr(1));// should return false, because it's not a string
echo(isNonEmptyStr('0'));// should return true, because it's a …

我对JavaScript很新,我对如何优化if语句有疑问.

我将向您展示两种情况.

//first

var number = 10;
var calculationOneResult = functionOne(number);
var calculationTwoResult = functionTwo(number);

if (calculationOneResult === true) {
    //stuff
} else if (calculationTwoResult === true) {
    //more stuffs
}


//second

var number = 10;

if (functionOne(number) === true) {
    //stuff
} else if (functionTwo(number) === true) {
    //more stuffs
}

这是我的问题:在第一个场景中,我正在计算两次.在第二个函数中,如果第一个函数返回true,它会计算第二个elseif语句还是会在执行后跳过它stuff？

我正在努力尝试使用枚举和大量的宏观魔法来实现vtable的替代品,这种魔法真的开始让我的大脑混乱.我开始认为我没有走正确的道路,因为代码变得更加丑陋和丑陋,并且无论如何都不适合生产.

如何使用最少量的重定向/操作实现以下代码的模式？

它必须在标准的c ++中完成,最多17个.

class A{
    virtual void Update() = 0; // A is so pure *¬*
};

class B: public A
{
    override void Update() final
    {
        // DO B STUFF
    }
}

class C: public A
{
    override void Update() final
    {
        // DO C STUFF
    }
}

// class...

int main()
{
    std::vector<A*> vecA{};

    // Insert instances of B, C, ..., into vecA

    for(auto a: vecA) // This for will be inside a main loop
        a->Update(); // …

我对以下代码段感到困惑:

movsx   ecx, [ebp+var_8] ; signed move
cmp     ecx, [ebp+arg_0]
jnb     short loc_401027 ; unsigned jump

这似乎有冲突.Var_8似乎是在签名扩展帐户上签名的.然而,jnb暗示var_8未在帐户上签名,它是无符号的比较.

那么,var_8是签名还是未签名？那么arg_0呢？

tl; dr:我有两个功能相同的C代码,我用Clang编译(事实上它的C代码并不重要;只有汇编很有意思),IACA告诉我一个应该更快,但我不明白为什么,我的基准测试显示两个代码的性能相同.

我有以下的C代码(忽略#include "iacaMarks.h",IACA_START,IACA_END现在):

ref.c:

#include "iacaMarks.h"
#include <x86intrin.h>

#define AND(a,b)  _mm_and_si128(a,b)
#define OR(a,b)   _mm_or_si128(a,b)
#define XOR(a,b)  _mm_xor_si128(a,b)
#define NOT(a)    _mm_andnot_si128(a,_mm_set1_epi32(-1))

void sbox_ref (__m128i r0,__m128i r1,__m128i r2,__m128i r3,
               __m128i* r5,__m128i* r6,__m128i* r7,__m128i* r8) {
  __m128i r4;

  IACA_START
  r3 = XOR(r3,r0);
  r4 = r1;
  r1 = AND(r1,r3);
  r4 = XOR(r4,r2);
  r1 = XOR(r1,r0);
  r0 = OR(r0,r3);
  r0 = XOR(r0,r4);
  r4 = XOR(r4,r3);
  r3 = XOR(r3,r2);
  r2 = OR(r2,r1);
  r2 = XOR(r2,r4);
  r4 = NOT(r4); …

如果我的理解是正确的，

_mm_movehdup_ps(a)

给出与以下结果相同的结果

_mm_shuffle_ps(a, a, _MM_SHUFFLE(1, 1, 3, 3))？

两者在性能上有区别吗？