VPF::Очередные данные о "медленности" JAVA

Neox_GeForce

Дата 3.7.2009, 11:10 (ссылка)

(нет голосов)

Загрузка ...

Опытный

Профиль
Группа: Участник
Сообщений: 283
Регистрация: 14.11.2007
Где: Украина

Репутация: нет
Всего: нет

Цитата(jer1 @ 16.1.2006, 15:54)

взял программу Коть и запустил у себя
Вот программы которые я использовал:

Код

#include <stdio.h>
#include <time.h>

const int N = 1000000;

unsigned int f;
unsigned int factorial (unsigned int a);
main()
{   
    clock_t t1 = clock();
    int i;
    for (i = 0; i < N; i++)
    {
        f = factorial(100);
    }
    clock_t t2 = clock();
    printf("\n Program execution time is %u milliseconds \n", (t2 - t1) * 10);
} 
unsigned int factorial(unsigned int a)
{
    if (a == 1) return 1;
    else 
    {
        a *= factorial(a - 1);
        return a;
    }
}

Код


public class JavaSpeedTest {
    public static final int COMPUTE_COUNT = 1000000;

    public static void main(String [] args)
    {
        long t1 = System.currentTimeMillis();
        int f = 0;
        for (int i = 0; i < COMPUTE_COUNT; i++)
        {
            f = factorial(100);
        }

        System.out.println("\n Program execution time is " + (System.currentTimeMillis() - t1) + 
                                      "   milliseconds");    
    }

    public static int factorial(int a) 
    {
    if (a == 1) return 1;
        else 
        {
            a *= factorial(a - 1);
            return a;
        }
    }
}

Код


program DelphiSpeedTest; //Delphi 5.62
{$APPTYPE CONSOLE}
uses
  SysUtils;

const
    COMPUTE_COUNT: integer = 1000000;

    function factorial(a: integer): integer; begin
        if (a = 1) then factorial := 1
        else begin
            a := a * factorial(a - 1);
            factorial := a;
        end;
    end;

var
   i: integer;
   time0, time1 : TDateTime;
   Year, Month, Day, Hour, Min, Sec, MSec: Word;
   f: integer;
begin
   time0 := now;
   for i := 0 to COMPUTE_COUNT do f := factorial(100);
   time1 := now;
   DecodeTime(time1 - time0, Hour, Min, Sec, MSec);
   write('Program execution time is ');
   write(intToStr(1000*sec+mSec)); write(' in miliseconds');
end.

компьютер Celeron 1.2 256M os: XP Professional, Linux Slackware ядро 2.4.26
jdk:
java version "1.5.0_04"
Java™ 2 Runtime Environment, Standard Edition (build 1.5.0_04-b05)
Java HotSpot™ Client VM (build 1.5.0_04-b05, mixed mode, sharing)

результаты в миллисекундах (три запуска):
delphi 5: 1141; 1140; 1156
java XP: 1187; 1203; 1187
java linux: 1201; 1189; 1203
java linux server: 685; 696; 705
c (gcc -o test2 CSpeedTest.c ): 19000000; 19000000; 19100000
c(gcc -O3 -o test CSpeedTest.c): 10800000; 11000000; 10800000
gcj (gcj -c -g -O JavaSpeedTest.java; gcj --main=JavaSpeedTest -o GCJSpeedTest JavaSpeedTest.o ): 2815; 2826; 2828

код на шарпе

Код


using System;
using System.Diagnostics;

namespace CsharpSpeed
    {
    class Program
        {
        public const int N=1000000;
        public static uint factorial(uint a)
{
    if (a == 1) return 1;
    else 
    {
        a *= factorial(a - 1);
        return a;
    }
}
        static void Main(string[] args)
            {
            Stopwatch timer=new Stopwatch();
            int i;
            uint f;
            timer.Start();
            for (i = 0; i < N; i++)
                {
                f = factorial(100);
                }
                timer.Stop();
             Console.WriteLine("\n Program execution time is {0} milliseconds \n",timer.ElapsedMilliseconds);
            Console.ReadLine();
            }
        }
    }

