相关疑难解决方法(0)

我有一个应用程序,我已经重新考虑了因此我相信它现在更快了.人们不可能感觉到差异,但理论上,应用程序应该运行得更快.通常我不在乎,但由于这是我的硕士学位项目的一部分,我想支持我的说法,即重新分解不仅会带来改进的设计和"更高的质量",而且还会提高性能应用程序(一个小玩具物 - 火车组模拟).

我今天玩了最新的VisualVM东西大约四个小时,但我无法从中得到任何帮助.没有(或者我没有找到)简单地比较两个版本(重构前和重构后)的分析结果的方法.

从更快的应用程序版本中简单地告诉较慢的方法是什么是最简单,最直接的方法.两者的差异必然会对绩效产生影响.谢谢.

这是一个危险的问题,所以让我试着正确地说出来.过早优化是所有邪恶的根源,但如果你知道你需要它,那么应该考虑一套基本的规则.这套是我想知道的.

例如,假设您有几千个项目的列表.如何查找具有特定ID的项目？当然,您只需使用Dictionary将ID映射到项目.

如果您知道存储在数据库中的设置始终是必需的,那么您只需缓存它而不是每秒发送数百次数据库请求.

甚至可以像在prod中使用发行版而不是调试版本一样简单.

我想还有一些更基本的想法.

我特别不是在寻找"不要这样做,对于专家:不要这样做"或"使用探查器"的答案,但对于非常简单的一般提示.如果你觉得这是一个争论性的问题,你可能会误解我的意图.

我也不是在寻找任何项目的具体建议,也不是任何复杂的低级技巧.可以将其视为如何避免作为初学者所犯的最重要的性能错误的概述.

编辑:这可能是我正在寻找的一个很好的描述:为具有基本技术理解的人创建一个共同优化规则的演示文稿(不是一个实际例子)(假设他们获得了CS学位)但由于某种原因从未写了一行代码.指出最重要的方面.伪代码很好.不要假设特定语言甚至架构.

我设置了一个(可能是非常不科学的)小测试,以确定单级单继承中虚函数的开销,并且我得到的结果在多态访问派生类或直接访问它时完全相同.有点令人惊讶的是当任何函数被声明为虚拟时引入的计算时间的数量级(参见下面的结果).

在声明成员函数时会有这么多开销吗？为什么即使直接访问派生类时它仍然存在？

代码如下:

class base
{
public:
    virtual ~base() {}
    virtual uint func(uint i) = 0;
};

class derived : public base
{
public:
    ~derived() {}
    uint func(uint i) { return i * 2; }
};

uint j = 0;
ulong k = 0;
double l = 0;
ushort numIters = 10;
base* mybase = new derived;  // or derived* myderived = ...

