相关疑难解决方法(0)

Python有一个有趣的for语句,允许您指定一个else子句.

在像这样的结构中:

for i in foo:
  if bar(i):
    break
else:
  baz()

该else子句在之后执行for,但仅在for正常终止时(不是由a break)终止.

我想知道C++中是否有相同的东西？我可以用for ... else吗？

在这段代码中,我正在比较两个功能相同的循环的性能:

for (int i = 1; i < v.size()-1; ++i) {
  int a = v[i-1];
  int b = v[i];
  int c = v[i+1];

  if (a < b  &&  b < c)
    ++n;
}

和

for (int i = 1; i < v.size()-1; ++i) 
  if (v[i-1] < v[i]  &&  v[i] < v[i+1])
    ++n;

在优化标志设置为O2:的许多不同C++编译器中,第一个运行速度明显慢于第二个编译器:

• 使用Clang 3.7.0,第二个循环现在慢了约330%
• 使用gcc 4.9.3,第二次循环慢约2%
• 使用Visual C++ 2015,第二个循环慢约2%

我很困惑,现代C++优化器在处理这种情况时遇到了问题.任何线索为什么？我是否必须编写丑陋的代码而不使用临时变量才能获得最佳性能？

现在,使用临时变量可以使代码更快,有时甚至更快.到底是怎么回事？

我正在使用的完整代码如下:

#include <algorithm>
#include <chrono>
#include <random>
#include <iomanip>
#include <iostream>
#include …

我想知道Java中的一些情况(或更一般地说:在编程中),当布尔表达式中首选使用unconditional AND(&)而不是条件版本(&&)时.

我知道它们是如何工作的,但我不能考虑使用单一的情况&是值得的.

考虑下一个代码:

unsigned idx;
//.. some work with idx
if( idx >= idx_max )
    idx %= idx_max;

可以简化为仅第二行:

idx %= idx_max;

并将取得同样的结果.

好几次我遇到了下一个代码:

unsigned x;
//... some work with x
if( x!=0 )
  x=0;

可以简化为

x=0;

问题:

• 有什么意义可以使用if,为什么？特别是使用ARM Thumb指令集.
• 这些if可以省略吗？
• 编译器有什么优化？

我刚刚阅读了有关Branch-Prediction的内容,并想尝试使用Java 8 Streams.

然而,Streams的性能总是比传统的循环更差.

int totalSize = 32768;
int filterValue = 1280;
int[] array = new int[totalSize];
Random rnd = new Random(0);
int loopCount = 10000;

for (int i = 0; i < totalSize; i++) {
    // array[i] = rnd.nextInt() % 2560; // Unsorted Data
    array[i] = i; // Sorted Data
}

long start = System.nanoTime();
long sum = 0;
for (int j = 0; j < loopCount; j++) {
    for (int c = 0; c < totalSize; …

注意:我认为,所谓的重复问题主要与"<"和">"比较有关,但与"=="比较无关,因此不回答我关于"=="运算符性能的问题.

很长一段时间,我相信"处理"排序数组应该比未排序数组更快.起初,我认为在排序数组中使用"=="应该比未排序数组更快,因为 - 我猜 - 分支预测如何工作:

UNSORTEDARRAY:

5 == 100 F
43 == 100 F
100 == 100 T
250 == 100 F
6 == 100 F
(other elements to check)

SORTEDARRAY:

5 == 100 F
6 == 100 F
43 == 100 F
100 == 100 T
(no need to check other elements, so all are F)

所以我猜SORTEDARRAY应该比UNSORTEDARRAY更快,但今天我用代码在标题中生成2个数组进行测试,并且分支预测似乎不像我想的那样工作.

我生成了一个未排序的数组和一个排序的数组来测试:

srand(time(NULL));
int UNSORTEDARRAY[524288];
int SORTEDARRAY[sizeof(UNSORTEDARRAY)/sizeof(int)];
for(int i=0;i<sizeof(SORTEDARRAY)/sizeof(int);i++){
    SORTEDARRAY[i]=UNSORTEDARRAY[i]=rand();
}
sort(SORTEDARRAY,SORTEDARRAY+sizeof(SORTEDARRAY)/sizeof(int));
string u="const int UNSORTEDARRAY[]={";
string s="const int SORTEDARRAY[]={";
for(int i=0;i<sizeof(UNSORTEDARRAY)/sizeof(int);i++){ …

我正在阅读那个分支错误预测可能是应用程序性能的热门瓶颈.正如我所看到的,人们经常会显示汇编代码来揭示问题,并指出程序员通常可以预测分支在大多数时间内的位置并避免分支错误预测.

我的问题是:

1-是否可以使用某种高级编程技术(即无汇编)来避免分支错误预测？

2-我应该记住用高级编程语言生成分支友好的代码(我最感兴趣的是C和C++)？

欢迎使用代码示例和基准测试!

这里有两个解决方案,在Cay Horstmann的Scala for the Impatient中运用4.9:"写一个函数lteqgt(values:Array [Int],v:Int),它返回一个包含小于v的值的三元组,等于v,并且大于v." 一个使用尾递归,另一个使用while循环.我认为两者都会编译成类似的字节码,但是while循环比尾递归慢了近两倍.这告诉我,我的while方法编写得很糟糕.

import scala.annotation.tailrec
import scala.util.Random
object PerformanceTest {

  def main(args: Array[String]): Unit = {
    val bigArray:Array[Int] = fillArray(new Array[Int](100000000))
    println(time(lteqgt(bigArray, 25)))
    println(time(lteqgt2(bigArray, 25)))
  }

  def time[T](block : => T):T = {
    val start = System.nanoTime : Double
    val result = block
    val end = System.nanoTime : Double
    println("Time = " + (end - start) / 1000000.0 + " millis")
    result
  }

  @tailrec def fillArray(a:Array[Int], pos:Int=0):Array[Int] = {
    if (pos == a.length)
      a
    else { …

我已经介绍过了,现在我正在寻找可以从我的热点中挤出一切可能的性能.

我知道[MethodImplOptions.AggressiveInlining]和ProfileOptimization类.还有其他人吗？

[编辑] 我刚刚发现了[TargetedPatchingOptOut].没关系,显然不需要一个.

假设我们有一系列这样的整数:

const int size = 100000;
int array[size];
//set some items to 0 and other items to 1

我想将所有值为1的项替换为另一个值,例如123456.这可以通过以下方式轻松实现:

for(int i = 0; i < size ; i++){
    if(array[i] != 0) 
        array[i] = 123456;
}

出于好奇,有没有更快的方法来做到这一点,通过某种x86技巧,或者这是处理器的最佳代码？