1. Если вы только начинаете программировать на ассемблере и не знаете с чего начать, тогда попробуйте среду разработки ASM Visual IDE
    (c) на правах рекламы
    Скрыть объявление

borland vs studio

Тема в разделе "LANGS.C", создана пользователем bolt90, 5 мар 2012.

  1. bolt90

    bolt90 New Member

    Публикаций:
    0
    Регистрация:
    21 май 2009
    Сообщения:
    18
    тестировал програмку, которая загружает библиотеку, выполняет функцию, и дальше обрабатывает результат. но это не суть важно, а дело в том что, для теста брал функции чтоб было побольше вычислений, написал одну коротенькую чтоб считала пи. Запустил, очень долго шурует (на нормальном компе) 26секунд, с всегото 1 млн интервалов. Писал на борланде, но на той машине на которой тестил уже его не было так что сделал тоже самое на вижуале. Запускаю и тут....1.5 сек с такими же параметрами. Я сначало подумал что пару нулей не поставил...не тут то было, все правильно, а рубает мгновено. Начал рытся,искать, поменял версию на дебуг...оп 26 секунд тоже. меняю на релиз 1.5. Думаю ничего себе оптимизация. Пришел домой поставил релиз на борланде, в настройках максимально быстрый код - ну и что бы вы думаете, ничего не дало почти. Ну не может быть чтоб одинакоый сишный код 2 разные компиляторы настолько по-разному перерабатывали. Может я чтото не включил в борланде? Продолжаю эксерименты, теперь с под борланда запускаю библиотечку на студии, запомнил результати. Тоже самое с под студии - на 1 сек быстрее. Чтоб убедится окончательно, вставил прям в функцию команды для измерения времени. Запустил одну и туже функцию абсолютно одинаково через LoadLibrary/GetProcAddress с одинаковыми параметрами и она дает опять таки разницу в секунду. И непонятно почему?! Нервов не хватает... Кстате версии - BDS 2010|Visual 2010
    Вот функция
    Код (Text):
    1. double f(double a)
    2. {
    3.     return (4.0 / (1.0 + a*a));
    4. }
    5. __declspec(dllexport) double pi(int begin,int intervals,int step)
    6. {
    7.      float h = 1.0 / (double) intervals,x;
    8.      static double sum = 0.0;
    9.      int i;
    10.      int t0=GetTickCount();
    11.             for(i = begin; i <= intervals; i += step)
    12.             {
    13.                 x = h * ((double)i - 0.5);
    14.                 sum += f(x);
    15.             }
    16.             sum *= h;
    17.               int t1=GetTickCount();
    18.     printf("%d\n",t1-t0);
    19.     return sum;
    20. }
     
  2. CyberManiac

    CyberManiac New Member

    Публикаций:
    0
    Регистрация:
    2 сен 2003
    Сообщения:
    2.473
    Адрес:
    Russia
    Запусти скомпилированный релиз не из самого Билдера, а отдельно, вне среды. Может, поможет.
     
  3. samuraishowdown

    samuraishowdown New Member

    Публикаций:
    0
    Регистрация:
    6 мар 2011
    Сообщения:
    70
    Может и не поможет.
    Но в функе ТСа я криминала не вижу, который тормозить может или по разному компилиться для дебуг/релиз. Нужно весь код смотреть. В студии в дебуг версии, память при выделении в хипе инициализируется 0хcd, в релизе не инициализируется - разница в скорости работы может быть большой. Это для примера.
     
  4. kaspersky

    kaspersky New Member

    Публикаций:
    0
    Регистрация:
    18 май 2004
    Сообщения:
    3.006
    CyberManiac
    а глянуть в сгенерированный код не вариант? борладна под рукой нету, так что помочь не могу
     
  5. AsmGuru62

    AsmGuru62 Member

    Публикаций:
    0
    Регистрация:
    12 сен 2002
    Сообщения:
    689
    Адрес:
    Toronto
    bolt90
    Вызывай BreakPoint(); и далее смотри код в дизасемблере.
    Можно также _asm int3, но это иногда вызывает выключение оптимизатора.
    Остановится код в KERNEL32 - надо вернуться пару раз чтобы попасть на "свой" код.
     
  6. Malfoy

    Malfoy New Member

    Публикаций:
    0
    Регистрация:
    2 янв 2012
    Сообщения:
    698
    Так как дельтатэ вычисляется в длл, то очевидно что причина в разной скорости её работы может быть только одна - приоритет. Хотя это если вы одинаковые аргументы передаёте.
     
  7. kaspersky

    kaspersky New Member

    Публикаций:
    0
    Регистрация:
    18 май 2004
    Сообщения:
    3.006
    AsmGuru62
    > Вызывай BreakPoint(); и далее смотри код в дизасемблере.
    с каких это пор компиляторы разучились генерить асм-листинги? на худой конец можно obj дизасмить. там по крайней мере есть часть символьной информации.

    Malfoy
    > Так как дельтатэ вычисляется в длл, то очевидно что причина в разной скорости её работы может быть только одна - приоритет.
    инлайн функции f, разворот цикла, выравнивание и быстрое умножение (которое ms умеет, а борлнад -- нет) вполне объясняют разницу.

    блин, специально ради вас скачал борланд и сравнил с 2008 студией. ну небо и земля, короче:

    Код (Text):
    1. $LN3@pi:
    2.     fild    DWORD PTR _i$[esp+8]
    3.     inc eax
    4.     cmp eax, 100                ; 00000064H
    5.     fsub    ST(0), ST(5)
    6.     fmul    ST(0), ST(4)
    7.     fstp    DWORD PTR tv211[esp+8]
    8.     fld DWORD PTR tv211[esp+8]
    9.     mov DWORD PTR _i$[esp+8], eax
    10.     fmul    ST(0), ST(0)
    11.     fadd    ST(0), ST(3)
    12.     fdivr   ST(0), ST(2)
    13.     faddp   ST(1), ST(0)
    14.     jle SHORT $LN3@pi
    это код студии. код борланда смотрите сами -- он слишком монстроузный, чтобы его сюда вставлять.
     
  8. ip_man

    ip_man New Member

    Публикаций:
    0
    Регистрация:
    7 июн 2011
    Сообщения:
    43
    оп запилико мне бинарники по хардкору на сендспейс
     
  9. CyberManiac

    CyberManiac New Member

    Публикаций:
    0
    Регистрация:
    2 сен 2003
    Сообщения:
    2.473
    Адрес:
    Russia
    Да у Борланда есть такая придурь, что если программу пускать из среды и при разрешённом встроенном отладчике, некоторые вещи начинают работать сильно медленнее. Запускаем не из среды - и полетело.
     
  10. bolt90

    bolt90 New Member

    Публикаций:
    0
    Регистрация:
    21 май 2009
    Сообщения:
    18
    сейчас попробую, не из среды. нет, не помагает. приоритеты одинаковые - средний. ну допустим борланд генерирует плохой код. это все равно не обьясняет как может быть такое, что одна и таже функция работает по разному. ну вот посудите. есть библиотека на вижуале с функцией тест которая просто ганяет циклы. создаю проект вижуала кидаю код
    Код (Text):
    1. #include <windows.h>
    2. #include<stdio.h>
    3. #include<conio.h>
    4. void main() {
    5.     typedef void(fnk)();
    6.     fnk *func_addr = (fnk*)GetProcAddress(LoadLibraryA(
    7.             "C:\\Users\\Администратор\\Documents\\Visual Studio 2010\\Projects\\dll\\Release\\dll.dll"), "test");
    8.     func_addr();
    9.     getch();
    10. }
    пишет 1077мс, повторял пару раз, одно и тоже число.
    создаю консольний проект на борланде копирую тот же листинг, запускаю, пишет 1350. тоже пару раз запусал, ниже не падает.
    Ну как это понять? нету работы с памятью, просто вычисления. ну и 2 раза вызывается GetTickCount, не в цикле, так что как это может повлиять на столько.

    нашел одну интересную фичу
    Код (Text):
    1. extern "C" __declspec(dllexport) void test()
    2. {
    3.      int i;
    4.      double sum = 0;
    5.      int t=GetTickCount();
    6.             for(i = 0; i <= 1000000000; i ++)
    7.                         sum += 1/i;        
    8.      int t2=GetTickCount();
    9.      printf("%f %d",sum,t2-t);
    10. }
    Выполняется одинаково 6022
    меняем на
    Код (Text):
    1. sum += 1.0/i;
    6598 борланд против 5351 вижуал
    тоесть дробные числа процессор под вижуалом стал делить быстрее, а под борландом дольше. интересно.
    посмотрим листинги с 1
    Код (Text):
    1. _test   PROC                        ; COMDAT
    2.  
    3. ; 50   : {
    4.  
    5.   00000 55       push    ebp
    6.   00001 8b ec        mov     ebp, esp
    7.   00003 83 e4 c0     and     esp, -64       ; ffffffc0H
    8.   00006 83 ec 34     sub     esp, 52            ; 00000034H
    9.  
    10. ; 51   :     int i;
    11. ; 52   :     double sum = 0;
    12.  
    13.   00009 d9 ee        fldz
    14.   0000b 53       push    ebx
    15.   0000c 56       push    esi
    16.   0000d dd 5c 24 2c  fstp    QWORD PTR _sum$[esp+60]
    17.   00011 57       push    edi
    18.  
    19. ; 53   :     int t=GetTickCount();
    20.  
    21.   00012 8b 3d 00 00 00
    22.     00       mov     edi, DWORD PTR __imp__GetTickCount@0
    23.   00018 ff d7        call    edi
    24.   0001a dd 44 24 30  fld     QWORD PTR _sum$[esp+64]
    25.   0001e 89 44 24 3c  mov     DWORD PTR _t$[esp+64], eax
    26.   00022 b9 03 00 00 00   mov     ecx, 3
    27.   00027 be 00 e1 f5 05   mov     esi, 100000000     ; 05f5e100H
    28. $LN3@test:
    29.  
    30. ; 54   :            for(i = 1; i <= 1000000000; i ++)
    31. ; 55   :                        sum += 1/i;    
    32.  
    33.   0002c 33 d2        xor     edx, edx
    34.   0002e 8d 59 fe     lea     ebx, DWORD PTR [ecx-2]
    35.   00031 b8 01 00 00 00   mov     eax, 1
    36.   00036 f7 f3        div     ebx
    37.   00038 33 d2        xor     edx, edx
    38.   0003a 8d 59 ff     lea     ebx, DWORD PTR [ecx-1]
    39.   0003d 89 44 24 30  mov     DWORD PTR tv545[esp+64], eax
    40.   00041 b8 01 00 00 00   mov     eax, 1
    41.   00046 db 44 24 30  fild    DWORD PTR tv545[esp+64]
    42.   0004a f7 f3        div     ebx
    43.   0004c de c1        faddp   ST(1), ST(0)
    44.   0004e 33 d2        xor     edx, edx
    45.   00050 8d 59 01     lea     ebx, DWORD PTR [ecx+1]
    46.   00053 89 44 24 30  mov     DWORD PTR tv463[esp+64], eax
    47.   00057 b8 01 00 00 00   mov     eax, 1
    48.   0005c db 44 24 30  fild    DWORD PTR tv463[esp+64]
    49.   00060 f7 f1        div     ecx
    50.   00062 de c1        faddp   ST(1), ST(0)
    51.   00064 33 d2        xor     edx, edx
    52.   00066 89 44 24 30  mov     DWORD PTR tv458[esp+64], eax
    53.   0006a b8 01 00 00 00   mov     eax, 1
    54.   0006f db 44 24 30  fild    DWORD PTR tv458[esp+64]
    55.   00073 f7 f3        div     ebx
    56.   00075 de c1        faddp   ST(1), ST(0)
    57.   00077 33 d2        xor     edx, edx
    58.   00079 8d 59 02     lea     ebx, DWORD PTR [ecx+2]
    59.   0007c 89 44 24 30  mov     DWORD PTR tv453[esp+64], eax
    60.   00080 b8 01 00 00 00   mov     eax, 1
    61.   00085 db 44 24 30  fild    DWORD PTR tv453[esp+64]
    62.   00089 f7 f3        div     ebx
    63.   0008b de c1        faddp   ST(1), ST(0)
    64.   0008d 33 d2        xor     edx, edx
    65.   0008f 8d 59 03     lea     ebx, DWORD PTR [ecx+3]
    66.   00092 89 44 24 30  mov     DWORD PTR tv448[esp+64], eax
    67.   00096 b8 01 00 00 00   mov     eax, 1
    68.   0009b db 44 24 30  fild    DWORD PTR tv448[esp+64]
    69.   0009f f7 f3        div     ebx
    70.   000a1 de c1        faddp   ST(1), ST(0)
    71.   000a3 33 d2        xor     edx, edx
    72.   000a5 8d 59 04     lea     ebx, DWORD PTR [ecx+4]
    73.   000a8 89 44 24 30  mov     DWORD PTR tv443[esp+64], eax
    74.   000ac b8 01 00 00 00   mov     eax, 1
    75.   000b1 db 44 24 30  fild    DWORD PTR tv443[esp+64]
    76.   000b5 f7 f3        div     ebx
    77.   000b7 de c1        faddp   ST(1), ST(0)
    78.   000b9 33 d2        xor     edx, edx
    79.   000bb 8d 59 05     lea     ebx, DWORD PTR [ecx+5]
    80.   000be 89 44 24 30  mov     DWORD PTR tv438[esp+64], eax
    81.   000c2 b8 01 00 00 00   mov     eax, 1
    82.   000c7 db 44 24 30  fild    DWORD PTR tv438[esp+64]
    83.   000cb f7 f3        div     ebx
    84.   000cd de c1        faddp   ST(1), ST(0)
    85.   000cf 33 d2        xor     edx, edx
    86.   000d1 8d 59 06     lea     ebx, DWORD PTR [ecx+6]
    87.   000d4 89 44 24 30  mov     DWORD PTR tv433[esp+64], eax
    88.   000d8 b8 01 00 00 00   mov     eax, 1
    89.   000dd db 44 24 30  fild    DWORD PTR tv433[esp+64]
    90.   000e1 f7 f3        div     ebx
    91.   000e3 de c1        faddp   ST(1), ST(0)
    92.   000e5 8d 59 07     lea     ebx, DWORD PTR [ecx+7]
    93.   000e8 33 d2        xor     edx, edx
    94.   000ea 83 c1 0a     add     ecx, 10            ; 0000000aH
    95.   000ed 89 44 24 30  mov     DWORD PTR tv428[esp+64], eax
    96.   000f1 b8 01 00 00 00   mov     eax, 1
    97.   000f6 db 44 24 30  fild    DWORD PTR tv428[esp+64]
    98.   000fa f7 f3        div     ebx
    99.   000fc de c1        faddp   ST(1), ST(0)
    100.   000fe 4e       dec     esi
    101.   000ff 89 44 24 30  mov     DWORD PTR tv423[esp+64], eax
    102.   00103 db 44 24 30  fild    DWORD PTR tv423[esp+64]
    103.   00107 de c1        faddp   ST(1), ST(0)
    104.   00109 0f 85 1d ff ff
    105.     ff       jne     $LN3@test
    106.   0010f dd 5c 24 30  fstp    QWORD PTR _sum$[esp+64]
    107.  
    108. ; 56   :     int t2=GetTickCount();
    109.  
    110.   00113 ff d7        call    edi
    111.  
    112. ; 57   :     printf("%f %d",sum,t2-t);
    113.  
    114.   00115 2b 44 24 3c  sub     eax, DWORD PTR _t$[esp+64]
    115.   00119 dd 44 24 30  fld     QWORD PTR _sum$[esp+64]
    116.   0011d 50       push    eax
    117.   0011e 83 ec 08     sub     esp, 8
    118.   00121 dd 1c 24     fstp    QWORD PTR [esp]
    119.   00124 68 00 00 00 00   push    OFFSET ??_C@_05JAALMNKC@?$CFf?5?$CFd?$AA@
    120.   00129 ff 15 00 00 00
    121.     00       call    DWORD PTR __imp__printf
    122.   0012f 83 c4 10     add     esp, 16            ; 00000010H
    123.  
    124. ; 58   : }
    125.  
    126.   00132 5f       pop     edi
    127.   00133 5e       pop     esi
    128.   00134 5b       pop     ebx
    129.   00135 8b e5        mov     esp, ebp
    130.   00137 5d       pop     ebp
    131.   00138 c3       ret     0
    132. _test   ENDP
    а теперь с 1.0
    Код (Text):
    1. test    PROC                        ; COMDAT
    2.  
    3. ; 50   : {
    4.  
    5.   00000 55       push    ebp
    6.   00001 8b ec        mov     ebp, esp
    7.   00003 83 e4 c0     and     esp, -64       ; ffffffc0H
    8.   00006 83 ec 38     sub     esp, 56            ; 00000038H
    9.  
    10. ; 51   :     int i;
    11. ; 52   :     double sum = 0;
    12.  
    13.   00009 d9 ee        fldz
    14.   0000b 56       push    esi
    15.  
    16. ; 53   :     int t=GetTickCount();
    17.  
    18.   0000c 8b 35 00 00 00
    19.     00       mov     esi, DWORD PTR __imp__GetTickCount@0
    20.   00012 dd 5c 24 34  fstp    QWORD PTR _sum$[esp+60]
    21.   00016 57       push    edi
    22.   00017 ff d6        call    esi
    23.   00019 d9 e8        fld1
    24.   0001b dd 44 24 38  fld     QWORD PTR _sum$[esp+64]
    25.   0001f 8b f8        mov     edi, eax
    26.   00021 b8 03 00 00 00   mov     eax, 3
    27.   00026 89 44 24 34  mov     DWORD PTR tv264[esp+64], eax
    28. $LN3@test:
    29.  
    30. ; 54   :            for(i = 1; i <= 1000000000; i ++)
    31. ; 55   :                        sum += 1.0/i;      
    32.  
    33.   0002a 8d 48 fe     lea     ecx, DWORD PTR [eax-2]
    34.   0002d 89 4c 24 38  mov     DWORD PTR tv455[esp+64], ecx
    35.   00031 db 44 24 38  fild    DWORD PTR tv455[esp+64]
    36.   00035 8d 50 ff     lea     edx, DWORD PTR [eax-1]
    37.   00038 89 54 24 38  mov     DWORD PTR tv449[esp+64], edx
    38.   0003c 8d 48 01     lea     ecx, DWORD PTR [eax+1]
    39.   0003f d8 fa        fdivr   ST(0), ST(2)
    40.   00041 8d 50 02     lea     edx, DWORD PTR [eax+2]
    41.   00044 de c1        faddp   ST(1), ST(0)
    42.   00046 db 44 24 38  fild    DWORD PTR tv449[esp+64]
    43.   0004a 89 4c 24 38  mov     DWORD PTR tv439[esp+64], ecx
    44.   0004e 8d 48 03     lea     ecx, DWORD PTR [eax+3]
    45.   00051 d8 fa        fdivr   ST(0), ST(2)
    46.   00053 de c1        faddp   ST(1), ST(0)
    47.   00055 db 44 24 34  fild    DWORD PTR tv264[esp+64]
    48.   00059 d8 fa        fdivr   ST(0), ST(2)
    49.   0005b de c1        faddp   ST(1), ST(0)
    50.   0005d db 44 24 38  fild    DWORD PTR tv439[esp+64]
    51.   00061 89 54 24 38  mov     DWORD PTR tv435[esp+64], edx
    52.   00065 8d 50 04     lea     edx, DWORD PTR [eax+4]
    53.   00068 d8 fa        fdivr   ST(0), ST(2)
    54.   0006a de c1        faddp   ST(1), ST(0)
    55.   0006c db 44 24 38  fild    DWORD PTR tv435[esp+64]
    56.   00070 89 4c 24 38  mov     DWORD PTR tv432[esp+64], ecx
    57.   00074 8d 48 05     lea     ecx, DWORD PTR [eax+5]
    58.   00077 d8 fa        fdivr   ST(0), ST(2)
    59.   00079 de c1        faddp   ST(1), ST(0)
    60.   0007b db 44 24 38  fild    DWORD PTR tv432[esp+64]
    61.   0007f 89 54 24 38  mov     DWORD PTR tv429[esp+64], edx
    62.   00083 8d 50 06     lea     edx, DWORD PTR [eax+6]
    63.   00086 d8 fa        fdivr   ST(0), ST(2)
    64.   00088 de c1        faddp   ST(1), ST(0)
    65.   0008a db 44 24 38  fild    DWORD PTR tv429[esp+64]
    66.   0008e 89 4c 24 38  mov     DWORD PTR tv426[esp+64], ecx
    67.   00092 8d 48 07     lea     ecx, DWORD PTR [eax+7]
    68.   00095 83 c0 0a     add     eax, 10            ; 0000000aH
    69.   00098 d8 fa        fdivr   ST(0), ST(2)
    70.   0009a 89 44 24 34  mov     DWORD PTR tv264[esp+64], eax
    71.   0009e de c1        faddp   ST(1), ST(0)
    72.   000a0 db 44 24 38  fild    DWORD PTR tv426[esp+64]
    73.   000a4 89 54 24 38  mov     DWORD PTR tv423[esp+64], edx
    74.   000a8 8d 50 fe     lea     edx, DWORD PTR [eax-2]
    75.   000ab d8 fa        fdivr   ST(0), ST(2)
    76.   000ad de c1        faddp   ST(1), ST(0)
    77.   000af db 44 24 38  fild    DWORD PTR tv423[esp+64]
    78.   000b3 89 4c 24 38  mov     DWORD PTR tv420[esp+64], ecx
    79.   000b7 d8 fa        fdivr   ST(0), ST(2)
    80.   000b9 de c1        faddp   ST(1), ST(0)
    81.   000bb db 44 24 38  fild    DWORD PTR tv420[esp+64]
    82.   000bf d8 fa        fdivr   ST(0), ST(2)
    83.   000c1 de c1        faddp   ST(1), ST(0)
    84.   000c3 81 fa 00 ca 9a
    85.     3b       cmp     edx, 1000000000        ; 3b9aca00H
    86.   000c9 0f 8e 5b ff ff
    87.     ff       jle     $LN3@test
    88.   000cf dd d9        fstp    ST(1)
    89.   000d1 dd 5c 24 38  fstp    QWORD PTR _sum$[esp+64]
    90.  
    91. ; 56   :     int t2=GetTickCount();
    92.  
    93.   000d5 ff d6        call    esi
    94.  
    95. ; 57   :     printf("%f %d",sum,t2-t);
    96.  
    97.   000d7 dd 44 24 38  fld     QWORD PTR _sum$[esp+64]
    98.   000db 2b c7        sub     eax, edi
    99.   000dd 50       push    eax
    100.   000de 83 ec 08     sub     esp, 8
    101.   000e1 dd 1c 24     fstp    QWORD PTR [esp]
    102.   000e4 68 00 00 00 00   push    OFFSET ??_C@_05JAALMNKC@?$CFf?5?$CFd?$AA@
    103.   000e9 ff 15 00 00 00
    104.     00       call    DWORD PTR __imp__printf
    105.   000ef 83 c4 10     add     esp, 16            ; 00000010H
    106.  
    107. ; 58   : }
    108.  
    109.   000f2 5f       pop     edi
    110.   000f3 5e       pop     esi
    111.   000f4 8b e5        mov     esp, ebp
    112.   000f6 5d       pop     ebp
    113.   000f7 c3       ret     0
    114. _test   ENDP
    я вижу только разницу что теперь вычисления проводятся в fpu, допустим fdiv быстрее div но причем тут борланд, у него что особенные отношение с сопроцессором?
     
  11. Malfoy

    Malfoy New Member

    Публикаций:
    0
    Регистрация:
    2 янв 2012
    Сообщения:
    698
    kaspersky
    Я думал что тс запилил тестовый код в длл и запускал его на бинарях, собранных разными компилерами. Если тестовый код собран на разных компиляторах, то тут и вопроса нет. Я не юзаю скрипты именно потому, что я не знаю и не могу контролировать конечный код.
     
  12. leo

    leo Active Member

    Публикаций:
    0
    Регистрация:
    4 авг 2004
    Сообщения:
    2.542
    Адрес:
    Russia
    bolt90
    Не знаю у кого из них более особые, но борланд, скорее всего, по умолчанию устанавливает double-точность вычислений, а VC скорее всего single (под float). См. _controlfp\_control87 (или у борланда еще System::Set8087 или Math::SetPrecisionMode)

    kaspersky
    При наличии деления в цикле все эти фишки мало что дают
     
  13. bolt90

    bolt90 New Member

    Публикаций:
    0
    Регистрация:
    21 май 2009
    Сообщения:
    18
    спасибо огромное.
    _controlfp( PC_24, MCW_PC ); быстро посчитал но неправельно
    _controlfp( PC_53, MCW_PC ); такая же скорость что и у вижуала
    _controlfp( PC_64, MCW_PC ); тот старый тормознутый результат
    получается борланд юзает 64 по умолчанию, а вижуал 53.
    тогда у меня еще 2 вопроса
    1. результат выдал одинаково 53 и 64, когда ипользовать 64 лучше тогда?
    2. можно все таки чтото сделать с борландом (ну 20 секунд разницы это уже слишком) чтоб он по лучше код генерировал, я имею ввиду какието настройки и ключи.
     
  14. leo

    leo Active Member

    Публикаций:
    0
    Регистрация:
    4 авг 2004
    Сообщения:
    2.542
    Адрес:
    Russia
    bolt90
    Во-первых, точность вычислений сказывается только на скорости операций деления и извлечения корня, которые сами по себе являются очень тормозными и их следует всячески избегать, сокращать кол-во за счет выбора алгоритма. Например, в твоем случае можно увеличить скорость почти вдвое, если вычислять не каждый член ряда по отдельности, а сумму двух членов с приведением их к общему знаменателю с использованием одного деления вместо двух.
    Во-вторых, повышенная точность используется при громоздких промежуточных вычислениях (особенно сумм рядов и интегралов), чтобы уменьшить накопление ошибок округления. Ты же понимаешь, что если каждый член f(x) считается с точностью double, то результирующая сумма будет иметь тем худшую (предельную) точность, чем больше членов суммируется (конечно можно надеяться на компенсацию\усреднение ошибок при суммировании, но максимальное значение и дисперсия ошибки по любому увеличиваются с ростом числа слагаемых). Поэтому если тебе не нужно получать sum с макс.точностью double, то можно юзать и 53-битную точность, если же нужно, то - 64.
     
  15. cppasm

    cppasm New Member

    Публикаций:
    0
    Регистрация:
    18 июл 2006
    Сообщения:
    923
    bolt90 зачем ты кругом вычисления в double делаешь, если результат всё равно до float округляешь?
    Чтоб медленнее было?

    Код (Text):
    1. float h = 1.0 / (double) intervals
    Смысл тут double делить на double, чтоб результат во float записать?

    Код (Text):
    1. x = h * ((double)i - 0.5);
    Смысл тут из double вычитать double, расширять h до double, умножить и урезать результат до float?

    Код (Text):
    1. sum *= h;
    И тут расширять h до double для сложения.

    Ты определись с точностью, и либо везде во float считай (f к константам не забудь дописать - 1.0f), либо всё в double храни.
    Потому что из-за этих твоих double компилятор SSE использовать не может к примеру.