Подтвердить что ты не робот

Целое число против двойной арифметической производительности?

Я пишу класс С# для выполнения 2D-разделительной свертки с использованием целых чисел, чтобы получить лучшую производительность, чем двойную копию. Проблема в том, что я не получаю реального прироста производительности.

Это код фильтра X (он действителен как для int, так и для двоичных случаев):

foreach (pixel)
{
      int value = 0;
      for (int k = 0; k < filterOffsetsX.Length; k++)
      {
          value += InputImage[index + filterOffsetsX[k]] * filterValuesX[k];  //index is relative to current pixel position
      }
      tempImage[index] = value;
 }

В целочисленном случае "значение", "InputImage" и "tempImage" имеют типы "int", "Image <byte>" и "Image <int>".
В двойном случае "значение", "InputImage" и "tempImage" имеют типы "double", "Image <double>" и "Image <double>".
(filterValues ​​- int [] в каждом случае)
(Класс Image <T> является частью exll dll. Он должен быть похож на класс .NET Drawing Image..).

Моя цель - добиться быстрой производительности благодаря int + = (byte * int) vs double + = (double * int)

Следующие времена означают 200 повторений.
Размер фильтра 9 = 0,031 (двойной) 0,027 (int)
Размер фильтра 13 = 0,042 (двойной) 0,038 (int)
Размер фильтра 25 = 0,078 (двойной) 0,070 (int)

Прирост производительности минимален. Может ли это быть вызвано конвейером и субоптимальным кодом?

EDIT: упрощен код, удаляющий неважные вары.

EDIT2: я не думаю, что у меня проблема с пропуском кеша, потому что "индекс" повторяется через соседние ячейки памяти (строка за строкой). Кроме того, "filterOffstetsX" содержит только небольшие смещения родственников по пикселям в одной строке и на максимальном расстоянии от размера фильтра /2. Проблема может присутствовать во втором сепарабельном фильтре (Y-фильтр), но времена не так сильно отличаются.

4b9b3361

ОТВЕТЫ

Ответ 1

Похоже, вы говорите, что вы используете только этот внутренний цикл 5000 раз даже в самом длинном случае. Последний FPU, который я проверил (по общему признанию, давным-давно), занял всего около 5 циклов, чтобы выполнить умножение, чем целое число. Таким образом, используя целые числа, вы будете экономить около 25 000 циклов процессора. Это предполагает отсутствие промахов в кеше или что-то еще, что может заставить CPU сидеть и ждать в любом случае.

Предполагая, что современный процессор Intel Core с тактовой частотой около 2,5 ГГц, вы можете ожидать, что сэкономили около 10 микросекунд, используя целочисленный блок. Нездоровый. Я занимаюсь программированием в реальном времени для жизни, и мы не будем потеть столько потерь процессора здесь, даже если у нас где-то не хватает.

digEmAll делает очень хорошее замечание в комментариях. Если компилятор и оптимизатор выполняют свои задания, все это конвейерно. Это означает, что на самом деле весь контур innner будет занимать 5 циклов дольше, чтобы работать с FPU, чем Integer Unit, а не каждая операция в нем. Если бы это было так, ожидаемая экономия времени была бы настолько мала, что было бы трудно измерить их.

Если вы действительно делаете достаточно операций с плавающей запятой, чтобы заставить весь shebang занять очень много времени, я бы предложил изучить одно или несколько из следующего:

  • Распараллеливайте свой алгоритм и запускайте его на каждом процессоре, доступном на вашем процессоре.
  • Не запускайте его на CLR (используйте собственный С++, или Ada или Fortran или что-то еще).
  • Перепишите его для запуска на графическом процессоре. Графические процессоры - это, по сути, массивные процессоры и предназначены для массового параллельного вычисления в массивах значений с плавающей запятой.

Ответ 2

Использование Visual С++, потому что таким образом я могу быть уверен, что я выполняю арифметические операции и не намного больше.

Результаты (каждая операция выполняется 600 миллионов раз):