Результаты(3 запуска):
1071 ms
1068 ms
1068 ms

Потом скомпилил в среде Dev-C++ с найлутшей оптимизацией

Код


#include <stdio.h>
#include <time.h>
#include <iostream>
const int N = 1000000;
unsigned int f;
unsigned int factorial (unsigned int a);
main()
{   
    clock_t t1 = clock();
    int i;
    for (i = 0; i < N; i++)
    {
        f = factorial(100);
    }
    clock_t t2 = clock();
    printf("\n Program execution time is %u milliseconds \n", (t2 - t1) * 10);
    system("Pause");
} 
unsigned int factorial(unsigned int a)
{
    if (a == 1) return 1;
    else 
    {
        a *= factorial(a - 1);
        return a;
    }
}

Результаты:
5620 ms
5620 ms
5460 ms

Машина: Intel core 2 duo 1.86 . RAM 1GB.

--------------------

Челябинские программисты настолько суровы, что обходятся без компиляторов.
Челябинские программисты настолько суровы, что считают ассемблер недопустительной роскошью - они вручную магнетизируют участки жесткого диска.

kamre

Дата 3.7.2009, 16:12 (ссылка)

(нет голосов)

Загрузка ...

Опытный

Профиль
Группа: Участник
Сообщений: 330
Регистрация: 24.3.2006

Репутация: 1
Всего: 13

Цитата(Neox_GeForce @ 3.7.2009, 11:10)

Потом скомпилил в среде Dev-C++ с найлутшей оптимизацией

Код


...
    printf("\n Program execution time is %u milliseconds \n", (t2 - t1) * 10);
...

Результаты:
5620 ms
5620 ms
5460 ms

Для начала неплохо перемерять с корректным подсчетом времени:

Код


printf("\n Program execution time is %u milliseconds \n", (t2 - t1) * 1000 / CLOCKS_PER_SEC);

И использовать современный компилятор (MSVC9/IntelCPP11/GCC4), а не престарелый MinGW из Dev-C++.

LSD

Дата 3.7.2009, 17:09 (ссылка)

(нет голосов)

Загрузка ...

Leprechaun Software Developer

Профиль
Группа: Модератор
Сообщений: 15718
Регистрация: 24.3.2004
Где: Dublin

Репутация: 210
Всего: 538

1. Этот тест меряет в первую очередь затраты на вызов метода. И в том что C# в это тесте быстрее C++ нет ничего удивительного.

2. Этот топик все таки посвящен Java, а не C# vs C++, так что не увлекайтесь. smile

--------------------

Disclaimer: this post contains explicit depictions of personal opinion. So, if it sounds sarcastic, don't take it seriously. If it sounds dangerous, do not try this at home or at all. And if it offends you, just don't read it.

serger

Дата 21.8.2009, 09:34 (ссылка)

(голосов:1)

Загрузка ...

Опытный

Профиль
Группа: Участник
Сообщений: 518
Регистрация: 19.6.2007
Где: Ижевск

Репутация: 1
Всего: 5

Ну ОЧЕНЬ давно хотел упомянуть про аллокацию в java.
Руки таки дошли...

Теория и практика Java: Еще раз о городских легендах о производительности

--------------------

упс!

Vitaly333

Дата 12.10.2009, 22:39 (ссылка)

(голосов:4)

Загрузка ...

Бывалый

Профиль
Группа: Участник
Сообщений: 220
Регистрация: 6.11.2006
Где: Volgograd

Репутация: 2
Всего: 2

