OpenCL медленнее на настольном компьютере, чем macbook 13 «

Question

Я пишу программу OpenCL, которую я впервые написал на своем Macbook Pro, и поскольку мой настольный компьютер сильнее, я хотел портировать код и посмотреть, есть ли какие-либо улучшения.

Тот же самый код баллотировался:

Mac: 0.055452s

Win7: 0.359s

характеристики обоих компьютеров: Mac: 2.6GHz Intel Core i5, 8 Гб 1600 МГц DDR3, Intel Iris 1536MB

PC: 3,3 ГГц Intel Core i5-2500K, 8 Гб 1600 МГц DDR3, AMD Radeon HD 6900 Series

Теперь, как вы можете увидеть код побежал на моем Mac почти в 10 раз быстрее, чем на моем настольном ПК.

я приурочил код с помощью

#include<ctime> 
clock_t begin = clock(); 
....// Entire main file 
float timeTaken = (float)(clock() - begin)/CLOCKS_PER_SEC; 
cout << "Time taken: " << timeTaken << endl; 

Если я не ошибаюсь, как CPU и GPU сильнее на ПК. Я смог запустить Battlefield 3 на настройках Ultra с помощью этого настольного компьютера.

Только разница может заключаться в том, что Visual Studio на ПК компилируется с другим компилятором? Я использовал g ++ на своем mac, не уверен, что использует Visual Studio.

Эти результаты не имеют смысла для меня. Ребята, что вы думаете? Если вы хотите, чтобы проверить код, который я могу разместить ссылку GitHub

EDIT: Следующая ссылка GitHub показывает код https://github.com/Batkow/OpenCL/tree/master/OpenCL. PSO_V2 использует тип кодирования, используемые в учебнике из: https://www.fixstars.com/en/opencl/book/OpenCLProgrammingBook/introduction-to-parallelization/

И ПСО упрощает кодирование с использованием пользовательских заголовков из этого GitHub репо: https://github.com/HandsOnOpenCL/Exercises-Solutions ..

Я побежал код на моих друзьях нового i7 портативного компьютера с NVidia Geforce 950M и код был выполнен еще медленнее, чем на моем настольном ПК.

Я действительно понимаю, что код не оптимизирован, поэтому любые намеки на глупые вещи, которые я делаю, пожалуйста, обращайтесь к ним. Например, если цикл while через три разные функции ядра выглядит глупо правильным? Я работаю над тем, чтобы реализовать все это внутри ядра и внутри него цикла, что должно повысить производительность?

ОБНОВЛЕНИЕ: Раскройте код OpenCL/PSO на окнах дома снова. Сроки кода до и после цикла while дают WINDOWS более высокую производительность yay!

clock_t Win7 = 0,027 и Mac = 0,036. Использование внешнего .hpp с классом Util :: Timer Win7 продолжалось: 0,026, а Mac - 0,085.

С момента начала основного файла справа перед циклом while (все инициализации) Mac набрал лучше Windows почти в 10 раз, используя как clock_t, так и Util :: Timer. Итак, узкое место, похоже, стоит на инициализации устройства?

Answer 1

Visual Studio будет использовать компилятор MSVC, если не указано иное.

Я думаю, что ответ скрыт в ваших поколениях ЦП. На вашем ПК это Sandy Bridge (2-й ген) и на Mac - Haswell (4-й ген). Это разница в 2 поколения.

OpenCL - это одна из вещей, которая значительно развивалась во время этих поколений процессоров Intel (чрезмерная аппаратная поддержка в Haswell).

Просто, чтобы получить доказательство - найдите друга с рабочим столом, оснащенным процессором Haswell, и запустите свои тесты. Рабочий процессор Haswell должен бить ваш Mac один (конечно, если другие аппаратные спецификации и общая загрузка системы будут совпадать).

Answer 2

Может быть, десятки вещей - то, что делает ядро ​​CL, будет ключевым, и насколько хорошо это работает на разных типах графических процессоров. Или какой компилятор используется

Однако, я думаю, проблема в том, как вы измеряете время. clock() на Windows измеряет «время работы на стену» (другими словами «прошедшее время»), на OSX (и всех других нормальных ОС), он сообщает процессорное время для вашего процесса. Если OSX работает на графическом процессоре [или в отдельном процессе], он не будет считаться CPU-time, где Windows измеряет общее время.

Измерьте время процессора, используя соответствующее время измерения ЦП в Windows (например, GetProcessTimes). Или используйте C++ std::chrono для измерения времени настенных часов в обоих местах.

Answer 3

Может быть проблема с пути вы измерения уходящего времени, например, я сделал три различных способа сделать это в моем проекте для разных ОС:

