为什么c ++代码实现的性能不如python实现？

Question

I am doing benchmarking for finding nearest neighbour for the datapoints. My c++ implementation and python implementation are taking almost same execution time. Shouldn't be c++ works better than the raw python implementation.

• C++ Execution Time : 8.506 seconds
• Python Execution Time : 8.7202 seconds

C++ Code:

#include <iostream>
#include <random>
#include <map>
#include <cmath>
#include <numeric> 
#include <algorithm>
#include <chrono>
#include <vector>     // std::iota

using namespace std;
using namespace std::chrono;

double edist(double* arr1, double* arr2, uint n) {
    double sum = 0.0;
    for (int i=0; i<n; i++) {
        sum += pow(arr1[i] - arr2[i], 2);
    }
    return sqrt(sum); }

template <typename T> vector<size_t> argsort(const vector<T> &v) {
  // initialize original index locations
  vector<size_t> idx(v.size());   iota(idx.begin(), idx.end(), 0);

  // sort indexes based on comparing values in v
  sort(idx.begin(), idx.end(),
       [&v](size_t i1, size_t i2) {return v[i1] < v[i2];});

  return std::vector<size_t>(idx.begin() + 1, idx.end()); }

int main() {

    uint N, M;
    // cin >> N >> M;
    N = 1000;
    M = 800;
    double **arr = new double*[N];
    std::random_device rd; // obtain a random number from hardware
    std::mt19937 eng(rd()); // seed the generator
    std::uniform_real_distribution<> distr(10.0, 60.0);

    for (int i = 0; i < N; i++) {
        arr[i] = new double[M];
        for(int j=0; j < M; j++) {
            arr[i][j] = distr(eng);
        }
    }
    auto start = high_resolution_clock::now();
    map<int, vector<size_t> > dist;

    for (int i=0; i<N; i++) {
        vector<double> distances;
        for(int j=0; j<N; j++) {
            distances.push_back(edist(arr[i], arr[j], N));
        }
        dist[i] = argsort(distances);
    }
    auto stop = high_resolution_clock::now();
    auto duration = duration_cast<microseconds>(stop-start);
    int dur = duration.count();
    cout<<"Time taken by code: "<<dur<<" microseconds"<<endl;
    cout<<" In seconds: "<<dur/pow(10,6);  
        return 0; }

Python Code:

import time
import numpy as np
def comp_inner_raw(i, x):
    res = np.zeros(x.shape[0], dtype=np.float64)
    for j in range(x.shape[0]):
        res[j] = np.sqrt(np.sum((i-x[j])**2))
    return res
def nearest_ngbr_raw(x): # x = [[1,2,3],[4,5,6],[7,8,9]]
    #print("My array: ",x)
    dist = {}
    for idx,i in enumerate(x):
        #lst = []
        lst = comp_inner_raw(i,x)
        s = np.argsort(lst)#[1:]
        sorted_array = np.array(x)[s][1:]
        dist[idx] = s[1:]
    return dist
arr = np.random.rand(1000, 800)
start = time.time()
table = nearest_ngbr_raw(arr)
print("Time taken to execute the code using raw python is {}".format(time.time()-start))

Compile Command:

 g++ -std=c++11 knn.cpp -o knn 

C++ compiler(g++) version for ubuntu 18.04.1: 7.4.0

Coded in c++11

Numpy version : 1.16.2

Edit Tried with compiler optimization, now it is taking around 1 second. Can this c++ code be optimized further from coding or any other perspective?

Answer 1

Can this c++ code be optimized further from coding or any other perspective?

I can see at least three optimisations. The first two are easy and should definitely be done but in my testing they end up not impacting the runtime measurably. The third one requires rethinking the code minimally.

1. edist caculates a costly square root, but you are only using the distance for pairwise comparison. Since the square root function is monotonically increasing, it has no impact on the comparison result. Similarly, pow(x, 2) can be replaced with x * x and this is sometimes faster:

    double edist(std::vector<double> const& arr1, std::vector<double> const& arr2, uint n) { double sum = 0.0; for (unsigned int i = 0; i < n; i++) { auto const diff = arr1[i] - arr2[i]; sum += diff * diff; } return sum; } 

2. argsort performs a copy because it returns the indices excluding the first element. If you instead include the first element (change the return statement to return idx; ), you avoid a potentially costly copy.

3. Your matrix is represented as a nested array (and you're for some reason using raw pointers instead of a nested std::vector ). It's generally more efficient to represent matrices as contiguous N*M arrays: std::vector<double> arr(N * M); . This is also how numpy represents matrices internally. This requires changing the code to calculate the indices.