i16 add: 834575
i32 add: 840381
i64 add: 1691091
f32 add: 987181
f64 add: 979725
i16 mult: 850516
i32 mult: 858988
i64 mult: 6526342
f32 mult: 1085199
f64 mult: 1072950
i16 divide: 3505916
i32 divide: 3123804
i64 divide: 10714697
f32 divide: 8309924
f64 divide: 8266111

freq = 1562587

CPU - это Intel Core i7, Turbo - до 2.53 ГГц.

Код контрольной точки:

#include <stdio.h>
#include <windows.h>

template<void (*unit)(void)>
void profile( const char* label )
{
    static __int64 cumtime;
    LARGE_INTEGER before, after;
    ::QueryPerformanceCounter(&before);
    (*unit)();
    ::QueryPerformanceCounter(&after);
    after.QuadPart -= before.QuadPart;
    printf("%s: %I64i\n", label, cumtime += after.QuadPart);
}

const unsigned repcount = 10000000;

template<typename T>
void add(volatile T& var, T val) { var += val; }

template<typename T>
void mult(volatile T& var, T val) { var *= val; }

template<typename T>
void divide(volatile T& var, T val) { var /= val; }

template<typename T, void (*fn)(volatile T& var, T val)>
void integer_op( void )
{
    unsigned reps = repcount;
    do {
        volatile T var = 2000;
        fn(var,5);
        fn(var,6);
        fn(var,7);
        fn(var,8);
        fn(var,9);
        fn(var,10);
    } while (--reps);
}

template<typename T, void (*fn)(volatile T& var, T val)>
void fp_op( void )
{
    unsigned reps = repcount;
    do {
        volatile T var = (T)2.0;
        fn(var,(T)1.01);
        fn(var,(T)1.02);
        fn(var,(T)1.03);
        fn(var,(T)2.01);
        fn(var,(T)2.02);
        fn(var,(T)2.03);
    } while (--reps);
}

int main( void )
{
    LARGE_INTEGER freq;
    unsigned reps = 10;
    do {
        profile<&integer_op<__int16,add<__int16>>>("i16 add");
        profile<&integer_op<__int32,add<__int32>>>("i32 add");
        profile<&integer_op<__int64,add<__int64>>>("i64 add");
        profile<&fp_op<float,add<float>>>("f32 add");
        profile<&fp_op<double,add<double>>>("f64 add");

        profile<&integer_op<__int16,mult<__int16>>>("i16 mult");
        profile<&integer_op<__int32,mult<__int32>>>("i32 mult");
        profile<&integer_op<__int64,mult<__int64>>>("i64 mult");
        profile<&fp_op<float,mult<float>>>("f32 mult");
        profile<&fp_op<double,mult<double>>>("f64 mult");

        profile<&integer_op<__int16,divide<__int16>>>("i16 divide");
        profile<&integer_op<__int32,divide<__int32>>>("i32 divide");
        profile<&integer_op<__int64,divide<__int64>>>("i64 divide");
        profile<&fp_op<float,divide<float>>>("f32 divide");
        profile<&fp_op<double,divide<double>>>("f64 divide");

        ::QueryPerformanceFrequency(&freq);

        putchar('\n');
    } while (--reps);

    printf("freq = %I64i\n", freq);
}

Я построил по умолчанию оптимизированную сборку, используя 32-разрядную версию Visual С++ 2010.

Каждый вызов profile, add, mult и divide (внутри петель) встал в очередь. Функциональные вызовы все еще были сгенерированы до profile, но поскольку для каждого вызова выполнено 60 миллионов операций, я думаю, что служебные данные вызова функции несущественны.

Даже при вбрасывании volatile компилятор Visual С++ оптимизирует SMART. Первоначально я использовал маленькие целые числа в качестве правого операнда, и компилятор с радостью использовал инструкции lea и add для умножения целого числа. Вы можете получить больше стимулов от вызова высокооптимизированного кода на С++, чем предлагает общая мудрость, просто потому, что оптимизатор С++ делает гораздо лучшую работу, чем любая JIT.

