Привет тебе, дорогой %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
