분명히 구현 품질 문제처럼 보입니다.

OP 코드로 몇 가지 테스트를 실행하고 약간 변경했습니다. 실제로 배열을 동적으로 할당 해야 한다는 가정 ( xs및 관련 스칼라)을 사용 하여 LDC / clang ++에 대해 D가 더 빨라졌습니다 . 일부 숫자는 아래를 참조하십시오.

OP에 대한 질문

C에 대한 반복마다 동일한 시드를 사용하고 D에는 그렇지 않은 것이 의도적 인 것입니까?

설정

scalar.d플랫폼간에 이식성을 갖도록 원본 D 소스 ( )를 조정했습니다 . 여기에는 배열의 크기에 액세스하고 수정하는 데 사용되는 숫자 유형 만 변경하는 것이 포함되었습니다.

그 후에 다음과 같이 변경했습니다.

• uninitializedArrayxs의 스칼라에 대한 기본 초기화를 피하는 데 사용 됩니다 (아마도 가장 큰 차이를 만들었 음). D는 일반적으로 모든 것을 자동으로 초기화하지만 C ++에서는 그렇지 않기 때문에 중요합니다.

• 코드를 인쇄에서 고려 교체 writefln와 함께writeln

• 선택적 가져 오기로 변경
• ^^평균 계산의 마지막 단계에 수동 곱셈 대신 pow 연산자 ( )를 사용했습니다.
• 를 제거하고 size_type새 index_type별칭으로 적절하게 교체

… 따라서 scalar2.cpp( pastebin )이 발생합니다.

    import std.stdio : writeln;
    import std.datetime : Clock, Duration;
    import std.array : uninitializedArray;
    import std.random : uniform;

    alias result_type = long;
    alias value_type = int;
    alias vector_t = value_type[];
    alias index_type = typeof(vector_t.init.length);// Make index integrals portable - Linux is ulong, Win8.1 is uint

    immutable long N = 20000;
    immutable int size = 10;

    // Replaced for loops with appropriate foreach versions
    value_type scalar_product(in ref vector_t x, in ref vector_t y) { // "in" is the same as "const" here
      value_type res = 0;
      for(index_type i = 0; i < size; ++i)
        res += x[i] * y[i];
      return res;
    }

    int main() {
      auto tm_before = Clock.currTime;
      auto countElapsed(in string taskName) { // Factor out printing code
        writeln(taskName, ": ", Clock.currTime - tm_before);
        tm_before = Clock.currTime;
      }

      // 1. allocate and fill randomly many short vectors
      vector_t[] xs = uninitializedArray!(vector_t[])(N);// Avoid default inits of inner arrays
      for(index_type i = 0; i < N; ++i)
        xs[i] = uninitializedArray!(vector_t)(size);// Avoid more default inits of values
      countElapsed("allocation");

      for(index_type i = 0; i < N; ++i)
        for(index_type j = 0; j < size; ++j)
          xs[i][j] = uniform(-1000, 1000);
      countElapsed("random");

      // 2. compute all pairwise scalar products:
      result_type avg = 0;
      for(index_type i = 0; i < N; ++i)
        for(index_type j = 0; j < N; ++j)
          avg += scalar_product(xs[i], xs[j]);
      avg /= N ^^ 2;// Replace manual multiplication with pow operator
      writeln("result: ", avg);
      countElapsed("scalar products");

      return 0;
    }