Первоначально у меня была инициализация var вне цикла, и это сделало код умножения с плавающей запятой запутанным медленным из-за постоянного переполнения. FPU, обрабатывающий NaNs, медленный, что-то еще нужно иметь в виду при написании высокопроизводительных подпрограмм с числовым хрустом.

Зависимости также настраиваются таким образом, чтобы предотвратить конвейерную обработку. Если вы хотите увидеть эффекты конвейерной обработки, скажем так в комментарии, и я пересмотрю testbench, чтобы работать с несколькими переменными вместо одного.

Разборка i32 умножается:

;   COMDAT [email protected][email protected]@@[email protected]@@YAXXZ
_TEXT   SEGMENT
_var$66971 = -4                     ; size = 4
[email protected][email protected]@@[email protected]@@YAXXZ PROC   ; integer_op<int,&mult<int> >, COMDAT

; 29   : {

  00000 55       push    ebp
  00001 8b ec        mov     ebp, esp
  00003 51       push    ecx

; 30   :    unsigned reps = repcount;

  00004 b8 80 96 98 00   mov     eax, 10000000      ; 00989680H
  00009 b9 d0 07 00 00   mov     ecx, 2000      ; 000007d0H
  0000e 8b ff        npad    2
[email protected][email protected]:

; 31   :    do {
; 32   :        volatile T var = 2000;

  00010 89 4d fc     mov     DWORD PTR _var$66971[ebp], ecx

; 33   :        fn(var,751);

  00013 8b 55 fc     mov     edx, DWORD PTR _var$66971[ebp]
  00016 69 d2 ef 02 00
    00       imul    edx, 751       ; 000002efH
  0001c 89 55 fc     mov     DWORD PTR _var$66971[ebp], edx

; 34   :        fn(var,6923);

  0001f 8b 55 fc     mov     edx, DWORD PTR _var$66971[ebp]
  00022 69 d2 0b 1b 00
    00       imul    edx, 6923      ; 00001b0bH
  00028 89 55 fc     mov     DWORD PTR _var$66971[ebp], edx

; 35   :        fn(var,7124);

  0002b 8b 55 fc     mov     edx, DWORD PTR _var$66971[ebp]
  0002e 69 d2 d4 1b 00
    00       imul    edx, 7124      ; 00001bd4H
  00034 89 55 fc     mov     DWORD PTR _var$66971[ebp], edx

; 36   :        fn(var,81);

  00037 8b 55 fc     mov     edx, DWORD PTR _var$66971[ebp]
  0003a 6b d2 51     imul    edx, 81            ; 00000051H
  0003d 89 55 fc     mov     DWORD PTR _var$66971[ebp], edx

; 37   :        fn(var,9143);

  00040 8b 55 fc     mov     edx, DWORD PTR _var$66971[ebp]
  00043 69 d2 b7 23 00
    00       imul    edx, 9143      ; 000023b7H
  00049 89 55 fc     mov     DWORD PTR _var$66971[ebp], edx

; 38   :        fn(var,101244215);

  0004c 8b 55 fc     mov     edx, DWORD PTR _var$66971[ebp]
  0004f 69 d2 37 dd 08
    06       imul    edx, 101244215     ; 0608dd37H

; 39   :    } while (--reps);

  00055 48       dec     eax
  00056 89 55 fc     mov     DWORD PTR _var$66971[ebp], edx
  00059 75 b5        jne     SHORT [email protected][email protected]

; 40   : }

  0005b 8b e5        mov     esp, ebp
  0005d 5d       pop     ebp
  0005e c3       ret     0
[email protected][email protected]@@[email protected]@@YAXXZ ENDP   ; integer_op<int,&mult<int> >
; Function compile flags: /Ogtp
_TEXT   ENDS

И умножить f64:

;   COMDAT [email protected][email protected]@@[email protected]@@YAXXZ
_TEXT   SEGMENT
_var$67014 = -8                     ; size = 8
[email protected][email protected]@@[email protected]@@YAXXZ PROC        ; fp_op<double,&mult<double> >, COMDAT

