Сравнение производительности языков программирования

в 10:40, , рубрики: c++, java, быстрая сортировка, метки: , ,

Сравнение производительности языков программирования
Привет тебе, дорогой %UserName%.
Многие из нас задумывались, какой язык более производительный. Услышав очередной разговор о том, что Java медленная, мне стало интересно посмотреть сравнение производительности Java, C++ и С#. Очевидно, что С++ будет самым производительным, но мне интереснее узнать, какова разница в производительности у С# и Java, и сколько они проигрывают С++. Всем, кому интересно прошу под кат.

Сравнивать языки программирования будем на классической задаче – сортировке массива. Сортировать будем алгоритмом быстрой сортировки. Каждую функцию будем прогонять на одинаковых массивах размером от 10000 до 100000 с шагом в 1000, и для точных результатов будем вызывать одну и ту же функцию на одном и том же массиве 20 раз.
Все расчёты проходили на процессоре Intel 3770K с тактовой частотой 3,5ГГц под управлением Windows 8.1. Компилятор С++ и С# — .Net framework 4.5.1. Компилятор Java – javac 1.7.0_45. Разумеется программы компилировались в режиме «Release», запускались по 15 раз прежде чем получить данные выходные файлы.
Исходные массивы, можете скачать здесь.

Исходник на Java

import java.io.*;
import java.util.StringTokenizer;

public class Sort {
    public static void main(String[] args) throws IOException {
        FileReader inputStream = new FileReader("input.txt");
        BufferedReader inputTxt = new BufferedReader(inputStream);
        FileOutputStream myFile = new FileOutputStream("Java time.txt");
        PrintWriter txtFile = new PrintWriter(myFile);
        txtFile.println("SizetTime");
        int N = 20;
        for (int i = 10000; i <= 100000 ; i += 1000) {
            long averageTime = 0;
            int[] array = parseStringToIntArray(inputTxt.readLine());
            for (int j = 0; j < N; j++) {
                int[] copyArray = array.clone();
                long afterSort;
                long beforeSort = System.nanoTime();
                sortArrayByHoarMiddle(copyArray, 0, i - 1);
                afterSort = System.nanoTime();
                averageTime += (afterSort - beforeSort) / N;
            }
            txtFile.println(i + "t" + averageTime);
        }
        inputTxt.close();
        txtFile.close();
    }

    static void sortArrayByHoarMiddle(int[] array, int i_n, int i_k) {
        int i = i_n;
        int j = i_k;
        int k = (i + j) / 2;
        int x = array[k];
        do {
            while (array[i] < x) {
                i++;
            }
            while (x < array[j]) {
                j--;
            }
            if (i <= j) {
                int p = array[i];
                array[i] = array[j];
                array[j] = p;
                i++;
                j--;
            }
        } while (!(i > j));
        if (i_n < j) {
            sortArrayByHoarMiddle(array, i_n, j);
        }
        if (i < i_k) {
            sortArrayByHoarMiddle(array, i, i_k);
        }
    }

    static int[] parseStringToIntArray(String str) {
        StringTokenizer tokenizer = new StringTokenizer(str, " ");
        int[] array = new int[tokenizer.countTokens()];
        int i = 0;
        while (tokenizer.hasMoreTokens()){
            array[i] = Integer.parseInt(tokenizer.nextToken());
            i++;
        }
        return array;
    }
}

Результат работы программы, написанной на Java

Size	Time
10000	1218126
11000	796698
12000	835308
13000	918886
14000	1026315
15000	1074744
16000	1149604
17000	1221519
18000	1359550
19000	1360003
20000	1457597
21000	1499144
22000	1640216
23000	1658920
24000	1772370
25000	1942055
26000	1922046
27000	2074285
28000	2102083
29000	2179696
30000	2271008
31000	2340938
32000	2422501
33000	2493961
34000	2592841
35000	2594070
36000	2766414
37000	2908608
38000	3014095
39000	2983376
40000	3100217
41000	3167500
42000	3223690
43000	3303309
44000	3437629
45000	3503627
46000	3618349
47000	3634672
48000	3815727
49000	3786251
50000	3978179
51000	4037950
52000	4143568
53000	4145787
54000	4231825
55000	4374047
56000	4425020
57000	4415523
58000	4598375
59000	4633567
60000	4781274
61000	4779257
62000	4928527
63000	5012996
64000	5156200
65000	5248884
66000	5316150
67000	5512071
68000	5420219
69000	5494009
70000	5597080
71000	5855710
72000	5719286
73000	5824581
74000	5915027
75000	5951183
76000	6113504
77000	6176621
78000	6267407
79000	6384609
80000	6402557
81000	6587646
82000	6659490
83000	6783332
84000	6800163
85000	6888099
86000	6961013
87000	7062564
88000	7201764
89000	7370732
90000	7341943
91000	7718669
92000	7484868
93000	7845065
94000	7994540
95000	7824591
96000	7843007
97000	7951560
98000	8103138
99000	8385002
100000	8257128

