Я пытаюсь сравнить производительность std::sort
(с помощью std::vector
структур) против Intel ipp
Сортировать.
Я запускаю этот тест на процессоре Intel Xeon model name : Intel(R) Xeon(R) CPU X5670 @ 2.93GHz
Я сортирую вектор длиной 20000 элементов и сортирую 200 раз. Я попробовал 2 разных ipp
сортировать процедуры, а именно. ippsSortDescend_64f_I
а также ippsSortRadixDescend_64f_I
, Во всех случаях, ipp
сортировка была как минимум в 5-10 раз медленнее, чем std::sort
, Я ожидал ipp
сортировка может быть медленнее для небольших массивов, но в целом она должна быть быстрее, чем std::sort
, Я что-то здесь упускаю? Что я делаю неправильно?
std::sort
последовательно быстрее во всех моих тестовых случаях.
Вот моя программа
#include <array>
#include <iostream>
#include <algorithm>
#include <stdlib.h>
#include <time.h>
#include <sys/time.h>
#include <sys/timeb.h>
#include <vector>
#include <chrono>
#include "ipp.h"
using namespace std;
const int SIZE = 2000000;
const int ITERS = 200;
//Chrono typedefs
typedef std::chrono::high_resolution_clock Clock;
typedef std::chrono::microseconds microseconds;
//////////////////////////////////// std ///////////////////////////////////
typedef vector<double> myList;
void initialize(myList & l, Ipp64f* ptr)
{
double randomNum;
for (int i = 0; i < SIZE; i++)
{
randomNum = 1.0 * rand() / (RAND_MAX / 2) - 1;
l.push_back(randomNum);
ptr[i] = randomNum;
}
}void test_sort()
{
array<myList, ITERS> list;
array<Ipp64f*, ITERS> ippList;
// allocate
for(int i=0; i<ITERS;i++)
{
list[i].reserve(SIZE);
ippList[i] = ippsMalloc_64f(SIZE);
}
// initialize
for(int i=0;i<ITERS;i++)
{
initialize(list[i], ippList[i]);
}
cout << "\n\nTest Case 1: std::sort\n";
cout << "========================\n";
// sort vector
Clock::time_point t0 = Clock::now();
for(int i=0; i<ITERS;i++)
{
std::sort(list[i].begin(), list[i].end());
}
Clock::time_point t1 = Clock::now();
microseconds ms = std::chrono::duration_cast<microseconds>(t1 - t0);
std::cout << ms.count() << " micros" << std::endl;
////////////////////////////////// IPP ////////////////////////////////////////
cout << "\n\nTest Case 2: ipp::sort\n";
cout << "========================\n";
// sort ipp
Clock::time_point t2 = Clock::now();
for(int i=0; i<ITERS;i++)
{
ippsSortAscend_64f_I(ippList[i], SIZE);
}
Clock::time_point t3 = Clock::now();
microseconds ms1 = std::chrono::duration_cast<microseconds>(t3 - t2);
std::cout << ms1.count() << " micros" << std::endl;
for(int i=0; i<ITERS;i++)
{
ippsFree( ippList[i] );
}
}///////////////////////////////////////////////////////////////////////////////////////
int main()
{
srand (time(NULL));
cout << "Test for sorting an array of structures.\n" << endl;
cout << "Test case: \nSort an array of structs ("<<ITERS<<" iterations) with double of length "<<SIZE<<". \n";
IppStatus status=ippInit();
test_sort();
return 0;
}
/////////////////////////////////////////////////////////////////////////////
Команда компиляции:
/share/intel/bin/icc -O2 -I$(IPPROOT)/include sorting.cpp -lrt -L$(IPPROOT)/lib/intel64 -lippi -lipps -lippvm -lippcore -std=c++0x
Выход программы:
Test for sorting an array of structures.
Test case:
Sort an array of structs (200 iterations) with double of length 2000000.Test Case 1: std::sort
========================
38117024 microsTest Case 2: ipp::sort
========================
48917686 micros
Я запустил ваш код на моем компьютере (Core i7 860).
std::sort 32,763,268 (~33s)
ippsSortAscend_64f_I 34,217,517 (~34s)
ippsSortRadixAscend_64f_I 15,319,053 (~15s)
Это ожидаемые результаты. std :: sort встроен и высоко оптимизирован, в то время как ippsSort_ * имеет накладные расходы на вызов функции и множество внутренних проверок, выполняемых всеми функциями ipp. Это должно объяснить небольшое замедление для функции ippsSortAscend. Radix-сортировка все еще в два раза быстрее, чем ожидалось, поскольку она не основана на сравнении.
для более точного результата нужно
Я полагаю, вы забыли вызвать ippInit () перед измерением