Вот и я решил внести свою лепту... Сегодня будем сравнивать какой же язык/компилятор лучше всего оптимизирует циклы и быстрее производит арифметические операции над числами с плавающей точкой или запятой, кому как угодно. Как гласит золотое правило 80% времени выполнения программы уходит на 20% кода. Чаще всего как раз эти 20%  состоят из большого кол-ва вложенных циклов и арифметических вычислений. От того как оптимизирован "циклический" алгоритм зависит многое. Но сегодня, в большинстве случаев,  за оптимизацию циклов  отвечает не программист а компилятор.От того как последний выполнит эту работу  также зависит очень многое.  Одни компиляторы очень хорошо справляются с этой задачей, другие намного хуже.  Основной вопрос заключается в следующем: стоит ли оптимизировать циклы вручную, если современные компиляторы могут сделать это за вас? И какой копилятор на сегодня лучше всего делает это? Я попытаюсь ответить на эти вопросы  в этой теме.
Для сравнений я взял, на мой взгляд, самый подходящий в этом случае численный алгоритм - алгоритм умножения матриц (С = С + A*B). Во первых он довольно прост в реализации. Во вторых это фундаментальный алгоритм линейной алгебры, который реально способен показать производительность программно-аппаратной системы, её приемущества и недостатки. В третьих, существует различные варианты его программной реализации, а значит есть несколько возможных путей его оптимизации для компиляторов и программистов. Поэтому здесь я привожу три программные реализации этого алгоритма:
1)  Классический (иногда ещё его называют наивным) ijk-алгоритм, использующий для вычисления c[i,j] элемента скалярное произведение i-ой строки матрицы A и j-ого столбца матрицы B.
2) Уже более хитрый чем первый ikj-алгоритм, умножающий i-строку матрицы A на j-ю строку матрицы B, для того чтобы вычислить каждый элемент матрицы C.
3) Блочный алгоритм, в котором квадратные матрицы A,B,C разбиваются на квадратные  блоки, размером bsizexbsize и потом перемножаются между собой так же как и элементы матриц, при обычном не блочном умножении.
Note: для простоты реализации матрицы A,B,C берутся квадратными одной и той же размерности. Используется арифметика двойной точности.
Реализации этих алгоритмов на трех языках (Java, С++ и Fortran) приведены ниже:

Код


public class MatrixMultiply {

public static double[][] classicalMult(double[][] A, double[][] B,double[][] C, int N){
        
        int i,j,k;        
        for (i=0;i<N;i++)
            for (j=0;j<N;j++)
                for (k=0;k<N;k++)
                    C[i][j] +=A[i][k]*B[k][j];                                                                                    
return C;    
}


public static double[][] optimizeMult(double[][] A, double[][] B,double[][] C, int N){
        
        int i,j,k;        
        transpose(B);
        for (i=0;i<N;i++)
            for (j=0;j<N;j++)
                for (k=0;k<N;k++)
                    C[i][j] +=A[i][k]*B[j][k];

                transpose(B);                                                                                    
return C;    
}

 public static double[][] blockMult(double[][]A, double[][] B,double[][]C, int N,int bsize){
        
        
        int n,m,iter,i,j,k;                
        int ibeg,iend,jbeg,jend,kbeg,kend;
        
        double A0=0.0,A1=0.0,B0=0.0,B1=0.0,r,r0,r1,r2,r3;
        transpose(B);
        
        int gridSize = N/bsize;
        for (n=0; n<gridSize; n++){
            ibeg = n*bsize;
            iend = ibeg+bsize;
            for (m=0; m<gridSize; m++){
                jbeg = m*bsize;
                jend = jbeg+bsize;
                for (iter=0; iter<gridSize; iter++)    {
                    kbeg = iter*bsize;
                    kend = kbeg+bsize;
                    for (i=ibeg;i<iend;i+=2){                        
                        for(j=jbeg;j<jend;j+=2) {
                            r = 0.0;
                            r0 = 0.0;
                            r1 = 0.0;
                            r2 = 0.0;
                            r3 = 0.0;
                            for (k=kbeg; k<kend; k++){                            
                                A0 = A[i][k];
                                A1 = A[i+1][k];
                                B0 = B[j][k];
                                B1 = B[j+1][k];                                
                                r0 =r0+A0*B0;                                
                                r1=r1+A0*B1;                                
                                r2 =r2+A1*B0;
                                r3 =r3+A1*B1;                                                            
                            }
                            
                        C[i][j] +=r0;
                        C[i][j+1]+=r1;
                        C[i+1][j]+=r2;
                        C[i+1][j+1]+=r3;
                                            
                        }                            
                    }
                }                
            }
                
        }

        transpose(B);    
                
return C;        
}

