标签: optimization

我有一个神经网络的大量PHP对象,我必须迭代它并执行一些数学运算.我想知道我是否会更好地在类的实例上使用关联数组？

我正在处理周围的3640对象并在此基础上迭代500(最好),因此任何微优化都有很大帮助.它不可避免地会$object['value']比这更快$object->value吗？

编辑:所以他们都是一样的.但我想构造函数会有一点开销吗？无论哪种方式,我都不认为我想在我的漂亮类中交换脏数组:P

我一直想知道,在Javascript中使用命名函数和匿名函数之间是否存在性能差异？

for (var i = 0; i < 1000; ++i) {
    myObjects[i].onMyEvent = function() {
        // do something
    };
}

VS

function myEventHandler() {
    // do something
}

for (var i = 0; i < 1000; ++i) {
    myObjects[i].onMyEvent = myEventHandler;
}

第一个是更整洁,因为它不会使用很少使用的函数使代码混乱,但重要的是你多次重新声明该函数是否重要？

我今天在unix中发现了"time"命令,并认为我会用它来检查Haskell中尾递归和正常递归函数之间运行时的差异.

我写了以下函数:

--tail recursive
fac :: (Integral a) => a -> a
fac x = fac' x 1 where
    fac' 1 y = y
    fac' x y = fac' (x-1) (x*y) 

--normal recursive
facSlow :: (Integral a) => a -> a
facSlow 1 = 1
facSlow x = x * facSlow (x-1)

这些都是有效的,记住它们只是用于这个项目,所以我没有费心去检查零或负数.

但是,在为每个编写一个main方法,编译它们,并使用"time"命令运行它们时,两者都具有相似的运行时,正常的递归函数使尾递归函数边缘化.这与我在lisp中关于尾递归优化的内容相反.这是什么原因？

想象一下,我有两个无符号字节b和x.我需要计算bsubas b - x和baddas b + x.但是,我不希望在这些操作期间发生下溢/溢出.例如(伪代码):

b = 3; x = 5;
bsub = b - x; // bsub must be 0, not 254

和

b = 250; x = 10;
badd = b + x; // badd must be 255, not 4

显而易见的方法包括分支:

bsub = b - min(b, x);
badd = b + min(255 - b, x);

我只是想知道是否有更好的方法来做到这一点,即通过一些hacky位操作？

当我将LIMIT 1添加到MySQL查询时,它是否在找到1个结果后停止搜索(从而使其更快)或者它仍然获取所有结果并在结束时截断？

我与Kohana建立的网站昨天遭到了大量的流量冲击,导致我退后一步并评估一些设计.我很好奇什么是优化基于Kohana的应用程序的标准技术？

我也对基准测试感兴趣.我是否需要设置Benchmark::start()和Benchmark::stop()使用每个控制器方法才能查看所有页面的执行时间,或者我是否能够全局且快速地应用基准测试？

我将在未来更多时间使用Cache-library,但我愿意接受更多建议,因为我确信我能做很多事情,我现在根本不知道.

从StringJava中删除所有不可打印字符的最快方法是什么？

到目前为止,我已经尝试并测量了138字节,131个字符的字符串:

• 字符串replaceAll()- 最慢的方法
  • 517009结果/秒
• 预编译模式,然后使用匹配器 replaceAll()
  • 637836结果/秒
• 使用StringBuffer,codepointAt()逐个获取代码点并附加到StringBuffer
  • 711946结果/秒
• 使用StringBuffer,charAt()逐个获取字符并附加到StringBuffer
  • 1052964结果/秒
• 预分配char[]缓冲区,charAt()逐个获取字符并填充此缓冲区,然后转换回String
  • 2022653结果/秒
• 预分配2个char[]缓冲区 - 旧的和新的,一次获取现有String的所有字符,getChars()逐个迭代旧缓冲区并填充新缓冲区,然后将新缓冲区转换为String - 我自己的最快版本
  • 2502502结果/秒
• 与2个缓冲区相同的东西 - 仅使用byte[],getBytes()并指定编码为"utf-8"
  • 857485结果/秒
• 具有2个byte[]缓冲区的相同内容,但将编码指定为常量Charset.forName("utf-8")
  • 791076结果/秒
• 与2个byte[]缓冲区相同的东西,但指定编码为1字节本地编码(几乎没有理智的事情要做)
  • 370164结果/秒

我最好的尝试如下:

    char[] oldChars = new char[s.length()];
    s.getChars(0, s.length(), oldChars, 0);
    char[] newChars = new char[s.length()];
    int newLen = 0;
    for (int j = 0; j < s.length(); …

所以,我有这个代码:

constexpr unsigned N = 1000;
void f1(char* sum, char* a, char* b) {
    for(int i = 0; i < N; ++i) {
        sum[i] = a[i] + b[i];
    }
}

void f2(char* sum, char* a, char* b) {
    char* end = sum + N;
    while(sum != end) {
        *sum++ = *a++ + *b++;
    }
}

我想看看GCC 4.7.2会产生的代码.所以我跑了g++ -march=native -O3 -masm=intel -S a.c++ -std=c++11并获得了以下输出:

        .file   "a.c++"
        .intel_syntax noprefix
        .text
        .p2align 4,,15
        .globl  _Z2f1PcS_S_
        .type   _Z2f1PcS_S_, @function
_Z2f1PcS_S_:
.LFB0:
        .cfi_startproc …

这与你可以使用Python生成器函数有什么相反？:python生成器,生成器表达式和itertools模块是我最近python的一些特性.它们在设置操作链以在大量数据上执行时特别有用 - 我经常在处理DSV文件时使用它们.

那么什么时候不是使用生成器,生成器表达式或itertools函数的好时机？

• 当我应该喜欢zip()过itertools.izip(),或
• range()结束xrange(),或
• [x for x in foo]结束(x for x in foo)？

显然,我们最终需要将生成器"解析"为实际数据,通常是通过创建列表或使用非生成器循环对其进行迭代.有时我们只需知道长度.这不是我要问的.

我们使用生成器,因此我们不会将新列表分配给内存以用于临时数据.这对于大型数据集尤其有用.对于小型数据集也有意义吗？有明显的内存/ CPU权衡吗？

考虑到列表理解性能与map()和filter()的开放性讨论,我特别感兴趣的是,如果有人对此做了一些分析.(alt链接)

正如Knuth所说,

我们应该忘记小的效率,大约97%的时间说:过早的优化是所有邪恶的根源.

这是Stack Overflow常常出现的问题,例如"哪个是最有效的循环机制","SQL优化技术？"等问题.(等等).这些优化提示问题的标准答案是分析您的代码并首先查看它是否是一个问题,如果不是,那么您的新技术就不再需要了.

我的问题是,如果某种技术不同但不是特别模糊或混淆,那真的可以被认为是过早的优化吗？

这是Randall Hyde的一篇名为"过早优化的谬误"的相关文章.