최신 하드웨어에서 부동 소수점 대 정수 계산

저는 C ++에서 성능에 중요한 작업을 수행하고 있으며 현재 "더 빠르기"때문에 본질적으로 부동 소수점 문제에 정수 계산을 사용하고 있습니다. 이로 인해 성가신 문제가 많이 발생하고 성가신 코드가 많이 추가됩니다.

이제 저는 부동 소수점 계산이 약 386 일 동안 얼마나 느 렸는지 읽은 기억이납니다. 여기서 (IIRC) 선택적 공동 프로세서가 있다고 믿습니다. 하지만 요즘에는 기하 급수적으로 더 복잡하고 강력한 CPU를 사용하여 부동 소수점 또는 정수 계산을 수행하는 경우 "속도"에 차이가 없습니다. 특히 실제 계산 시간이 파이프 라인 지연을 일으키거나 주 메모리에서 무언가를 가져 오는 것과 비교하여 매우 작기 때문에?

정답은 대상 하드웨어에서 벤치마킹하는 것입니다.이를 테스트하는 좋은 방법은 무엇입니까? 나는 두 개의 작은 C ++ 프로그램을 작성하고 그들의 실행 시간을 Linux의 "시간"과 비교했지만 실제 실행 시간은 너무 가변적입니다 (가상 서버에서 실행하는 데 도움이되지 않습니다). 하루 종일 수백 개의 벤치 마크를 실행하고 그래프를 작성하는 데 소요되는 시간이 부족합니다. 상대 속도를 합리적으로 테스트하기 위해 할 수있는 일이 있습니까? 어떤 아이디어 나 생각? 내가 완전히 틀렸습니까?

내가 다음과 같이 사용한 프로그램은 어떤 식 으로든 동일하지 않습니다.

#include <iostream>
#include <cmath>
#include <cstdlib>
#include <time.h>

int main( int argc, char** argv )
{
    int accum = 0;

    srand( time( NULL ) );

    for( unsigned int i = 0; i < 100000000; ++i )
    {
        accum += rand( ) % 365;
    }
    std::cout << accum << std::endl;

    return 0;
}

프로그램 2 :

#include <iostream>
#include <cmath>
#include <cstdlib>
#include <time.h>

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

    float accum = 0;
    srand( time( NULL ) );

    for( unsigned int i = 0; i < 100000000; ++i )
    {
        accum += (float)( rand( ) % 365 );
    }
    std::cout << accum << std::endl;

    return 0;
}

미리 감사드립니다!

편집 : 내가 관심있는 플랫폼은 데스크톱 Linux 및 Windows 시스템에서 실행되는 일반 x86 또는 x86-64입니다.

편집 2 (아래 주석에서 붙여 넣기) : 현재 광범위한 코드 기반이 있습니다. 정말로 나는 우리가 "정수 계산이 더 빠르기 때문에 float를 사용해서는 안된다"는 일반화에 반대했습니다. 그리고이 일반화 된 가정을 반증 할 방법을 찾고 있습니다. 모든 작업을 수행하고 나중에 프로파일 링하지 않으면 정확한 결과를 예측할 수 없다는 것을 알고 있습니다.

어쨌든, 모든 훌륭한 답변과 도움에 감사드립니다. 다른 것을 추가해도됩니다. :).

아아, 나는 당신에게 "그것에 달려있다"대답 만 줄 수 있습니다 ...

내 경험으로 볼 때 성능에 대한 많은 변수가 있습니다. 특히 정수와 부동 소수점 수학 사이에 있습니다. 프로세서마다 "파이프 라인"길이가 다르기 때문에 프로세서마다 크게 다릅니다 (x86과 같은 동일한 제품군 내에서도). 또한 일부 작업은 일반적으로 매우 간단하고 (예 : 추가) 프로세서를 통해 가속화 된 경로를 가지며 다른 작업 (예 : 분할)은 훨씬 더 오래 걸립니다.

다른 큰 변수는 데이터가있는 곳입니다. 추가 할 값이 몇 개만있는 경우 모든 데이터가 캐시에 상주하여 CPU로 빠르게 전송 될 수 있습니다. 캐시에 이미 데이터가있는 매우 느린 부동 소수점 연산은 정수를 시스템 메모리에서 복사해야하는 정수 연산보다 몇 배 더 빠릅니다.

