标签: micro-optimization

鉴于阵列:

int canvas[10][10];
int addon[10][10];

在所有值都在0到100之间的情况下,C++中添加这两个数组的最快方法是什么,因此画布中的每个单元都等于自身加上插件中相应的单元格值？

IE,我想实现类似的东西:

canvas += another;

因此,如果canvas [0] [0] = 3且addon [0] [0] = 2则canvas [0] [0] = 5

速度是必不可少的,因为我正在编写一个非常简单的程序来暴力背包式问题,并且将有数千万种组合.

并且作为一个额外的小问题(感谢您可以提供帮助!)检查画布中的任何值是否超过100的最快方法是什么？ 循环很慢!

我想知道现代编译器和它们的优化是否仍然值得用C而不是C++编写一些关键代码以使其更快.

我知道C++可能会导致在复制的情况下性能不佳,而它们可以通过引用传递,或者当编译器自动创建类时,通常使用重载的运算符和许多其他类似的情况; 但是对于一个知道如何避免所有这些的优秀C++开发人员来说,仍然值得用C语言编写代码以提高性能吗？

有没有比使用ListIterator？更快,更有效的方法？

ListIterator<Integer> itr = list.listIterator(list.size());
while(itr.hasPrevious()){
    System.out.println(itr.previous());
}

我读到当PHP lexer解析php并遇到doccomment时,它将该注释的内容存储为元数据.所以我认为与使用非doccomment格式的常规注释相比,这可能会有轻微的开销？

定期评论......

<?php

/*
some text
/*
// more comments

?>

doccomment ...

<?php
/**
 * @author Kenneth Davis
 * @copyright 2011
 * @filename Exception.class.php
*/
?>

今天,我使用Visual Studio 2010性能分析器分析了我的一个C#应用程序.具体来说,我正在对" 并发 " 进行概要分析,因为看起来我的应用程序应该具有更多的容量然后才能进行演示.分析报告显示,线程在同步状态下花费了大约70-80%的时间.

说实话,我不确定这意味着什么.这是否意味着应用程序遭受了锁定状态？

对于上下文...有大约30个+长时间运行的线程绑定到单个AppDomain(如果这很重要)并且一些线程非常繁忙(例如while(true) { _waitEvent.WaitOne(0); //do stuff }).

我意识到这是一个相当模糊的问题......我想我正在寻找关于线程同步状态含义的一些说明.太多了,为什么？~75%真的很糟糕吗？我有太多线程吗？或者我应该开始寻找其他领域？

我有一组少量的功能.两个函数进行数学叠加操作(定义http://docs.gimp.org/en/gimp-concepts-layer-modes.html,但有点下来-只要搜索"叠加",找到数学)在不同的方法.现在,这个操作是Gimp在一秒钟之内做得很快的事情,但是我似乎无法优化我的代码以获得类似于远程类似时间的任何东西.

(我的应用程序是一个GUI应用程序,可以帮助我查看和比较大量文件的各种叠加组合.Gimp层界面实际上很难选择两个图像叠加,然后选择不同的两个,等等)

这是代码:

(set! *warn-on-reflection* true )

(defn to-8-bit [v]
  (short (* (/ v 65536) 256)))

(defn overlay-sample [base-p over-p]
  (to-8-bit 
    (* (/ base-p 65536) 
       (+ base-p
          (* (/ (* 2 over-p) 65536)
             (- 65536 base-p))))))

(defn overlay-map [^shorts base ^shorts over]
  (let [ovl (time (doall (map overlay-sample ^shorts base ^shorts over)))]
    (time (into-array Short/TYPE ovl))))

(defn overlay-array [base over]
  (let [ovl (time (amap base
                        i
                        r
                        (int (overlay-sample (aget r i)
                                             (aget over i)))))]
    ovl))

overlay-map和overlay-array以不同的方式执行相同的操作.我也写了这个操作的其他版本.然而,到目前为止,叠加图是我所拥有的最快的.

base和over两个函数都是16位整数数组.每个样本的实际大小为1,276,800个样本(800 …

使用英特尔编译器内在函数,给定一个128位寄存器,打包8个16位元素,如何从寄存器中访问(廉价)任意元素,以便后续使用_mm_cvtepi8_epi64(符号扩展两个8位元素,打包在较低位置) 16位寄存器,两个64位元素)？

我会解释为什么我问:

1. 输入:具有k个字节的内存缓冲区,每个字节为0x0或0xff.
2. 期望输出:对于输入的每两个连续字节,寄存器分别用0x0和包装两个四字(64位)0xffff ffff ffff ffff.
3. 最终目标:根据输入缓冲区的条目对k个双精度缓冲区进行求和.

注意:输入缓冲区的值0x0和值0xff可以更改为最有用的值,前提是在总和之前屏蔽效果仍然存在.

从我的问题可以明显看出,我目前的计划如下,在输入缓冲区中流式传输:

1. 将输入掩码缓冲区从8位扩展到64位.
2. 使用扩展掩码屏蔽双打缓冲区.
3. 总结蒙面的双打.

谢谢,阿萨夫

我想在C++中定义一个新类型,它只是一些原始类型(在我的例子中int,可以是任何类型).我NodeId在这个例子中调用了这个类型.

我可以用typedef int NodeId.我想要一个NodeIds 的默认值,所以我会用#define NULL_NODE_ID -1.

现在,我认为定义一个类而不是typedef允许一个函数isValid()和构造一个null的默认构造函数会更好NodeId:

class NodeId
{
    int value;
public:
    inline NodeId() : value(-1) {}
    inline NodeId(int value) : value(value) {}
    inline operator int() {return value;}
    inline bool isValid() {return value != -1;}
    //...
};

是否存在导致使用第二种方法的性能缺点？

如果我将一次迭代变量声明为类成员,我想我会节省一些时间:

struct Foo {
  int i;
  void method1() {
    for(i=0; i<A; ++i) ...
  }
  void method2() {
    for(i=0; i<B; ++i) ...
  }
} foo;

然而,这似乎快了20%

struct Foo {
  void method1() {
    for(int i=0; i<A; ++i) ...
  }
  void method2() {
    for(int i=0; i<B; ++i) ...
  }
} foo;

在这段代码中

void loop() { // Arduino loops
  foo.method1();
  foo.method2();
}

你能解释性能差异吗？

(我需要在Arduino上运行许多简单的paralel"进程",这样的微优化会产生影响.)

有时gcc使用32位寄存器,当我希望它使用64位寄存器时.例如以下C代码:

unsigned long long 
div(unsigned long long a, unsigned long long b){
    return a/b;
}

使用-O2选项编译(省略一些样板文件):

div:
    movq    %rdi, %rax
    xorl    %edx, %edx
    divq    %rsi
    ret

对于无符号除法,寄存器%rdx需要0.这可以通过xorq %rdx, %rdx但xorl %edx, %edx似乎具有相同的效果来实现.

至少在我的机器上没有性能提升(即加速)进行xorl了xorq.

我实际上不只是一个问题:

1. 为什么gcc更喜欢32位版本？
2. 为什么gcc会停止xorl并且不使用xorw？
3. 有没有xorl比这更快的机器xorq？
4. 如果可能的话,总是更喜欢32位寄存器/操作而不是64位寄存器/操作吗？