сегодня в 14:40
Привет тебе, дорогой %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("Size\tTime");
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("Size\tTime");
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#, если кто-нибудь знает, напишите – буду благодарен.
Нет времени
на счета?
MasterCard
Mobile
Только зарегистрированные пользователи могут оставлять комментарии. Войдите, пожалуйста.
This entry passed through the Full-Text RSS service — if this is your content and you're reading it on someone else's site, please read the FAQ at fivefilters.org/content-only/faq.php#publishers.
Комментариев нет:
Отправить комментарий