 public static void transpose(double[][] A){
        double tmp = 0.0;
        int N = A[0].length;
        for (int i=0;i<N;i++){
            for (int j=0;j<i;j++){
                tmp = A[i][j];
                A[i][j] = A[j][i];
                A[j][i] = tmp;
            }
        }
    }

public static void fillMatrices(double[][] A, double[][] B, double[][] C,int N){
        
    int i,j;        
        for (i = 0; i < N; i++) {
        for (j = 0; j < N; j++) {
                   A[i][j] = Math.random()*10;    
                   B[i][j] = Math.random()*10;
                   C[i][j] = 0.0; 
         }
        }
        
    }

public static void main(String[] args) {
        
        final int N = 512;
        final int bSIZE = 64;
        
        System.out.println("Allocate memory");
        double[][] A = new double[N][N];
        double[][] B = new double[N][N];
        double[][] C = new double[N][N];
                System.out.println("Fill matrices");
        fillMatrices(A, B,C,N);
                
                System.out.println("Matrix multiplicaton...");                                            
        long t1,t2;
        t1 = System.currentTimeMillis();
        classicalMult(A, B, C,N);    
        //optimizeMult(A, B, C,N);    
        //blockMult(A, B, C, N,bSIZE);
        t2 = System.currentTimeMillis()-t1;
               System.out.println("Computation time = " + t2 + " millisec");
               if (t2==0) t2 = 0.000001;
               float perform = (float)(2*Math.pow(N/100.0,3.0)/t2);
               System.out.println("Performance = " + perform + " MFlops");
        
    }


}

Код


#include "conio.h"
#include "math.h"
#include <iostream>
#include "time.h"

using namespace std;


double** classicalMult(double** A, double** B,double** C,int N){

    int i,j,k;
        for (i=0;i<N;i++)
            for (j=0;j<N;j++)
                for (k=0;k<N;k++)
                    C[i][j] +=A[i][k]*B[k][j];                                    
        return C;
}

double** optimizeMult(double** A, double** B,double** C,int N){

      transpose(B,N);
    int i,j,k;
        for (i=0;i<N;i++)
            for (j=0;j<N;j++)
                for (k=0;k<N;k++)
                    C[i][j] +=A[i][k]*B[j][k];                                    
        return C;
}


double** blockMult(double**A, double** B,double**C, int N,int bsize){


        int n,m,iter,i,j,k;
        int ibeg,iend,jbeg,jend,kbeg,kend;

        double r,r0,r1,r2,r3;
        double A0=0.0,A1=0.0,B0=0.0,B1=0.0;
        transpose(B,N);

        int gridSize = N/bsize;
        for (n=0; n<=gridSize; n++){
            ibeg = n*bsize;
            iend = ibeg+bsize;
            for (m=0; m<gridSize; m++){
                jbeg = m*bsize;
                jend = jbeg+bsize;
                for (iter=0; iter<gridSize; iter++)    {
                    kbeg = iter*bsize;
                    kend = kbeg+bsize;
                    for (i=ibeg; i<iend; i+=2){
                        for (j=jbeg; j<jend; j+=2){
                            r0 = 0.0;
                            r1 = 0.0;
                            r2 = 0.0;
                            r3 = 0.0;
                            for (k=kbeg; k<kend;k++){
                                A0 = A[i][k];
                                A1 = A[i+1][k];
                                B0 = B[j][k];
                                B1 = B[j+1][k];
                                r0 = r0+A0*B0;
                                r1 = r1+A0*B1;
                                r2 = r2+A1*B0;
                                r3 = r3+A1*B1;
                            }

                            C[i][j] +=r0;
                            C[i][j+1]+=r1;
                            C[i+1][j]+=r2;
                            C[i+1][j+1]+=r3;

                        }
                    }
                }
            }

        }
                transpose(B,N);

        return C;

    }




