Tag: 性能

O（log N）== O（1） – 为什么不呢？

每当我考虑algorithm/数据结构，我倾向于用常量来replacelog（N）部分。 哦，我知道日志（N）分歧 – 但在真实世界的应用程序中是否重要？ 日志（无穷远）<100为实际目的。 我真的很好奇现实世界的例子，这不成立。 澄清： 我明白O（f（N）） 我很好奇真实世界的例子， 渐近行为比实际performance的常量更重要。 如果log（N）可以被一个常量替代，它仍然可以用O（N log N）中的一个常量代替。 这个问题是为了（a）娱乐和（b）收集争论的使用，如果我再次（关于devise的performance）的争议。

二进制堆的有效实现

我在寻找如何有效地实现二进制堆的信息 。 我觉得应该有一个好的文章有关实施堆，但我还没有find一个。 事实上我一直没有find任何有关如何将数据堆存储在基础之上的有效实现方面的资源。 我正在寻找制作快速二进制堆的技术，超出了我在下面描述的范围。 我已经写了一个比Microsoft Visual C ++和GCC的std :: priority_queue更快的C ++实现，或者使用std :: make_heap，std :: push_heap和std :: pop_heap。 以下是我在实现中已经涉及到的技术。 我自己只提出了最后两个，但我怀疑这些是新的想法： （编辑：增加内存优化部分） 从1开始索引 查看二维堆的维基百科实现注释 。 如果堆的根位于索引0处，则索引n处的父节点，左节点和右节点的公式分别为（n-1）/ 2,2n + 1和2n + 2。 如果使用基于1的数组，那么公式将变得更简单n / 2，2n和2n + 1.因此，在使用基于1的数组时，父项和左项是更高效的。 如果p指向一个基于0的数组，并且q = p-1，那么我们可以像q [1]那样访问p [0]，所以在使用基于1的数组时没有开销。 在更换叶子之前，将popup/移除元素移到堆的底部 在一个堆上popup通常是通过replace最左边的底部叶子的顶部元素，然后将其向下移动直到堆属性被恢复来描述。 这要求每个级别进行2次比较，而且我们可能会在堆栈顶部移动一个叶子，因此可能会走得很远。 所以我们应该期望有less于2个log n的比较。 相反，我们可以在堆顶部留下一个洞。 然后，我们通过迭代地将更大的孩子向上移动，将这个洞向下移动。 这只需要我们通过每个级别1比较。 这样孔就会变成一片叶子。 在这一点上，我们可以将最右边的底部叶子移动到洞的位置，并移动该值直到堆属性恢复。 既然我们移动的价值是一片叶子，我们不期望它移动到树上很远。 所以我们应该期待比log n比较多一点，这比以前更好。 支持replace顶部 假设你想删除最大的元素，并插入一个新的元素。 […]

插入USB热点后，简单的Java程序速度降低了100倍

我有以下Java程序： class Main { public static void main(String[] args) throws java.io.IOException { long start = System.nanoTime(); java.io.File.createTempFile("java_test", ".txt").delete(); System.out.println((System.nanoTime() – start ) / 1e9); } } 通常情况下，执行需要大约63毫秒的时间： $ java Main 0.06308555 但是，一旦我连接Android手机作为USB热点，它需要更长的时间。 根据不同的机器从3到40秒： $ java Main 4.263285528 奇怪的是，这里没有任何东西实际上通过networking传输 – 插入的networking适配器应该不重要。 我做了一个回溯，看起来大部分时间都花在了NetworkInterface.getAll方法上： "main" #1 prio=5 os_prio=0 tid=0x00000000023ae000 nid=0x142c runnable [0x000000000268d000] java.lang.Thread.State: RUNNABLE at java.net.NetworkInterface.getAll(Native Method) at […]

更快的加权抽样无需更换

