這是我用所有三種語言運行矩陣乘法時發生的情況

在過去的兩年中，我為C語言做了大量的實現工作。 我之所以選擇C語言而不是其他語言，是因為人們普遍認為C代碼比其他流行的編程語言(例如Java和Python)運行得更快。 但是，即使我一直對C的速度(或C實際上最快)感到好奇，我自己也沒有做任何實驗來證實這一說法。 最后，我決定進行一些實驗，以比較C，Java和Python的性能。 本文是關于我進行的實驗和獲得的結果的文章。

本實驗

我決定使用所有三種語言進行矩陣乘法。 矩陣的大小為2048 x 2048(即每個矩陣的乘法和加法運算為8,589,934,592)，我為它們填充了0.0到1.0之間的隨機值(使用隨機值而不是對所有三種語言使用完全相同的矩陣的影響可以忽略不計)。 我將每個實驗運行了五次，并計算了平均運行時間。

C代碼

#include <stdlib.h> 
#include <stdio.h> 
#include <time.h> 
 
#define n 2048 
 
double A[n][n]; 
double B[n][n]; 
double C[n][n]; 
 
int main() { 
 
    //populate the matrices with random values between 0.0 and 1.0 
    for (int i = 0; i < n; i++) { 
        for (int j = 0; j < n; j++) { 
 
            A[i][j] = (double) rand() / (double) RAND_MAX; 
            B[i][j] = (double) rand() / (double) RAND_MAX; 
            C[i][j] = 0; 
        } 
    } 
 
    struct timespec start, end; 
    double time_spent; 
 
    //matrix multiplication 
    clock_gettime(CLOCK_REALTIME, &start); 
    for (int i = 0; i < n; i++) { 
        for (int j = 0; j < n; j++) { 
            for (int k = 0; k < n; k++) { 
                C[i][j] += A[i][k] * B[k][j]; 
            } 
        } 
    } 
    clock_gettime(CLOCK_REALTIME, &end); 
    time_spent = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1000000000.0; 
    printf("Elapsed time in seconds: %f \n", time_spent); 
    return 0; 
} 

Java代碼

import java.util.Random; 
 
public class MatrixMultiplication { 
    static int n = 2048; 
    static double[][] A = new double[n][n]; 
    static double[][] B = new double[n][n]; 
    static double[][] C = new double[n][n]; 
 
    public static void main(String[] args) { 
        //populate the matrices with random values between 0.0 and 1.0 
        Random r = new Random(); 
        for (int i = 0; i < n; i++) { 
            for (int j = 0; j < n; j++) { 
                A[i][j] = r.nextDouble(); 
                B[i][j] = r.nextDouble(); 
                C[i][j] = 0; 
            } 
        } 
 
        long start = System.nanoTime(); 
        //matrix multiplication 
        for (int i = 0; i < n; i++) { 
            for (int j = 0; j < n; j++) { 
                for (int k = 0; k < n; k++) { 
                    C[i][j] += A[i][k] * B[k][j]; 
                } 
            } 
        } 
 
        long stop = System.nanoTime(); 
        double timeDiff = (stop - start) * 1e-9; 
        System.out.println("Elapsed time in seconds: " + timeDiff); 
    } 
} 

Python代碼

import random 
import time 
 
n = 2048 
 
#populate the matrices with random values between 0.0 and 1.0 
A = [[random.random() for row in range(n)] for col in range(n)] 
B = [[random.random() for row in range(n)] for col in range(n)] 
C = [[0 for row in range(n)] for col in range(n)] 
 
start = time.time() 
#matrix multiplication 
for i in range(n): 
    for j in range(n): 
        for k in range(n): 
            C[i][j] += A[i][k] * B[k][j] 
 
end = time.time() 
print("Elapsed time in seconds %0.6f" % (end-start)) 
如何編譯和運行 
#C 
gcc MatrixMultiplication.c -o matrix 
./matrix 
 
#Java 
javac MatrixMultiplication.java 
java MatrixMultiplication 
 
#Python 
python MatrixMultiplication.py 

如何編譯和運行

#C 
gcc MatrixMultiplication.c -o matrix 
./matrix 
 
#Java 
javac MatrixMultiplication.java 
java MatrixMultiplication 
 
#Python 
python MatrixMultiplication.py 

運行時間

根據這些結果，C比Java慢2.34倍，Python比Java慢33.34倍。

等待!!! C應該不是最快的嗎???

實際上，這是不公平的比較。 當我們編譯Java程序時，即使沒有任何優化標志，Java JIT(即時)編譯器也會自動執行優化。 但是，對于GCC(編譯C程序)，情況并非如此，我們必須顯式設置優化標志。

因此，我在編譯C程序時使用了-O2和-O3優化標志，并再次進行了實驗。

gcc -O2 MatrixMultiplication.c -o matrix./matrixgcc -O3 MatrixMultiplication.c -o matrix./matrix

新的經過時間

現在，Java代碼比C [-O3]慢1.69倍，而Python代碼慢56倍。 我做出了正確的決定(或者很幸運：-))，選擇了C而不是其他編程語言。

總結結果

討論結果

• Python相對非常慢，因為C是經過編譯的，而Python是被解釋的。 編譯器一次將C代碼轉換為機器代碼。 另一方面，解釋器必須讀取，解釋和執行每一行代碼，并更新機器狀態(這會增加很多開銷)。 將程序編譯為機器代碼時，CPU可以直接執行它。 但是，當涉及到解釋器時，CPU將運行解釋器，并且解釋器本身將執行程序。 (如果您對編譯器和解釋器感興趣，請閱讀Vaidehi Joshi撰寫的精彩文章)
• 這就是使Python非常靈活的原因。 Python犧牲了一點性能來提供更多的靈活性/高級編程功能(如果不使用C語言指定數據類型，則不能將變量初始化為n = 100，但是可以在Python中進行初始化)。
• JIT(Java編譯器)位于C和Python之間。 首次執行代碼時，將對其進行解釋。 但是，當一段代碼頻繁執行時，它會實時編譯為機器代碼，并且進一步的執行將使用編譯后的版本。

本文的靈感來自Charles E. Leiserson教授關于性能工程的演講，我修改了他使用的源代碼以滿足我的要求。