void fillMatrices(double** A,double** B,double** C, int N){

        int i,j;
         for (i = 0;i < N; i++) {
            for (j = 0;j<N;j++){
                A[i][j] = rand()*10;
                B[i][j] = rand()*10;
                C[i][j] = 0;
            }
         }
 }


void transpose(double** A, int N){
        double tmp = 0.0;
        for (int i=0;i<N;i++){
            for (int j=0;j<i;j++){
                tmp = A[i][j];
                A[i][j] = A[j][i];
                A[j][i] = tmp;
            }
        }
    }


int main() {

    int const N = 512;
    int const BSIZE = 64;

    std::cout <<"Allocate memory..."<<endl;
 
    double** A = new double*[N];
    double** B = new double*[N];
    double** C = new double*[N];

    for (int i=0;i<N;i++){
        A[i] = new double[N];
        B[i] = new double[N];
        C[i] = new double[N];
    }

       std::cout <<"Fill matrices..."<<endl;
       fillMatrices(A,B,C,N);

       std::cout <<"Matrix multiplication..."<<endl;
       float t1,t2;
       t1 = clock();
       //classicalMult(A,B,C,N);
       //optimizeMult(A,B,C,N);
       //blockMult(A,B,C,N,BSIZE);
       t2 = (float)(clock()-t1)/CLOCKS_PER_SEC;
       std::cout <<"Computation time = "<<t2<<" sec. "<<endl;
       if (t2==0.0) t2 = 0.000000000001;
       float perform = 2*pow(N/100,3)/t2;
       std::cout<<"Performance = "<<perform<<" MFlops "<<endl;
       //getch();

 return 0;
}

Код



   FUNCTION CLASSICALMULT(A,B,C,N)
       INTEGER N
       DOUBLE PRECISION A(N,N),B(N,N),C(N,N)
       do i = 1,N
         do j = 1,N
           do k = 1,N
           C(j,i) = C(j,i) + A(j,k)*B(k,i)
           enddo
         enddo
       enddo
   END FUNCTION

   FUNCTION OPTIMIZEMULT(A,B,C,N)
       INTEGER N
       DOUBLE PRECISION A(N,N),B(N,N),C(N,N)
       call TRANS(A,N,N)
       do i = 1,N
         do j = 1,N
           do k = 1,N
           C(j,i) = C(j,i) + A(k,j)*B(k,i)
           enddo
         enddo
       enddo
   END FUNCTION

FUNCTION BLOCKMULT(A,B,C,N,BSIZE)
      INTEGER N,BSIZE
      DOUBLE PRECISION A(N,N),B(N,N),C(N,N)
      INTEGER GRIDSIZE
      GRIDSIZE = N/bsize-1
      call TRANS(A,N,N)

        do h=0,GRIDSIZE
            ibeg = h*bsize+1
            iend = ibeg+bsize-1
            do m=0,GRIDSIZE
                jbeg = m*bsize+1
                jend = jbeg+bsize-1
                do iter=0,GRIDSIZE
                    kbeg = iter*bsize+1
                    kend = kbeg+bsize-1
                    i = ibeg
                    do while (i<=iend)
                        j = jbeg
                        do while (j<=jend)
                            r0 = 0.
                                r1 = 0.
                                r2 = 0.
                                r3 = 0.
                                 r =  0.
                            do k=kbeg,kend
                                                             A0 = A(k,j)
                                                             A1 = A(k,j+1)
                                                             B0 = B(k,i)
                                                             B1 = B(k,i+1)
                                                             r0=r0+A0*B0
                                                             r1=r1+A0*B1
                                                             r2=r2+A1*B0
                                                             r3=r3+A1*B1
                            enddo
                            C(j,i) =C(j,i)+ r0
                            C(j,i+1)=C(j,i+1)+r1
                            C(j+1,i)=C(j+1,i)+r2
                            C(j+1,i+1)=C(j+1,i+1)+r3
                            j = j + 2
                        enddo
                        i = i + 2
                    enddo
                enddo
            enddo
        enddo
      END FUNCTION

       FUNCTION TRANS(A,N,M)
        INTEGER N,M
        DOUBLE PRECISION A(N,M)
         tmp = 0.
         do i=1,N
           do j=i+1,M
            tmp = A(i,j)
            A(i,j) = A(j,i)
            A(j,i) = tmp
           enddo
         enddo
        END FUNCTION

       FUNCTION FILLMATRICES(A,B,C,N,M)
      INTEGER N,M
      DOUBLE PRECISION A(N,M),B(N,M),C(N,M)
       k  = 0.
      do i = 1,N
        do j = 1,M
         A(i,j) = k
         B(i,j) = k
         C(i,j) = 0.
         k = k + 1.
         enddo
      enddo
      END

    PROGRAM MAIN
       Integer N,BSIZE
      Parameter(N=512,BSIZE=64)
      double precision A(N,N),B(N,N),C(N,N)
      real start, finish

      call FILLMATRICES(A,B,C,N,N)

      print *,'Matrix multiplication... '
      call cpu_time(start)

        call classicalMult(A,B,C,N)