Исходник на C#

using System;
using System.IO;
using System.Diagnostics;

class Sort
    {
        static void Main(string[] args)
        {
            FileStream inputStream = new FileStream("input.txt", FileMode.Open);
            StreamReader inputTxt = new StreamReader(inputStream);
            FileStream output = new FileStream("C# time.txt", FileMode.Create);
            StreamWriter txtOutput = new StreamWriter(output);
            txtOutput.WriteLine("SizetTime");
            long nanosecPerTick = (1000L*1000L*1000L) / Stopwatch.Frequency;
            int N = 20;
            for (int i = 10000; i <= 100000; i += 1000)
            {
                long averageTime = 0;
                int[] array = ParseStringToIntArray(inputTxt.ReadLine());
                for (int j = 0; j < N; j++)
                {
                    int[] copyArray = (int[])array.Clone();
                    Stopwatch stopWatch = new Stopwatch();
                    stopWatch.Start();
                    SortArrayByHoarMiddle(copyArray, 0, i - 1);
                    stopWatch.Stop();
                    long ticks = stopWatch.ElapsedTicks;
                    averageTime += ticks * nanosecPerTick / N;
                }
                txtOutput.WriteLine(i + "t" + averageTime);
            }
            txtOutput.Close();
            Console.ReadLine();
        }

        static void SortArrayByHoarMiddle(int[] array, int i_n, int i_k)
        {
            int i = i_n;
            int j = i_k;
            int k = (i + j) / 2;
            int x = array[k];
            do
            {
                while (array[i] < x)
                {
                    i++;
                }
                while (x < array[j])
                {
                    j--;
                }
                if (i <= j)
                {
                    int p = array[i];
                    array[i] = array[j];
                    array[j] = p;
                    i++;
                    j--;
                }
            } while (!(i > j));
            if (i_n < j)
            {
                SortArrayByHoarMiddle(array, i_n, j);
            }
            if (i < i_k)
            {
                SortArrayByHoarMiddle(array, i, i_k);
            }
        }

        static int[] ParseStringToIntArray(String str)
        {
            String[] arrayString = str.Split(' ');
            int[] array = new int[arrayString.Length];
            for (int i = 0; i < arrayString.Length - 1; i++)
            {
                array[i] = int.Parse(arrayString[i]);
            }
            return array;
        }
    }
}

Результат работы программы, написанной на C#

Size	Time
10000	1332153
11000	1428953
12000	1576034
13000	1708891
14000	1862235
15000	2012483
16000	2156280
17000	2274118
18000	2431856
19000	2571824
20000	2766049
21000	2847679
22000	3069379
23000	3156221
24000	3322092
25000	3492548
26000	3613098
27000	3819411
28000	3948388
29000	4107046
30000	4261208
31000	4408067
32000	4586027
33000	4739052
34000	4947158
35000	4952706
36000	5244474
37000	5396953
38000	5473196
39000	5658907
40000	5858680
41000	5976777
42000	6098354
43000	6301101
44000	6566402
45000	6657884
46000	6765616
47000	7017528
48000	7136460
49000	7259376
50000	7595233
51000	7471629
52000	7632316
53000	7880486
54000	8081982
55000	8243414
56000	8443758
57000	8403534
58000	8720965
59000	8889335
60000	9036738
61000	9052938
62000	9479172
63000	9435579
64000	9763566
65000	9942635
66000	10090243
67000	10198428
68000	10419237
69000	10906309
70000	10667364
71000	10734352
72000	10919068
73000	11219640
74000	11255747
75000	11394910
76000	11712081
77000	11725572
78000	11948457
79000	12299382
80000	12142577
81000	12523768
82000	12967215
83000	13065838
84000	12918116
85000	13492231
86000	13292635
87000	13534572
88000	13746286
89000	13860021
90000	14057907
91000	14424352
92000	14191134
93000	14366682
94000	14763600
95000	14807255
96000	15007813
97000	15617905
98000	15254395
99000	15566791
100000	15682962