성능이 중요한 응용 프로그램을 작업하고 있기 때문에이 질문을한다고 가정합니다. x86 아키텍처 용으로 개발 중이고 추가 성능이 필요한 경우 SSE 확장 사용을 고려할 수 있습니다. 이것은 단 정밀도 부동 소수점 연산 속도를 크게 높일 수 있습니다. 동일한 연산이 여러 데이터에 대해 한 번에 수행 될 수 있고 SSE 연산을위한 별도의 * 레지스터 뱅크가 있기 때문입니다. (두 번째 예제에서 "double"대신 "float"를 사용하여 단 정밀도 수학을 사용하고 있다고 생각합니다.)

* 참고 : 이전 MMX 명령어를 사용하면 실제로 프로그램 속도가 느려집니다. 이전 명령어는 실제로 FPU와 동일한 레지스터를 사용하여 FPU와 MMX를 동시에 사용할 수 없기 때문입니다.

예를 들어 (숫자가 적을수록 빠름),

64 비트 Intel Xeon X5550 @ 2.67GHz, gcc 4.1.2 -O3

short add/sub: 1.005460 [0]
short mul/div: 3.926543 [0]
long add/sub: 0.000000 [0]
long mul/div: 7.378581 [0]
long long add/sub: 0.000000 [0]
long long mul/div: 7.378593 [0]
float add/sub: 0.993583 [0]
float mul/div: 1.821565 [0]
double add/sub: 0.993884 [0]
double mul/div: 1.988664 [0]

32 비트 듀얼 코어 AMD Opteron (tm) 프로세서 265 @ 1.81GHz, gcc 3.4.6 -O3

short add/sub: 0.553863 [0]
short mul/div: 12.509163 [0]
long add/sub: 0.556912 [0]
long mul/div: 12.748019 [0]
long long add/sub: 5.298999 [0]
long long mul/div: 20.461186 [0]
float add/sub: 2.688253 [0]
float mul/div: 4.683886 [0]
double add/sub: 2.700834 [0]
double mul/div: 4.646755 [0]