!        call optimizeMult(A,B,C,N)
!         call BLOCKMULT(A,B,C,N,BSIZE)

      call cpu_time(finish)
      time = finish-start
      print *,'Computation time = ', time ,' millisec.'
      N = N/100;
      N3 = N*N*N 
      if (time.EQ.0.) time = 0.000001
      perform = 2*N3/time
      print *,'Performance = ', perform ,' MFlops.'
      END

В забеге участвовали след. компиляторы/интерпретаторы:
• GNU FORTRAN v 4.4.0
• INTEL VISUAL FORTRAN v 11.1.038
• GNU C++ v 4.4.0
• INTEL C++ v 11.1.035
• MSVS C++ v 8.00.50727.42 (из MSVS 2005)
• SUN CLIENT JVM 1.6_16
• SUN SERVER JVM 1.6_16
• EXCELSIOR JET 4.6
• GNU JAVA v 4.4.0

Для тестов брались квадратные вещественные матрицы размерноcтью 512,1024,2048 и 4096. Каждый компилятор тестировался с разными ключами оптимизации.
Тестовая машина: OS Windows XP, CPU AMD Athlon64x2 2.41GHZ L1 = 64KB L2 = 512KB,400MHZ DDR 1GB
Вот результаты проведенного тестирования:
В каждой из таблиц приведено время, затраченное на выполнение умножения матриц.

Классический алгоритм:

user posted image

Оптимизированный алгоритм:

user posted image

Блочный алгоритм:

user posted image

Лучшие результаты для каждого компилятора я вынес в гистограммы производительности:

user posted image

Итак, как и ожидалось, самый быстрый код создают компиляторы от Интел. Пока им нет равных. Особенно это заметно на классическом варианте умножения матриц. В этом алгоритме изначально порядок следования циклов далеко не оптимальный. Это скорее всего улавливают компиляторы от Интел и располагает его нужным образом, а также задействуют векторизацию и др. оптимизации. Всё это позволяет "нихрена не делая" сделать почти безнадежный классический алгоритм очень эффективным. Другие компиляторы этого пока не могут. Поэтому приходится оптимизировать алгоритмы вручную. Блочный и ikj-алгоритмы за счет более эффективной работы с кэш памятью процессора позволяют несколько приблизится к результатам, полученным интелом. Что же касается Java, то серверная JVM от Sun на некоторых тестах выглядит достаточно достойно, почти на уровне MSVS C++ и GNU G++. Клиентская версия конечно ещё сильно отстает от своих конкурентов. Компиляторы из Java напямую в машинный код не везде так быстры как ожидалось. Того же касается и GNU Fortran. От него я ожидал большего.
Вывод: Если нет времени на оптимизацию программы то стоит взять компилятор от Интел, включив по возможности высокий уровень оптимизации (ключи /O3 /fast). Если результат не удовлетворителен или если есть время, то стоит повозится с оптимизацией циклов. Можно применить след. способы оптимизации: блокирование циклов, разворот самого внутреннего цикла, если он короткий, заюзать векторизацию и регистры. Кстати говоря благодяря последним двум мне удалось обогнать компилятор от Интел, но здесь уже нужно писать на ASM-е.
Было бы не плохо узнать какие результаты получатся на процессоре Intel.

