标签: optimization

当我谈论Go时,我正在谈论gc编译器实现.

据我所知,Go执行逃逸分析.Go代码中经常出现以下习语:

func NewFoo() *Foo

转义分析会注意到Foo转义NewFoo并在堆上分配Foo.

这个函数也可以写成:

func NewFoo(f *Foo)

并将被用作

var f Foo
NewFoo(&f)

在这种情况下,只要f不在其他地方转义,就可以在堆栈上分配f.

现在来看我的实际问题.

编译器是否可以优化每个foo() *Foo进程foo(f *Foo),甚至可能在多个级别进行优化,其中Foo在每个级别中返回？

如果不是,这种方法在哪种情况下会失败？

先感谢您.

Visual c ++,调试模式.

if(k>=0)

011D14CE  cmp         dword ptr [k],0  
011D14D2  jl          bez+28h (11D14D8h)  

return true;

011D14D4  mov         al,1  
011D14D6  jmp         bez+33h (11D14E3h)  

return false;
011D14D8  xor         al,al  
011D14DA  jmp         bez+33h (11D14E3h)  

和平等的代码:

return (k>=0)?(true):(false);
011D14DC  cmp         dword ptr [k],0  
011D14E0  setge       al  

什么更快？当我在函数调用中使用第二个构造时,什么更快？

if(i>0)
    Foo(true);
else
    Foo(false);

要么:

Foo((i>0)?(true):(false))

？

请问功能qsort()在stdlib.h实际使用快速排序算法,顾名思义？

当函数变得中等大时,我通常将其更改为静态.例如,如果一个类toString()变得很大,我通常将其更改为

public String toString()  {
   return  ClassName.toString(this);
}

private static final String toString(ClassName c_n)  {
    //.........
}

如果功能不是太大,这样做是否有点过分？

编辑

我在这里被大肆击倒.:)

我理解一般应该如何使用静态修饰符(对于单例,对于与特定实例无关的东西,对于效用函数).我从优化的角度问这个问题:为了避免大型函数的字节代码在内存中复制,对于每个类的实例.我显然错了它的工作原理.

我正在编写(或者至少尝试编写)一些高性能的C++代码.我遇到了一个需要进行大量整数比较的部分,即检查结果是否等于零.

哪个更有效率？也就是说,这需要更少的处理器指令？

if (i == 0) {
    // do stuff
}

要么

if (!i) {
    // do stuff
}

我在x86-64架构上运行它,如果这有任何区别的话.

得到的变换光场数据的索引是ub,vb,sb,tb.它们中的每一个都取决于变量u,v,s,t.

很抱歉不清楚,让我提一下,我正在尝试通过某种矩阵转换4D数据集.在下面的代码中,M只是一个3D变换矩阵.

f=0.1; 
n = 11; 
[u,v,s,t] = ndgrid([1:Size(3)],[1:Size(4)],[1:Size(1)],[1:Size(2)]); 
alpha = M(3,1)*s+M(3,2)*t+M(3,3)*nf; 
beta1 = M(1,1)*u+M(1,2)*v+M(1,4); 
beta2 = M(2,1)*u+M(2,2)*v+M(2,4); 
C = M(3,1)*u+M(3,2)*v+M(3,4); 
D1 = M(1,1)*s+M(1,2)*t+M(1,3)*nf; 
D2 = M(2,1)*s+M(2,2)*t+M(2,3)*nf; 
ub = -D1.*C./alpha+beta1; 
vb = -D2.*C./alpha+beta2; 
sb = nf*D1./alpha; 
tb = nf*D2./alpha; 
for s = 1:Size(1) 
    for t = 1:Size(2) 
        for u = 1:Size(3) 
            for v = 1:Size(4)             
                newLF(sb(u,v,s,t),tb(u,v,s,t),ub(u,v,s,t),vb(u,v,s,t)) = LF2(s,t,u,v); 
            end;
        end; 
    end;
end;  

现在由于ub,vb,sb和​​tb依赖于u,v,s,t因此,不可能像newLF = LF2那样分配它;

现在的问题是如何将这些for循环最小化到单行.

我在这个孤独的星期五晚上的任务是写一个C#交换算法

public void Swap<T> ( ref T a, ref T b ) 
{
   // ... 
} 

适用于任何类或数据类型T,并尽可能高效.帮助批评我到目前为止建立的方法.首先,这是正确的吗？我如何才能使其获得Skeet认证？

public void Swap<T> ( ref T a, ref T b ) 
{
   // Not sure yet if T is a data or value type. 
   // Will handle swapping algorithm differently depending on each case.
   Type type = T.GetType();
   if ( (type.IsPrimitive()) || (type == typeof(Decimal)) )
   {
       // this means the we can XOR a and b, the fastest way of …

从前一个问题跳出来,我问了一会儿:

为什么Python 3中的1000000000000000范围(1000000000000001)如此之快？

如果你这样做:

1000000000000000.0 in range(1000000000000001)

...很明显,range尚未进行优化以检查floats是否在指定范围内.

我想我明白,预期的目的range是int仅使用s - 所以你不能,例如,做这样的事情:

1000000000000 in range(1000000000000001.0)
# error: float object cannot be interpreted as an integer

或这个:

1000000000000 in range(0, 1000000000000001, 1.0) 
# error: float object cannot be interpreted as an integer

然而,无论出于何种原因,决定允许这样的事情:

1.0 in range(1)

似乎很明显1.0(及1000000000000.0以上)没有被强制转换为ints,因为那时int优化也适用于那些.

我的问题是,为什么不一致,为什么没有优化floats？或者,或者,为什么上述代码不会产生与前面示例相同的错误的原因是什么？

除了优化ints 之外,这似乎是一个明显的优化.我猜测有一些细微的问题妨碍了这种优化的干净实施,或者有一些理由说明为什么你实际上不想包含这样的优化.或者两者都可能.

编辑:为了澄清这里的问题,以下所有语句都进行了评估False:

3.2 in range(5)
'' in range(1)
[] in range(1) …

因此,当我学习编程时,我了解到一个简单的'x%2'将是一个很好的快速方法来确定一个数字是否是偶数.我已经开始使用'x&1',因为我相信它在CPU中更快(尽管今天的速度可能毫无意义).任何了解CPU的人都可以了解这是否真的更快,或者是否有一些简单的编译器优化？

我有一个C#应用程序,我通过Windows API与另一个窗口进行交互:(例如FindWindow(),FindWindowEx()).

在我的应用程序的一个特定部分,我必须等待另一个应用程序的窗口加载,然后单击出现的按钮(有时需要三秒钟才能显示).

目前,我这样做:

IntPtr foohWnd = IntPtr.Zero;
while(foohWnd == IntPtr.Zero)
    foohWnd = FindWindow(null, "Foo");

正如您所看到的,这只是一遍又一遍地检查窗口而不关心资源或类似的东西.(别担心,在我的实际代码中,它会在一点之后"超时"以防止无限循环).

但是,我发现这样做的另一种方法是使用Thread.Sleep():

Thread.Sleep(3000);
foohWnd = FindWindow(null, "Foo");

这两个中哪一个是更好的做法？有没有更好的方式我在这里无视？