테스트 후 scalar2.d(속도 최적화를 우선 순위로 한) 호기심으로 루프 main를 foreach동등한 것으로 대체하고 scalar3.d( pastbin ) 이라고했습니다 .

    import std.stdio : writeln;
    import std.datetime : Clock, Duration;
    import std.array : uninitializedArray;
    import std.random : uniform;

    alias result_type = long;
    alias value_type = int;
    alias vector_t = value_type[];
    alias index_type = typeof(vector_t.init.length);// Make index integrals portable - Linux is ulong, Win8.1 is uint

    immutable long N = 20000;
    immutable int size = 10;

    // Replaced for loops with appropriate foreach versions
    value_type scalar_product(in ref vector_t x, in ref vector_t y) { // "in" is the same as "const" here
      value_type res = 0;
      for(index_type i = 0; i < size; ++i)
        res += x[i] * y[i];
      return res;
    }

    int main() {
      auto tm_before = Clock.currTime;
      auto countElapsed(in string taskName) { // Factor out printing code
        writeln(taskName, ": ", Clock.currTime - tm_before);
        tm_before = Clock.currTime;
      }

      // 1. allocate and fill randomly many short vectors
      vector_t[] xs = uninitializedArray!(vector_t[])(N);// Avoid default inits of inner arrays
      foreach(ref x; xs)
        x = uninitializedArray!(vector_t)(size);// Avoid more default inits of values
      countElapsed("allocation");

      foreach(ref x; xs)
        foreach(ref val; x)
          val = uniform(-1000, 1000);
      countElapsed("random");

      // 2. compute all pairwise scalar products:
      result_type avg = 0;
      foreach(const ref x; xs)
        foreach(const ref y; xs)
          avg += scalar_product(x, y);
      avg /= N ^^ 2;// Replace manual multiplication with pow operator
      writeln("result: ", avg);
      countElapsed("scalar products");

      return 0;
    }

LDC가 성능 측면에서 D 컴파일에 가장 적합한 옵션 인 것처럼 보이기 때문에 LLVM 기반 컴파일러를 사용하여 이러한 각 테스트를 컴파일했습니다. x86_64 Arch Linux 설치에서 다음 패키지를 사용했습니다.

• clang 3.6.0-3
• ldc 1:0.15.1-4
• dtools 2.067.0-2

다음 명령을 사용하여 각각을 컴파일했습니다.

• C ++ : clang++ scalar.cpp -o"scalar.cpp.exe" -std=c++11 -O3
• 디: rdmd --compiler=ldc2 -O3 -boundscheck=off <sourcefile>

결과

각 소스 버전의 결과 ( 원시 콘솔 출력 스크린 샷 )는 다음과 같습니다.

1. scalar.cpp (원래 C ++) :

   allocation: 2 ms
   
   random generation: 12 ms
   
   result: 29248300000
   
   time: 2582 ms

   C ++는 표준을 2582ms로 설정합니다 .

2. scalar.d (수정 된 OP 소스) :

   allocation: 5 ms, 293 μs, and 5 hnsecs
   
   random: 10 ms, 866 μs, and 4 hnsecs
   
   result: 53237080000
   
   scalar products: 2 secs, 956 ms, 513 μs, and 7 hnsecs 

   이것은 ~ 2957 ms 동안 실행되었습니다 . C ++ 구현보다 느리지 만 너무 많지는 않습니다.

3. scalar2.d (인덱스 / 길이 유형 변경 및 초기화되지 않은 배열 최적화) :

   allocation: 2 ms, 464 μs, and 2 hnsecs
   
   random: 5 ms, 792 μs, and 6 hnsecs
   
   result: 59
   
   scalar products: 1 sec, 859 ms, 942 μs, and 9 hnsecs

   다시 말해, ~ 1860 ms 입니다. 지금까지 이것은 주도하고 있습니다.

4. scalar3.d (두려움) :

   allocation: 2 ms, 911 μs, and 3 hnsecs
   
   random: 7 ms, 567 μs, and 8 hnsecs
   
   result: 189
   
   scalar products: 2 secs, 182 ms, and 366 μs

   ~ 2182ms 는 ~ 보다 느리지 scalar2.d만 C ++ 버전보다 빠릅니다.

결론

올바른 최적화를 통해 D 구현은 실제로 사용 가능한 LLVM 기반 컴파일러를 사용하는 동등한 C ++ 구현보다 빠릅니다. 대부분의 응용 프로그램에서 D와 C ++ 사이의 현재 격차는 현재 구현의 한계에 기반한 것으로 보입니다.

답변