Это сообщение отредактировал(а) Vitaly333 - 12.10.2009, 22:57

Xaker88

Дата 3.11.2009, 16:11 (ссылка)

(нет голосов)

Загрузка ...

Новичок

Профиль
Группа: Участник
Сообщений: 9
Регистрация: 6.8.2009

Репутация: нет
Всего: нет

Код


using System;


namespace Project1
{
    class MainClass
    {
        public static void Main(string[] args)
        {
            int N=1000000;
            int Dt=DateTime.Now.Millisecond;
            
            
            int f;
            for (int i = 0; i < N; i++)
            {
             f = factorial(100);
            }
            
            Console.WriteLine("\n Program execution time is " + (DateTime.Now.Millisecond - Dt) +  "   milliseconds");
        }
         public static int factorial(int a)
         {
            if (a == 1) return 1;
            else
            {
                a *= factorial(a - 1);
                return a;
            }
        }
    }
}

Код


package javaapplication1;


public class Main
{

    
    public static void main(String[] args)
    {
        int N=1000000;
        long t1 = System.currentTimeMillis();
        int f;
        for (int i = 0; i < N; i++)
        {
            f = factorial(100);
        }
       System.out.println("\n Program execution time is " + (System.currentTimeMillis() - t1) +  "   milliseconds");

    }
    public static int factorial(int a)
    {
        if (a == 1) return 1;
        else
        {
            a *= factorial(a - 1);
            return a;
        }
    }

}

Джава в 10 раз медленней чем С#

Java(NetBeans) - 700 milliseconds
C#(MonoDevelop) - 70 milliseconds

Может делаю что то не так?

Это сообщение отредактировал(а) Xaker88 - 3.11.2009, 16:13

Temdegon

Дата 3.11.2009, 23:31 (ссылка)

(голосов:3)

Загрузка ...

Опытный

Профиль
Группа: Участник
Сообщений: 429
Регистрация: 11.10.2008
Где: Minsk

Репутация: 7
Всего: 9

Вы тестируете непонятно что. Так можно тестировать какой-нить компилятор паскаля 1985 года или интерпретатор Basic для ПК Ратон, но не языки с динамической компиляцией.
Ваш метод factorial замениться вычисленным в первой итерации значением либо на этапе компиляции, либо уже в процессе выполнения. Когда конкретно это произойдет - зависит от используемого компилятора и виртуальной машины. Теоретически, серверная JVM 1.6 сначала выбросит функцию, т.к. она реально не нужна, потом и сам цикл признает бесполезным =). Но на какой итерации это произойдет - я не знаю. Так же я не уверен, что клиентская jvm будет это делать.
В общем, читайте очень познавательную статью на эту тему.
линк

Это сообщение отредактировал(а) Temdegon - 3.11.2009, 23:36

LamerTM

Дата 17.11.2009, 13:43 (ссылка)

(нет голосов)

Загрузка ...

Шустрый

Профиль
Группа: Участник
Сообщений: 97
Регистрация: 11.3.2006

Репутация: нет
Всего: 0

Осилил всю тему. smile

Тест с факториалом на C++ у меня проходит за 0 ms (на VS2005). Похоже оптимизатор что-то там мудрит.

Поэтому изменил тест следующим образом:

C++:

Код


int FactorialI(int a)
{
    if (a == 1) return 1; else return a * FactorialI(a - 1);
}

double FactorialD(double a)
{
    if (a == 1) return 1; else return a * FactorialD(a - 1);
}