#include <cstdio> 
#include <iostream> 

#if defined(_WIN32) || defined(_WIN64) 
#include <windows.h> 
#elif defined(__linux__) 
#include <time.h> 
#elif defined(__APPLE__) 
#include <mach/mach.h> 
#include <mach/mach_time.h> 
#include <stddef.h> 
#endif 
#if defined(_WIN32) || defined(_WIN64) 
LARGE_INTEGER frequency; // ticks per second 
LARGE_INTEGER t0, t1, t2; // ticks 
LARGE_INTEGER t3, t4; 
#elif defined(__linux__) 
timespec t0, t1, t2; 
timespec t3, t4; 
double us; 
#elif defined(__APPLE__) 
unsigned long t0, t1, t2; 
#endif 
double elapsedTime; 
void refreshTime() { 
#if defined(_WIN32) || defined(_WIN64) 
    QueryPerformanceFrequency(&frequency); // get ticks per second 
    QueryPerformanceCounter(&t1);   // start timer 
    t0 = t1; 
#elif defined(__linux__) 
    clock_gettime(CLOCK_MONOTONIC_RAW, &t1); 
    t0 = t1; 
#elif defined(__APPLE__) 
    t1 = mach_absolute_time(); 
    t0 = t1; 
#endif 
} 

void watch_report(const char *str) { 
#if defined(_WIN32) || defined(_WIN64) 
    QueryPerformanceCounter(&t2); 
    printf(str, (t2.QuadPart - t1.QuadPart) * 1000.0/frequency.QuadPart); 
    t1 = t2; 
    elapsedTime = (t2.QuadPart - t0.QuadPart) * 1000.0/frequency.QuadPart; 
#elif defined(__linux__) 
    clock_gettime(CLOCK_MONOTONIC_RAW, &t2); 
    time_t sec = t2.tv_sec - t1.tv_sec; 
    long nsec; 
    if (t2.tv_nsec >= t1.tv_nsec) { 
    nsec = t2.tv_nsec - t1.tv_nsec; 
    } else { 
    nsec = 1000000000 - (t1.tv_nsec - t2.tv_nsec); 
    sec -= 1; 
    } 
    printf(str, (float)sec * 1000.f + (float)nsec/1000000.f); 
    t1 = t2; 
    elapsedTime = (float)(t2.tv_sec - t0.tv_sec) * 1000.f + 
       (float)(t2.tv_nsec - t0.tv_nsec)/1000000.f; 
#elif defined(__APPLE__) 
    uint64_t elapsedNano; 
    static mach_timebase_info_data_t sTimebaseInfo; 

    if (sTimebaseInfo.denom == 0) { 
    (void)mach_timebase_info(&sTimebaseInfo); 
    } 

    t2 = mach_absolute_time(); 
    elapsedNano = (t2 - t1) * sTimebaseInfo.numer/sTimebaseInfo.denom; 
    printf(str, (float)elapsedNano/1000000.f); 
    t1 = t2; 
    elapsedNano = (t2 - t0) * sTimebaseInfo.numer/sTimebaseInfo.denom; 
    elapsedTime = (float)elapsedNano/1000000.f; 
#endif 
} 
/*This Function will work till you press q*/ 
void someFunction() { 
    while (1) { 
    char ch = std::cin.get(); 
    if (ch == 'q') 
     break; 
    } 
} 

int main() { 
    refreshTime(); 
    someFunction(); 
    watch_report("some function was working: \t%9.3f ms\n"); 
} 

Answer 4

Другая возможная причина, почему вы можете быть с, что результаты - возможно ваша программа компилируется в OpenCL ver.2.0.

В Windows ваш GPU работает с 2010 года, он поддерживает только OpenCL 1.2.

На OSX ваш Intel GPU поддерживает OpenCL 2.0.

Answer 5

Вы разместили свои функции синхронизации, но не код OpenCL. Что все приурочено? Большим фактором может быть время компиляции ядра (clCreateProgramFromSource и clBuildProgram). Ваш компьютер может использовать кешированные ядра, а ваш Mac - нет. Правильный способ измерения времени выполнения OpenCL - это использовать события OpenCL.

Answer 6

Его функция clock() просто подсчитывает циклы тактовых импульсов ЦП. Ваш хост-код может вызвать ядро ​​и затем переспать. И это время сна обычно не учитывается функцией часов, даже если вы выполняете ядро. Таким образом, это означает, что функция часов учитывает только время выполнения хост-кода, а не ядро ​​openCL. Вам нужно использовать функцию, которая учитывает время настенных часов, а не тактовые циклы процессора.