这个问题导致了一个新的R包： wrswoR R的默认采样无需使用sample.int进行replace，似乎需要二次运行时间，例如使用从均匀分布中抽取的权重。 对于大样本，这很慢。 有谁知道一个更快的实现，可以从R内使用 ？ 两种select是“拒绝采样replace”（请参阅​​stats.sx上的这个问题 ）和Wong和Easton（1980）的algorithm（在StackOverflow答案中使用Python实现）。 感谢Ben Bolker暗示在sample.int被调用replace=F和非均匀权重时被内部调用的C函数： ProbSampleNoReplace 。 实际上，代码显示了两个嵌套for循环（ random.c ）。 以下是根据经验分析运行时间的代码： library(plyr) sample.int.test <- function(n, p) { sample.int(2 * n, n, replace=F, prob=p); NULL } times <- ldply( 1:7, function(i) { n <- 1024 * (2 ** i) p <- runif(2 * n) data.frame( n=n, user=system.time(sample.int.test(n, p), gcFirst=T)['user.self']) }, .progress='text' […]

AWS RDS预置IOPS真的值得吗？

据我了解，与标准I / O速率相比，RDS预置IOPS相当昂贵。 在东京地区，标准部署的P-IOPS费率为0.15美元/ GB，0.12美元/ IOP。 （ 多可用区域部署的价格是双倍的… ） 对于P-IOPS，所需的最小存储量为100GB，IOP为1000.因此，P-IOPS的起始成本为135 $，不包括实例定价。 就我而言，使用P-IOPS的成本比使用标准I / O速率高100倍。 这可能是一个非常主观的问题，但请提出一些意见。 在最优化的RDS P-IOPS数据库中，性能是否值得？ 要么 AWS网站提供了关于P-IOPS如何使性能受益的一些见解。 有没有实际的基准？ 自我解答 除了零斯基尔兹写的答案外，我还做了更多的研究。 不过，请注意，我不是阅读数据库基准testing的专家。 此外，基准和答案是基于EBS。 根据“罗德里戈·坎波斯” 的一篇文章 ，performance确实有了明显的提高。 从1000 IOPS到2000 IOPS，读/写（包括随机读/写）性能加倍。 根据零斯基尔兹所说，标准的EBS块提供了大约100 IOPS。 想象一下当100 IOPS达到1000 IOPS（这是P-IOPS部署的最低IOPS）时性能的改善。 结论 根据基准，性能/价格似乎是合理的。 对于性能危机的情况，我想有些人或公司应该selectP-IOPS，即使它们的收费是100倍以上。 但是，如果我是一个中小企业的财务顾问，那么我会逐渐放大（如CPU，内存）在我的RDS实例上，直到性能/价格与P-IOPS匹配。

数组连接vsstringConcat

哪种方法更快？ arraysjoin： var str_to_split = "a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z"; var myarray = str_to_split.split(","); var output=myarray.join(""); stringConcat： var str_to_split = "a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z"; var myarray = str_to_split.split(","); var output = ""; for (var i = 0, len = myarray.length; i<len; i++){ output += myarray[i]; }

为什么提升matrix乘法比我的慢？

我用boost::numeric::ublas::matrix实现了一个matrix乘法（请参阅我的完整工作boost代码 ） Result result = read (); boost::numeric::ublas::matrix<int> C; C = boost::numeric::ublas::prod(result.A, result.B); 另一个是标准algorithm（见完整的标准代码 ）： vector< vector<int> > ijkalgorithm(vector< vector<int> > A, vector< vector<int> > B) { int n = A.size(); // initialise C with 0s vector<int> tmp(n, 0); vector< vector<int> > C(n, tmp); for (int i = 0; i < n; i++) { for […]

使用AVX intrinsics而不是SSE不会提高速度 – 为什么？

我一直在使用英特尔的SSE内部函数，并获得了很好的性能提升。 因此，我期望AVX内部函数能够进一步加速我的程序。 不幸的是，直到现在，情况并非如此。 也许我犯了一个愚蠢的错误，所以如果有人能帮助我，我将不胜感激。 我使用Ubuntu 11.10与g ++ 4.6.1。 我编译我的程序（见下文） g++ simpleExample.cpp -O3 -march=native -o simpleExample testing系统有一个Intel i7-2600 CPU。 这里是代表我的问题的代码。 在我的系统上，我得到了输出 98.715 ms, b[42] = 0.900038 // Naive 24.457 ms, b[42] = 0.900038 // SSE 24.646 ms, b[42] = 0.900038 // AVX 请注意，计算sqrt（sqrt（sqrt（x）））只是为了确保内存带宽不限制执行速度; 这只是一个例子。 simpleExample.cpp： #include <immintrin.h> #include <iostream> #include <math.h> #include <sys/time.h> using namespace std; […]

VisualVM和自我时间

我一直在寻找关于在VisualVM中实际引用的“自我时间”的一致和清晰的解释，以及它与“自我时间（cpu）”有何不同。 “自我时间[％]”是指自我时间或自我时间的CPU。 似乎没有太多的文件或至less我没有find它。 所以任何想法/input将不胜感激。

这里我们再次去：在R中追加一个元素到列表中

我不满意接受的答案追加一个对象到R中的分摊恒定时间的列表？ > list1 <- list("foo", pi) > bar <- list("A", "B") 我怎样才能将新的元素bar添加到list1 ？ 很明显， c()不起作用，它使扁平化： > c(list1, bar) [[1]] [1] "foo" [[2]] [1] 3.141593 [[3]] [1] "A" [[4]] [1] "B" 指定作品索引： > list1[[length(list1)+1]] <- bar > list1 [[1]] [1] "foo" [[2]] [1] 3.141593 [[3]] [[3]][[1]] [1] "A" [[3]][[2]] [1] "B" 这种方法的效率是多less？ 有没有更优雅的方式？