; 44   : {

  00000 55       push    ebp
  00001 8b ec        mov     ebp, esp
  00003 83 e4 f8     and     esp, -8            ; fffffff8H

; 45   :    unsigned reps = repcount;

  00006 dd 05 00 00 00
    00       fld     QWORD PTR [email protected]
  0000c 83 ec 08     sub     esp, 8
  0000f dd 05 00 00 00
    00       fld     QWORD PTR [email protected]
  00015 b8 80 96 98 00   mov     eax, 10000000      ; 00989680H
  0001a dd 05 00 00 00
    00       fld     QWORD PTR [email protected]
  00020 dd 05 00 00 00
    00       fld     QWORD PTR [email protected]
  00026 dd 05 00 00 00
    00       fld     QWORD PTR [email protected]
  0002c dd 05 00 00 00
    00       fld     QWORD PTR [email protected]
  00032 dd 05 00 00 00
    00       fld     QWORD PTR [email protected]
  00038 eb 02        jmp     SHORT [email protected][email protected]
[email protected][email protected]:

; 46   :    do {
; 47   :        volatile T var = (T)2.0;
; 48   :        fn(var,(T)1.01);
; 49   :        fn(var,(T)1.02);
; 50   :        fn(var,(T)1.03);
; 51   :        fn(var,(T)2.01);
; 52   :        fn(var,(T)2.02);
; 53   :        fn(var,(T)2.03);
; 54   :    } while (--reps);

  0003a d9 ce        fxch    ST(6)
[email protected][email protected]:
  0003c 48       dec     eax
  0003d d9 ce        fxch    ST(6)
  0003f dd 14 24     fst     QWORD PTR _var$67014[esp+8]
  00042 dd 04 24     fld     QWORD PTR _var$67014[esp+8]
  00045 d8 ce        fmul    ST(0), ST(6)
  00047 dd 1c 24     fstp    QWORD PTR _var$67014[esp+8]
  0004a dd 04 24     fld     QWORD PTR _var$67014[esp+8]
  0004d d8 cd        fmul    ST(0), ST(5)
  0004f dd 1c 24     fstp    QWORD PTR _var$67014[esp+8]
  00052 dd 04 24     fld     QWORD PTR _var$67014[esp+8]
  00055 d8 cc        fmul    ST(0), ST(4)
  00057 dd 1c 24     fstp    QWORD PTR _var$67014[esp+8]
  0005a dd 04 24     fld     QWORD PTR _var$67014[esp+8]
  0005d d8 cb        fmul    ST(0), ST(3)
  0005f dd 1c 24     fstp    QWORD PTR _var$67014[esp+8]
  00062 dd 04 24     fld     QWORD PTR _var$67014[esp+8]
  00065 d8 ca        fmul    ST(0), ST(2)
  00067 dd 1c 24     fstp    QWORD PTR _var$67014[esp+8]
  0006a dd 04 24     fld     QWORD PTR _var$67014[esp+8]
  0006d d8 cf        fmul    ST(0), ST(7)
  0006f dd 1c 24     fstp    QWORD PTR _var$67014[esp+8]
  00072 75 c6        jne     SHORT [email protected][email protected]
  00074 dd d8        fstp    ST(0)
  00076 dd dc        fstp    ST(4)
  00078 dd da        fstp    ST(2)
  0007a dd d8        fstp    ST(0)
  0007c dd d8        fstp    ST(0)
  0007e dd d8        fstp    ST(0)
  00080 dd d8        fstp    ST(0)

; 55   : }

  00082 8b e5        mov     esp, ebp
  00084 5d       pop     ebp
  00085 c3       ret     0
[email protected][email protected]@@[email protected]@@YAXXZ ENDP        ; fp_op<double,&mult<double> >
; Function compile flags: /Ogtp
_TEXT   ENDS

Ответ 3

Ваш алгоритм, по-видимому, имеет доступ к большим областям памяти в очень не последовательном шаблоне. Вероятно, он генерирует тонны промахов в кэше. Узким местом является, вероятно, доступ к памяти, а не арифметика. Использование int должно сделать это немного быстрее, потому что ints - 32 бита, в то время как удваивается 64 бита, то есть кеш будет использоваться немного более эффективно. Если почти каждая итерация цикла включает промаху в кеше, вы в основном не повезло, если не можете внести некоторые изменения в алгоритмику или структуру структуры данных, чтобы улучшить локальность ссылки.