으로 댄 지적 (어떤이 파이프 라인의 설계 자체에 오해의 소지가 될 수있다) 심지어 한 번 정상화 클럭 주파수, 결과는 격렬하게 CPU 아키텍처에 따라 달라집니다 (개인 ALU / FPU의 성능 , 뿐만 아니라 실제 의 ALU / FPU를 수 사용할 수 당 병렬로 실행할 수있는 독립적 인 작업 수에 영향을주는 슈퍼 스칼라 설계의 핵심입니다 .

가난한 사람의 FPU / ALU 운영 벤치 마크 :

#include <stdio.h>
#ifdef _WIN32
#include <sys/timeb.h>
#else
#include <sys/time.h>
#endif
#include <time.h>
#include <cstdlib>

double
mygettime(void) {
# ifdef _WIN32
  struct _timeb tb;
  _ftime(&tb);
  return (double)tb.time + (0.001 * (double)tb.millitm);
# else
  struct timeval tv;
  if(gettimeofday(&tv, 0) < 0) {
    perror("oops");
  }
  return (double)tv.tv_sec + (0.000001 * (double)tv.tv_usec);
# endif
}

template< typename Type >
void my_test(const char* name) {
  Type v  = 0;
  // Do not use constants or repeating values
  //  to avoid loop unroll optimizations.
  // All values >0 to avoid division by 0
  // Perform ten ops/iteration to reduce
  //  impact of ++i below on measurements
  Type v0 = (Type)(rand() % 256)/16 + 1;
  Type v1 = (Type)(rand() % 256)/16 + 1;
  Type v2 = (Type)(rand() % 256)/16 + 1;
  Type v3 = (Type)(rand() % 256)/16 + 1;
  Type v4 = (Type)(rand() % 256)/16 + 1;
  Type v5 = (Type)(rand() % 256)/16 + 1;
  Type v6 = (Type)(rand() % 256)/16 + 1;
  Type v7 = (Type)(rand() % 256)/16 + 1;
  Type v8 = (Type)(rand() % 256)/16 + 1;
  Type v9 = (Type)(rand() % 256)/16 + 1;

  double t1 = mygettime();
  for (size_t i = 0; i < 100000000; ++i) {
    v += v0;
    v -= v1;
    v += v2;
    v -= v3;
    v += v4;
    v -= v5;
    v += v6;
    v -= v7;
    v += v8;
    v -= v9;
  }
  // Pretend we make use of v so compiler doesn't optimize out
  //  the loop completely
  printf("%s add/sub: %f [%d]\n", name, mygettime() - t1, (int)v&1);
  t1 = mygettime();
  for (size_t i = 0; i < 100000000; ++i) {
    v /= v0;
    v *= v1;
    v /= v2;
    v *= v3;
    v /= v4;
    v *= v5;
    v /= v6;
    v *= v7;
    v /= v8;
    v *= v9;
  }
  // Pretend we make use of v so compiler doesn't optimize out
  //  the loop completely
  printf("%s mul/div: %f [%d]\n", name, mygettime() - t1, (int)v&1);
}

int main() {
  my_test< short >("short");
  my_test< long >("long");
  my_test< long long >("long long");
  my_test< float >("float");
  my_test< double >("double");

  return 0;
}

고정 소수점 수학과 부동 소수점 수학간에 실제 속도에는 상당한 차이가있을 수 있지만 ALU 대 FPU의 이론적 최상의 처리량은 완전히 관련이 없습니다. 대신 계산 (예 : 루프 제어용)에 사용되지 않는 아키텍처의 정수 및 부동 소수점 레지스터 (레지스터 이름이 아닌 실제 레지스터)의 수, 캐시 라인에 맞는 각 유형의 요소 수 , 정수 대 부동 소수점 수학에 대한 서로 다른 의미를 고려하여 최적화가 가능합니다. 이러한 효과가 지배적입니다. 알고리즘의 데이터 종속성은 여기서 중요한 역할을하므로 일반적인 비교로 문제의 성능 차이를 예측할 수 없습니다.

예를 들어 정수 더하기는 교환 적이므로 컴파일러가 벤치 마크에 사용한 것과 같은 루프를 발견하면 (임의 데이터가 결과를 가리지 않도록 미리 준비되었다고 가정) 루프를 풀고 다음을 사용하여 부분 합계를 계산할 수 있습니다. 종속성이없는 경우 루프가 종료 될 때 추가하십시오. 그러나 부동 소수점을 사용하면 컴파일러가 요청한 순서와 동일한 순서로 작업을 수행해야합니다 (시퀀스 포인트가 있으므로 컴파일러는 순서 변경을 허용하지 않는 동일한 결과를 보장해야 함). 따라서 각 추가 항목에 대한 강한 종속성이 있습니다. 이전 결과의 결과.

한 번에 더 많은 정수 피연산자를 캐시에 넣을 수도 있습니다. 따라서 고정 소수점 버전은 FPU가 이론적으로 더 높은 처리량을 가진 컴퓨터에서도 부동 소수점 버전보다 성능이 훨씬 뛰어납니다.

덧셈은보다 훨씬 빠르기 rand때문에 프로그램은 (특히) 쓸모가 없습니다.

성능 핫스팟을 식별하고 프로그램을 점진적으로 수정해야합니다. 먼저 해결해야 할 개발 환경에 문제가있는 것 같습니다. 작은 문제 세트로 인해 PC에서 프로그램을 실행할 수 없습니까?

일반적으로 정수 산술로 FP 작업을 시도하는 것은 느린 방법입니다.

TIL 이것은 다양합니다 (많음). 다음은 gnu 컴파일러를 사용한 몇 가지 결과입니다 (btw 나는 또한 기계에서 컴파일하여 확인했습니다. xenial의 gnu g ++ 5.4는 정확하게 linaro의 4.6.3보다 훨씬 빠릅니다)

인텔 i7 4700MQ 제니 얼

short add: 0.822491
short sub: 0.832757
short mul: 1.007533
short div: 3.459642
long add: 0.824088
long sub: 0.867495
long mul: 1.017164
long div: 5.662498
long long add: 0.873705
long long sub: 0.873177
long long mul: 1.019648
long long div: 5.657374
float add: 1.137084
float sub: 1.140690
float mul: 1.410767
float div: 2.093982
double add: 1.139156
double sub: 1.146221
double mul: 1.405541
double div: 2.093173

Intel i3 2370M의 결과도 비슷합니다.

short add: 1.369983
short sub: 1.235122
short mul: 1.345993
short div: 4.198790
long add: 1.224552
long sub: 1.223314
long mul: 1.346309
long div: 7.275912
long long add: 1.235526
long long sub: 1.223865
long long mul: 1.346409
long long div: 7.271491
float add: 1.507352
float sub: 1.506573
float mul: 2.006751
float div: 2.762262
double add: 1.507561
double sub: 1.506817
double mul: 1.843164
double div: 2.877484

Intel (R) Celeron (R) 2955U (xenial을 실행하는 Acer C720 Chromebook)

short add: 1.999639
short sub: 1.919501
short mul: 2.292759
short div: 7.801453
long add: 1.987842
long sub: 1.933746
long mul: 2.292715
long div: 12.797286
long long add: 1.920429
long long sub: 1.987339
long long mul: 2.292952
long long div: 12.795385
float add: 2.580141
float sub: 2.579344
float mul: 3.152459
float div: 4.716983
double add: 2.579279
double sub: 2.579290
double mul: 3.152649
double div: 4.691226

DigitalOcean 1GB Droplet Intel (R) Xeon (R) CPU E5-2630L v2 (트러스티 실행)

short add: 1.094323
short sub: 1.095886
short mul: 1.356369
short div: 4.256722
long add: 1.111328
long sub: 1.079420
long mul: 1.356105
long div: 7.422517
long long add: 1.057854
long long sub: 1.099414
long long mul: 1.368913
long long div: 7.424180
float add: 1.516550
float sub: 1.544005
float mul: 1.879592
float div: 2.798318
double add: 1.534624
double sub: 1.533405
double mul: 1.866442
double div: 2.777649

AMD Opteron (tm) 프로세서 4122 (정밀)

short add: 3.396932
short sub: 3.530665
short mul: 3.524118
short div: 15.226630
long add: 3.522978
long sub: 3.439746
long mul: 5.051004
long div: 15.125845
long long add: 4.008773
long long sub: 4.138124
long long mul: 5.090263
long long div: 14.769520
float add: 6.357209
float sub: 6.393084
float mul: 6.303037
float div: 17.541792
double add: 6.415921
double sub: 6.342832
double mul: 6.321899
double div: 15.362536

이것은 http://pastebin.com/Kx8WGUfg의 코드를 다음 과 같이 사용합니다.benchmark-pc.c

g++ -fpermissive -O3 -o benchmark-pc benchmark-pc.c

여러 번 통과했지만 일반적인 숫자가 동일한 경우 인 것 같습니다.

한 가지 주목할만한 예외는 ALU mul 대 FPU mul 인 것 같습니다. 덧셈과 뺄셈은 사소하게 다르게 보입니다.

위의 차트 형식은 다음과 같습니다 (전체 크기를 보려면 클릭, 낮을수록 더 빠르고 선호 됨) :

@Peter Cordes를 수용하도록 업데이트

https://gist.github.com/Lewiscowles1986/90191c59c9aedf3d08bf0b129065cccc

    short add: 0.773049
    short sub: 0.789793
    short mul: 0.960152
    short div: 3.273668
      int add: 0.837695
      int sub: 0.804066
      int mul: 0.960840
      int div: 3.281113
     long add: 0.829946
     long sub: 0.829168
     long mul: 0.960717
     long div: 5.363420
long long add: 0.828654
long long sub: 0.805897
long long mul: 0.964164
long long div: 5.359342
    float add: 1.081649
    float sub: 1.080351
    float mul: 1.323401
    float div: 1.984582
   double add: 1.081079
   double sub: 1.082572
   double mul: 1.323857
   double div: 1.968488

    short add: 1.235603
    short sub: 1.235017
    short mul: 1.280661
    short div: 5.535520
      int add: 1.233110
      int sub: 1.232561
      int mul: 1.280593
      int div: 5.350998
     long add: 1.281022
     long sub: 1.251045
     long mul: 1.834241
     long div: 5.350325
long long add: 1.279738
long long sub: 1.249189
long long mul: 1.841852
long long div: 5.351960
    float add: 2.307852
    float sub: 2.305122
    float mul: 2.298346
    float div: 4.833562
   double add: 2.305454
   double sub: 2.307195
   double mul: 2.302797
   double div: 5.485736

    short add: 1.040745
    short sub: 0.998255
    short mul: 1.240751
    short div: 3.900671
      int add: 1.054430
      int sub: 1.000328
      int mul: 1.250496
      int div: 3.904415
     long add: 0.995786
     long sub: 1.021743
     long mul: 1.335557
     long div: 7.693886
long long add: 1.139643
long long sub: 1.103039
long long mul: 1.409939
long long div: 7.652080
    float add: 1.572640
    float sub: 1.532714
    float mul: 1.864489
    float div: 2.825330
   double add: 1.535827
   double sub: 1.535055
   double mul: 1.881584
   double div: 2.777245

고려해야 할 두 가지 사항-

최신 하드웨어는 명령어를 겹치고 병렬로 실행하며 하드웨어를 최대한 활용하기 위해 순서를 변경할 수 있습니다. 또한 중요한 부동 소수점 프로그램은 인덱스를 배열, 루프 카운터 등으로 만 계산하는 경우에도 중요한 정수 작업을 수행 할 가능성이 있으므로 느린 부동 소수점 명령이 있더라도 별도의 하드웨어 비트에서 실행될 수 있습니다. 일부 정수 작업과 겹쳤습니다. 내 요점은 부동 소수점 명령어가 정수 1보다 느리더라도 하드웨어를 더 많이 사용할 수 있기 때문에 전체 프로그램이 더 빠르게 실행될 수 있다는 것입니다.

항상 그렇듯이 확인하는 유일한 방법은 실제 프로그램을 프로파일 링하는 것입니다.

두 번째 요점은 요즘 대부분의 CPU에는 동시에 여러 부동 소수점 값에서 작동 할 수있는 부동 소수점에 대한 SIMD 명령어가 있다는 것입니다. 예를 들어, 4 개의 부동 소수점을 단일 SSE 레지스터에로드하고 모두 병렬로 4 개의 곱셈을 수행 할 수 있습니다. SSE 명령어를 사용하도록 코드의 일부를 다시 작성할 수 있다면 정수 버전보다 빠를 가능성이 높습니다. Visual C ++는이를 수행하는 컴파일러 내장 함수를 제공합니다 . 자세한 내용 은 http://msdn.microsoft.com/en-us/library/x5c07e2a(v=VS.80).aspx 를 참조 하십시오 .

나머지 연산이 없으면 부동 소수점 버전이 훨씬 느려집니다. 모든 추가가 순차적이기 때문에 CPU는 합산을 병렬화 할 수 없습니다. 대기 시간이 중요합니다. FPU 추가 대기 시간은 일반적으로 3주기이고 정수 추가는 1주기입니다. 그러나 나머지 연산자에 대한 분배기는 최신 CPU에서 완전히 파이프 라인되지 않기 때문에 아마도 중요한 부분이 될 것입니다. 따라서 나누기 / 나머지 명령어가 많은 시간을 소비한다고 가정하면 지연 시간 추가로 인한 차이는 작을 것입니다.

초당 수백만 번 호출되는 코드를 작성하지 않는 한 (예 : 그래픽 응용 프로그램에서 화면에 선 그리기) 정수 대 부동 소수점 산술은 병목 현상이 거의 발생하지 않습니다.

효율성 질문에 대한 일반적인 첫 번째 단계는 코드를 프로파일 링하여 런타임이 실제로 소비되는 위치를 확인하는 것입니다. 이에 대한 linux 명령은 gprof.

편집하다:

정수와 부동 소수점 숫자를 사용하여 항상 선 그리기 알고리즘을 구현할 수 있다고 생각하지만 여러 번 호출하여 차이가 있는지 확인합니다.

http://en.wikipedia.org/wiki/Bresenham's_algorithm

오늘날 정수 연산은 일반적으로 부동 소수점 연산보다 조금 더 빠릅니다. 따라서 정수 및 부동 소수점에서 동일한 연산으로 계산을 수행 할 수 있다면 정수를 사용하십시오. 그러나 당신은 "이것은 많은 성가신 문제를 일으키고 많은 성가신 코드를 추가합니다"라고 말하고 있습니다. 부동 소수점 대신 정수 산술을 사용하기 때문에 더 많은 연산이 필요한 것처럼 들립니다. 이 경우 부동 소수점이 더 빨리 실행됩니다.

• 더 많은 정수 연산이 필요하면 아마도 훨씬 더 많이 필요할 것입니다. 따라서 약간의 속도 이점은 추가 연산에 의해 소모되는 것보다 많습니다.

• 부동 소수점 코드가 더 간단합니다. 즉, 코드를 작성하는 것이 더 빠릅니다. 즉, 속도가 중요한 경우 코드를 최적화하는 데 더 많은 시간을 할애 할 수 있습니다.

rand () 대신 숫자에 1을 더한 테스트를 실행했습니다. 결과 (x86-64에서)는 다음과 같습니다.

• 짧음 : 4.260 초
• int : 4.020 초
• 롱 롱 : 3.350s
• 부동 : 7.330 초
• 두 배 : 7.210 초

믿을 수있는 "내가들은 것"을 기반으로했을 때, 예전에는 정수 계산이 부동 소수점보다 약 20 ~ 50 배 더 빨랐고, 요즘에는 두 배도 안됩니다.