for(ushort i = 0; i < numIters; i++)
{
  clock_t start2, finish2;
  start2 = clock();

  for (uint …

首先,我应该提一下,我知道性能优化可能非常符合项目.我现在大部分时间都没有遇到这些特殊问题.我面临着JVM本身的一系列性能问题.

我现在想知道:

• 哪个代码优化从编译器的角度来看是有意义的:例如,为了支持垃圾收集器,我将变量声明为final - 非常依赖PMD的Eclipse建议.
• 有什么最佳实践:vmargs,堆和其他东西传递给JVM进行初始化.我如何在这里获得正确的值？有没有公​​式或是尝试和错误？

Java自动化很多,在字节码级和内容上做了很多优化.但是我认为大部分内容必须由开发人员来规划才能工作.

那么如何加速Java程序呢？:)

我在剖析中是个假人,请告诉我你的人如何分析你的申请.哪一个更好,分析整个应用程序或隔离？如果选择是隔离你如何做到这一点？

我有一个Ruby程序,大约需要4分钟才能完成任务,我想把它降到1分钟以下.

我尝试了宝石中的ruby-prof,但是它使运行时间增加到约30分钟,甚至看起来都没有特别好地保持单调性(一些变化可靠地提高了性能 - 使用剖析器并且可靠地降低了性能 - 没有剖析器).此任务也无法真正分解为可以独立进行有意义分析的部分.

目前以最低开销分析Ruby代码的最佳方法是什么？

我使用OSX,但如果由于任何原因,探测器需要另一个操作系统,我可能会重新启动.

编辑:perftools.rb具有更低的开销,但结果看起来相当可疑诚实,超出任何合理的抽样错误 - 至少它必须搞乱GC或i/o缓冲或类似的东西,导致很多愚蠢的错误归因.它仍然击败了ruby-prof.

我会保持问题公开,万一有人知道比这更好的事情.

我在我的位置上很新,所以在表达担忧之前我应该​​三思而后行,但我看到的一些代码......

当我试图提高可读性时,我被告知并不总是有时间,效率更重要.

但后来我看到不同类型的循环中的变量重新声明,有时下降到两个级别.我的一部分认为 - 不要那样做!但另一部分说 - 无论如何,这个复杂的功能应该分解成几个功能.那些较小的函数可以有临时变量,编译器应该能够处理它们.

然后函数调用会增加一些额外的成本.让我试着想出两个例子:

Class1::Do1()
{
    for (int i = 0; i < 100; i++)
    {
        bool x = GetSomeValue();
        ...
        if (x)
        {
            ...
        }
    } 
}

VS

Class1::Do1()
{
    bool x = false;
    for (int i = 0; i < 100; i++)
    {
        x = GetSomeValue();
        ...
        if (x)
        {
            ...
        }
    } 
}

VS

Class1::Do1()
{
    for (int i = 0; i < 100; i++)
    {
        Do2();
    } 
}

Class1::Do2()
{
    bool x …

今天我正在编写代码,当时我偶然发现了一些事情,并没有想到它是否有任何影响.

这有两种方法可以做同样的事情

if(foo != true)
{
bar ++;
}

if(foo == true)
{
}
else
{
bar ++;
}

现在我知道编译器可能会将它优化为同样的东西,但我想知道它们的区别,因为你不能总是指望它们.

我的问题是第二种选择是否真的会产生某种惩罚,因为它会给支票添加另一个命令？

是的,这是一个错字.

我在Objective-c中实现了几乎相同的代码,它的运行速度比Java快两到三倍.我正在试图找出哪些指令可能是最耗费资源的,并且看看是否有更好的方法来做同样的事情,这在Java中更有效.

这是从数据库中读取大型结果集的例程的一部分,对于返回的每个单词,它会检查该单词是否可以从播放器具有的字母区块中创建.它包括对空白图块的支持,可以用作任何字母.空白图块将由下划线字符表示.

基本上,对于从数据库返回的每个单词,我遍历单词的每个字母,并查看可用字母的玩家数组.如果我找到那封信,我将其从玩家阵列中移除并继续前进.如果我没有找到该字母,则该字被丢弃并且下一个字被读取.除非,我在播放器的数组中找到一个下划线字符,然后,我将使用它作为字母,并将其从数组中删除.如果我到达数据库字的字母数组的末尾并且每个字母都"找到",那么该单词将保存在列表中.

我已经计时了整个函数的各个部分,数据库查询发生得非常快.这只是对这个游标的处理非常慢.任何建议,将不胜感激!

if (c.moveToFirst()) {

    do { 
        boolean found = false;
        int aValue = 0;
        int letterValue = 0;

        // Word and Word's length from the database
        String sWord = c.getString(0);
        int wordLength = c.getInt(1);

        // Refresh the Tile array, underscores sorted to the front
        // sortedTiles sorted the players tiles {_,_,a,b,c}
        char[] aTiles = sortedTiles.clone();

        // Calculate the value of the word
        for (int i = 0; i < wordLength; i++) {

            // For each character in …

对于大学讲座,我正在寻找具有已知渐近运行时的浮点算法,但是可以进行低级(微)优化.这意味着优化,例如最小化缓存未命中和寄存器溢出,最大化指令级并行性以及利用新CPU上的SIMD(向量)指令.优化将特定于CPU,并将使用适用的指令集扩展.

经典的教科书示例是矩阵乘法,通过简单地重新排序存储器访问序列(以及其他技巧)可以实现极大的加速.另一个例子是FFT.不幸的是,我不允许选择其中任何一个.

任何人有任何想法,或可以使用提升的算法/方法？

我只对可以想象每线程加速的算法感兴趣.通过多线程并行解决问题很好,但不是本讲座的范围.

编辑1:我走的过程中,没有教它.在过去几年中,有不少项目在性能方面成功超越了当前最佳实施.

编辑2:本文列出了(从第11页开始)七类重要的数值方法和一些使用它们的相关算法.至少一些提到的算法是候选者,但是很难看出哪个算法.

编辑3:谢谢大家的好建议!我们建议实施曝光融合算法(2007年的论文),我们的提案被接受了.该算法创建类似HDR的图像,主要包括小核卷积,然后是源图像的加权多分辨率混合(在拉普拉斯金字塔上).我们感兴趣的是,该算法已经在广泛使用的Enfuse工具中实现,该工具现在的版本为4.1.因此,我们将能够验证和比较我们的结果与原始结果,也可能有助于工具本身的开发.如果可以的话,我将在未来更新这篇文章.