Кстати, вы считали использование БПФ для свертки? Это приведет вас к совершенно другому классу "большой-O".

Ответ 4

по крайней мере, несправедливо сравнивать int (DWORD, 4 байта) и double (QWORD, 8 байт) в 32-битной системе. Сравните int с float или long до double, чтобы получить справедливые результаты. double имеет повышенную точность, вы должны заплатить за него.

PS: для меня это пахнет микро (+ преждевременной) оптимизацией, и этот запах не очень хорош.

Изменить: Хорошо, хорошо. Неправильно сравнивать длинные, чтобы удвоить, но все же сравнение int и double на 32 CPU неверно, даже если они имеют как внутренние инструкции. Это не волшебство, x86 - толстый CISC, а double double не обрабатывается как единый шаг внутри.

Ответ 5

На моей машине я нахожу, что умножение с плавающей запятой имеет одинаковую скорость с целым умножением.

Я использую эту функцию синхронизации:

static void Time<T>(int count, string desc, Func<T> action){
    action();

    Stopwatch sw = Stopwatch.StartNew();
    for(int i = 0; i < count; i++)
        action();

    double seconds = sw.Elapsed.TotalSeconds;

    Console.WriteLine("{0} took {1} seconds", desc, seconds);
}

Скажем, вы обрабатываете массив 200 x 200 с фильтром длиной 25 бит 200 раз, тогда ваш внутренний цикл выполняет 200 * 200 * 25 * 200 = 200 000 000 раз. Каждый раз вы делаете однократное, одно добавление и 3 индексы массива. Поэтому я использую этот код профилирования

const int count = 200000000;

int[]  a = {1};
double d = 5;
int    i = 5;

Time(count, "array index", ()=>a[0]);
Time(count, "double mult", ()=>d * 6);
Time(count, "double add ", ()=>d + 6);
Time(count, "int    mult", ()=>i * 6);
Time(count, "int    add ", ()=>i + 6);

На моей машине (медленнее, чем ваша, я думаю), я получаю следующие результаты:

array index took 1.4076632 seconds
double mult took 1.2203911 seconds
double add  took 1.2342998 seconds
int    mult took 1.2170384 seconds
int    add  took 1.0945793 seconds

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

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

Кстати, разница в производительности для деления гораздо более поразительна. Следуя приведенному выше шаблону, я получаю:

double div  took 3.8597251 seconds
int    div  took 1.7824505 seconds

Еще одно примечание:

Чтобы быть понятным, все профилирование должно выполняться с оптимизированной версией сборки. Отладочные сборки будут медленнее в целом, и некоторые операции могут не иметь точного времени относительно других.

Ответ 6

Если время, которое вы измерили, точнее, время выполнения вашего алгоритма фильтрации, похоже, растет с кубом размера фильтра. Что это за фильтр? Возможно, вы можете уменьшить количество необходимых умножений. (например, если вы используете разделимое ядро ​​фильтра?)

В противном случае, если вам нужна сырая производительность, вы можете использовать библиотеку, такую ​​как Intel Performance Primitives, - она ​​содержит высоко оптимизированные функции для таких вещей, которые используют инструкции CPU SIMD. Они обычно намного быстрее, чем написанный вручную код на С# или С++.

Ответ 7

Вы пытались посмотреть на разобранный код? В языках высокого уровня я очень доверяю компилятору для оптимизации моего кода. Например for(i=0;i<imageSize;i++) может быть быстрее, чем foreach. Кроме того, арифметические операции могут быть оптимизированы компилятором в любом случае.... когда вам нужно оптимизировать что-либо, вы либо оптимизируете весь "черный ящик", либо, возможно, изобретаете алгоритм, используемый в этом цикле, или сначала смотрите на разобранную код и посмотреть, что с ним не так.