标签: performance

为什么这段代码,

const float x[16] = {  1.1,   1.2,   1.3,     1.4,   1.5,   1.6,   1.7,   1.8,
                       1.9,   2.0,   2.1,     2.2,   2.3,   2.4,   2.5,   2.6};
const float z[16] = {1.123, 1.234, 1.345, 156.467, 1.578, 1.689, 1.790, 1.812,
                     1.923, 2.034, 2.145,   2.256, 2.367, 2.478, 2.589, 2.690};
float y[16];
for (int i = 0; i < 16; i++)
{
    y[i] = x[i];
}

for (int j = 0; j < 9000000; j++)
{
    for (int i = 0; i < 16; i++)
    {
        y[i] *= …

计算对象的键/属性数的最快方法是什么？它可以在不迭代对象的情况下完成此操作吗？即没有做

var count = 0;
for (k in myobj) if (myobj.hasOwnProperty(k)) count++;

(Firefox确实提供了一个神奇的__count__属性,但是在版本4的某个地方删除了它.)

我一直在寻找最快的方法来处理popcount大数据.我遇到了一个很奇怪的效果:改变从循环变量unsigned至uint64_t50%在我的电脑上所做的性能下降.

基准

#include <iostream>
#include <chrono>
#include <x86intrin.h>

int main(int argc, char* argv[]) {

    using namespace std;
    if (argc != 2) {
       cerr << "usage: array_size in MB" << endl;
       return -1;
    }

    uint64_t size = atol(argv[1])<<20;
    uint64_t* buffer = new uint64_t[size/8];
    char* charbuffer = reinterpret_cast<char*>(buffer);
    for (unsigned i=0; i<size; ++i)
        charbuffer[i] = rand()%256;

    uint64_t count,duration;
    chrono::time_point<chrono::system_clock> startP,endP;
    {
        startP = chrono::system_clock::now();
        count = 0;
        for( unsigned k = 0; k < …

Python 2.6引入了该str.format()方法,其语法与现有%运算符略有不同.哪种情况更好,哪种情况更好？

1. 以下使用每种方法并具有相同的结果,那么有什么区别？

   #!/usr/bin/python
   sub1 = "python string!"
   sub2 = "an arg"
   
   a = "i am a %s" % sub1
   b = "i am a {0}".format(sub1)
   
   c = "with %(kwarg)s!" % {'kwarg':sub2}
   d = "with {kwarg}!".format(kwarg=sub2)
   
   print a    # "i am a python string!"
   print b    # "i am a python string!"
   print c    # "with an arg!"
   print d    # "with an arg!"
   

   Run Code Online (Sandbox Code Playgroud)

2. 此外,何时在Python中发生字符串格式化？例如,如果我的日志记录级别设置为HIGH,我仍然会执行以下%操作吗？如果是这样,有没有办法避免这种情况？

   log.debug("some debug info: %s" % some_info)
   

   Run Code Online (Sandbox Code Playgroud)

如何更快地使用Eclipse体验？

例如:我禁用了我不需要的所有插件(Mylyn,Subclipse,...).

我没有为Mercurial使用插件,而是将TortoiseHG配置为外部工具.

我昨天做了评论,其中有人曾用一个答案[0123456789]的正则表达式,而不是[0-9]或\d.我说使用范围或数字说明符比使用字符集更有效.

我决定今天测试一下,并且我惊讶地发现(至少在C#正则表达式引擎中)\d似乎效率低于其他两个似乎没有太大差别的.这是我的10000个随机字符串1000个随机字符的测试输出,其中5077实际上包含一个数字:

Regular expression \d           took 00:00:00.2141226 result: 5077/10000
Regular expression [0-9]        took 00:00:00.1357972 result: 5077/10000  63.42 % of first
Regular expression [0123456789] took 00:00:00.1388997 result: 5077/10000  64.87 % of first

令我惊讶的是有两个原因:

1. 我原以为该范围的实施要比套装更有效.
2. 我无法理解为什么\d会比这更糟糕[0-9].还有\d简单的简写[0-9]吗？

这是测试代码:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.Text.RegularExpressions;

namespace SO_RegexPerformance
{
    class Program
    {
        static void Main(string[] args)
        {
            var rand = new …

项目欧拉和其他编码竞赛通常有最长的运行时间或人们吹嘘他们的特定解决方案运行的速度.使用python,有时候这些方法有点像kludgey - 即添加时间码__main__.

分析python程序运行多长时间的好方法是什么？

我对DB的了解有限,并且只使用DB作为应用程序员.我想知道Clustered和Non clustered indexes.我用谷歌搜索,发现的是:

聚簇索引是一种特殊类型的索引,它重新排序表中记录的物理存储方式.因此,表只能有一个聚簇索引.聚簇索引的叶节点包含数据页.非聚簇索引是一种特殊类型的索引,其中索引的逻辑顺序与磁盘上行的物理存储顺序不匹配.非聚簇索引的叶节点不包含数据页.相反,叶节点包含索引行.

我在SO中发现的是聚簇索引和非聚簇索引之间有什么区别？.

有人可以用简单的英语解释这个吗？

我想要的是开始在我的代码中的某个地方计算时间,然后获得通过的时间,以测量执行少量功能所花费的时间.我认为我使用的是timeit模块错误,但文档对我来说只是让人困惑.

import timeit

start = timeit.timeit()
print("hello")
end = timeit.timeit()
print(end - start)

我在Swift Beta中实现了一个算法,并注意到性能非常差.在深入挖掘之后,我意识到其中一个瓶颈就像排序数组一样简单.相关部分在这里:

let n = 1000000
var x =  [Int](repeating: 0, count: n)
for i in 0..<n {
    x[i] = random()
}
// start clock here
let y = sort(x)
// stop clock here

在C++中,类似的操作在我的计算机上需要0.06秒.

在Python中,它需要0.6秒(没有技巧,只有y =排序(x)表示整数列表).

在Swift中,如果我使用以下命令编译它需要6秒:

xcrun swift -O3 -sdk `xcrun --show-sdk-path --sdk macosx`

如果我使用以下命令编译它需要多达88秒:

xcrun swift -O0 -sdk `xcrun --show-sdk-path --sdk macosx`

Xcode中使用"Release"与"Debug"构建的计时相似.

这有什么不对？与C++相比,我可以理解一些性能损失,但与纯Python相比,速度没有降低10倍.

编辑:天气注意到,改变-O3以-Ofast使这个代码的运行几乎一样快如C++版本!但是,-Ofast更改了语言的语义 - 在我的测试中,它禁用了对整数溢出和数组索引溢出的检查.例如,使用-Ofast以下Swift代码以静默方式运行而不会崩溃(并打印出一些垃圾):

let …