Исходник на C++

#include <iostream> 
#include <fstream> 
#include <iomanip>
#include<Windows.h>	

int* CopyArray(int *mass, int length);
void SortArrayByHoarMiddle(int *A, int i_n, int i_k);

using namespace std;

int main()
{
	ofstream outFile;
	outFile.open("C++ time.txt", ifstream::app);
	ifstream inputTxt;
	inputTxt.open("input", ios::in);
	outFile << "Size" << setw(15) << "Time" << endl;
	int N = 20;
	for (int i = 10000; i <= 100000; i += 1000)
	{
		LARGE_INTEGER averageTime;
		averageTime.QuadPart = 0;

		int* arr = new int[i];
		for (int j = 0; j < i; j++)
		{
			inputTxt >> arr[j];
		}

		for (int j = 0; j < N; j++) 
		{
			LARGE_INTEGER StartTime1, StartTime2, Frequency;
			QueryPerformanceFrequency(&Frequency);

			int* copyArray = CopyArray(arr, i);
			QueryPerformanceCounter(&StartTime1);
			SortArrayByHoarMiddle(copyArray, 0, i - 1);
			QueryPerformanceCounter(&StartTime2);
			averageTime.QuadPart += ((StartTime2.QuadPart -
                                     StartTime1.QuadPart) * 1000000000 / Frequency.QuadPart) / N;
			delete[]copyArray;
		}
		delete[]arr;
		outFile << i << setw(15) << averageTime.QuadPart << endl;
	}
	outFile.close();
	inputTxt.close();
	system("pause");
	return 1;
}

void SortArrayByHoarMiddle(int *A, int i_n, int i_k)
{
	int i = i_n;
	int j = i_k;
	int k = (i + j) / 2;
	int x = A[k];
	do
	{
		while (A[i] < x)
		{
			i++;
		}
		while (x < A[j])
		{
			j--;
		}
		if (i <= j)
		{
			int p = A[i];
			A[i] = A[j];
			A[j] = p;
			i++;
			j--;
		}
	} while (!(i > j));
	if (i_n < j)
	{
		SortArrayByHoarMiddle(A, i_n, j);
	}
	if (i < i_k)
	{
		SortArrayByHoarMiddle(A, i, i_k);
	}
}

int* CopyArray(int *mass, int length)
{
	int *newMass = new int[length];
	for (int i = 0; i < length; i++)
	{
		newMass[i] = mass[i];
	}
	return newMass;
}

Результат работы программы, написанной на C#

Size           Time
10000         100942
11000         127631
12000         117779
13000         131950
14000         141810
15000         151233
16000         158850
17000         189961
18000         195538
19000         206154
20000         209590
21000         223517
22000         231769
23000         239298
24000         249350
25000         266595
26000         275632
27000         294540
28000         297129
29000         311579
30000         318054
31000         328837
32000         334655
33000         390990
34000         395043
35000         402540
36000         409347
37000         422282
38000         428493
39000         435066
40000         440648
41000         462426
42000         469822
43000         474614
44000         485667
45000         494188
46000         506517
47000         507351
48000         520722
49000         524961
50000         558094
51000         563955
52000         580101
53000         587453
54000         606845
55000         614531
56000         624221
57000         628074
58000         650527
59000         654883
60000         665655
61000         671014
62000         687000
63000         690293
64000         698432
65000         703298
66000         810772
67000         817962
68000         823441
69000         831422
70000         839763
71000         846793
72000         856030
73000         862610
74000         879574
75000         884135
76000         893747
77000         899299
78000         908379
79000         917278
80000         923637
81000         926501
82000         966136
83000         971560
84000         978383
85000         982154
86000         989751
87000        1005488
88000        1013646
89000        1028962
90000        1030597
91000        1045373
92000        1047800
93000        1056653
94000        1062558
95000        1094374
96000        1099536
97000        1106445
98000        1118150
99000        1169052
100000        1172926

Построим график по полученным результатам:
Сравнение производительности языков программирования

Вывод:

Как и ожидалось, С++ показал лучшие результаты. Что касается борьбы между C# и Java – то очевидно, что Java выигрывает более чем в два раза у C#. К сожалению, я не могу ответить на вопрос, почему так сильно проигрывает C#, если кто-нибудь знает, напишите – буду благодарен.

Автор: MFomichev

Источник


* - обязательные к заполнению поля


https://ajax.googleapis.com/ajax/libs/jquery/3.4.1/jquery.min.js