int _tmain(int argc, _TCHAR* argv[])
{
    int st = GetTickCount();
    double f = 1;
    int N = 100000000;
    int t = 5;
    for (int i = 0; i < N; i++)
    {
        if (t == 5) t = 4; else t = 5;
        f += FactorialI(t);
        if (f > 1000000) f = 1;
    }
    st = GetTickCount() - st;
            

    std::cout << "Result=" << f << "\n";
    std::cout << "Time=" << st;
    std::cin >> st;
    return 0;
}

C#:

Код


        public static double FactorialD(double a)
        {
            if (a == 1) return 1; else return a * FactorialD(a - 1);
        }

        public static int FactorialI(int a)
        {
            if (a == 1) return 1; else return a * FactorialI(a - 1);
        }

        private void button22_Click(object sender, EventArgs e)
        {
            int st = Environment.TickCount;
            double f = 1;
            int N = 100000000;
            int t = 5;
            for (int i = 0; i < N; i++)
            {
                if (t == 5) t = 4; else t = 5;
                f += FactorialI(t);
                if (f > 1000000) f = 1;
            }
            st = Environment.TickCount - st;
            richTextBox1.AppendText("Result=" + f.ToString() + " Time=" + st.ToString() + "\n");
        }

Delphi:

Код


function TForm1.FactorialI(a: Integer): Integer;
begin
         if a = 1 then
         begin
           Result := 1;
           Exit;
         end else
         begin
           Result := a * FactorialI(a - 1);
         end;
end;

function TForm1.FactorialD(a: Double): Double;
begin
         if a = 1 then
         begin
           Result := 1;
           Exit;
         end else
         begin
           Result := a * FactorialD(a - 1);
         end;
end;

procedure TForm1.Button16Click(Sender: TObject);
var       st: Cardinal;
          i, N, t: Integer;
          f: Double;
begin
          st := GetTickCount;
          N := 100000000;
          t := 5;
          for i := 0 to N - 1 do
          begin
            if t = 5 then t := 4 else t := 5;
            f := f + FactorialI(t);
            if f > 1000000 then f := 1;
          end;

          st := GetTickCount - st;
          Memo1.Lines.Add('Result='+IntToStr(Trunc(f))+' Time='+IntToStr(st));
end;

Вместо вызова функции FactorialI в теле цикла можно подставить вызов FactorialD (результаты будут разными).

Для FactorialI:

C++: 2390 ms
C#: 2453 ms
Delphi7: 4156 ms

Для FactorialD:

C++: 4828 ms
C#: 5453 ms
Delphi7: 11156 ms

Java у меня нет.

Это сообщение отредактировал(а) LamerTM - 17.11.2009, 13:47

Bozo

Дата 13.3.2011, 15:18 (ссылка)

(нет голосов)

Загрузка ...

Новичок

Профиль
Группа: Участник
Сообщений: 32
Регистрация: 5.4.2006

Репутация: нет
Всего: нет

Цитата

Вот шикарный тест из LZMA SDK и Java и C# и оптимизтрованный C++ и Delphi:

Код

E5620
~~~~~~~~~~~~~~~~~
C++       3979 KB/s    4685 MIPS      37032 KB/s    3733 MIPS
Java 1.7 -server
          2716 KB/s    3198 MIPS      33601 KB/s    3301 MIPS
C#        2523 KB/s    2971 MIPS      26699 KB/s    2691 MIPS
Java 1.7  2388 KB/s    2813 MIPS      22972 KB/s    2257 MIPS
Delphi10F 2283 KB/s    2688 MIPS      22443 KB/s    2205 MIPS
Delphi7   2195 KB/s    2585 MIPS      20844 KB/s    2048 MIPS

Karadul

Дата 26.3.2012, 18:19 (ссылка)

(нет голосов)

Загрузка ...

Опытный

Профиль
Группа: Участник
Сообщений: 378
Регистрация: 18.5.2006

Репутация: 0
Всего: 1

http://habrahabr.ru/post/136210/
Надеюсь, не [:|||:]

1 Пользователей читают эту тему (1 Гостей и 0 Скрытых Пользователей)
0 Пользователей:
« Предыдущая тема \| Java: Общие вопросы \| Следующая тема »