Здравствуйте, getch, Вы писали:

G>Ну а как без статиков тогда обойтись? Запихивать все на глобальный уровень — архитектурно-эстетически противно, да и также при каждом вызове функции надо будет их в регисры пропихивать.

Я без понятия, как обойтись без статиков в реальном коде, который я не видел.
А здесь можно выполнить ряд преобразований кода, который сведётся к тому, чтобы проинлайнить Print вручную, раз уж компилятор не захотел делать это сам.
И смысл? Ну, мы увидим, что 64-битная арифметика на 5 или 15% тормознутее 32-битной, и сделаем очевидный вывод: не использовать 64 бита без нужды.

Если нужна помощь в рефакторинге реального кода, так это... код в студию. Что-нибудь придумаем.

Здравствуйте, getch, Вы писали:

G>А замедление в два раза после добавления безобидной строчки cout перед циклом (без обращения к CalcBars) — это вообще безобразие.

Это ввод-вывод-то безобидный, да еще с endl, который сбрасывает буфферы?

Здравствуйте, Кодт, Вы писали:

К>Например, код
К>

К>bool isZero = some->var == 0;
К>

К>три инструкции (воспроизвожу по памяти)
К>

К>mov edx, dword ptr [some+var]
К>test edx, edx
К>setz cl
К>

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

ИМХО, это кэш. test тормозит, дожидаясь загрузки edx.

Здравствуйте, getch, Вы писали:

G>2. Каковы реальные причины этого?

Явно релятивистский эффект

You will always get what you always got
  If you always do  what you always did

Здравствуйте, Кодт, Вы писали:

К>Может, ему сам факт cout<< не нравится.
К>Может, критическое значение имеет размер функции main: если она меньше порога по длине, или нагрузке на стек, или нагрузке на регистры, то инлайнит содержимое, а если больше порога — то заведомо не инлайнит.
К>Попробуй засунуть этот cout<< внутрь Print и посмотреть, проинлайнится он или нет.

Если поместить cout в Print (только ни к чему), то замедления не происходит. Вообщем, данное замедление — это просто баг, оправдание которому быть не может. Надеюсь, исправят.

Короткий пример:

// Windows 7 x86, Intel i7 x86, Project Win32.

#include <iostream>
#include <windows.h>

void Print( long long Amount, unsigned long long CalcBars )
{
  static int ProcentCount = 0;
  static long long Count = 0, CountP = 0, Procent = Amount / 100;
  static unsigned long int StartTime = GetTickCount();

  CountP++;

    if (CountP > Procent)
    {
      Count += CountP;

      CountP = 0;
      ProcentCount++;
      
   unsigned long int DeltaTime = GetTickCount() - StartTime;

      if (Count != 0)
     std::cout << "Finished " << ProcentCount << "%, Time = " << DeltaTime / 1000 <<
                     " / " << (int)((double)DeltaTime * (Amount - Count) / (Count * 1000.)) << std::endl;

// Замедление в основном происходит здесь    
      if (DeltaTime != 0) 
        std::cout << "Average Velocity = " << CalcBars / DeltaTime << " thousands bars/sec." << std::endl;
    }
  
 return;
}

#define AMOUNT 100000000000LL

int main(int argc, char* argv[])
{
  unsigned long int CalcBars = 0, CurrentBar = 100;
// Замена на эту строчку замедляет выполнение программы на ~ 15%.
//  unsigned long long CalcBars = 0, CurrentBar = 100;
  
  for (long long i = 0; i < AMOUNT; i++)
  {
    Print(AMOUNT, CalcBars);

    CalcBars += CurrentBar;
  }

  return(0);
}

В программе цикл на 100 млрд, при этом 100 раз (каждый процент выполнения) через cout выводятся данные в секундах: сколько времени посчиталось и сколько осталось считать.
Если в main заменить строчку, согласно комментарию, то происходит замедление выполнения кода на 15%: вместо 189-и секунд вычисления длятся 220 секунд.

Запускаю под VS 2012 Ultimate SP1 Windows 7 x86, Intel i5, Console Project Win32 Release.

Три вопроса:
1. У кого-нибудь воспроизводится данное чудовищное замедление?

2. Каковы реальные причины этого?

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

Командная строка компилятора:

/GS /GL /analyze- /W3 /Gy /Zc:wchar_t /Zi /Gm- /O2 /Fd"Release\vc110.pdb" /fp:precise /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_UNICODE" /D "UNICODE" /errorReport:prompt /WX- /Zc:forScope /Gd /Oy- /Oi /MD /Fa"Release\" /EHsc /nologo /Fo"Release\" /Fp"Release\Test.pch"

Вроде (второй день на Visual Studio), это должно давать наибыстрейшее исполнение кода.

Данные профилировщика:


P.S. Согласен, что cout не совсем корректно использовать между вызовами GetTickCount, но в данном примере это не влияет на результат.

Здравствуйте, getch, Вы писали:

G>Короткий пример:
G>

G>int main(int argc, char* argv[])
G>{
G> . . .
G>  unsigned long int CalcBars = 0, CurrentBar = 100;
G>// Замена на эту строчку замедляет выполнение программы на ~ 15%.
G>//  unsigned long long CalcBars = 0, CurrentBar = 100;
  
G>  for (long long i = 0; i < AMOUNT; i++)
G>  {
G>    Print(AMOUNT, CalcBars);

G>    CalcBars += CurrentBar;
G>  }
G>}
G>

G>В программе цикл на 100 млрд, при этом 100 раз (каждый процент выполнения) через cout выводятся данные в секундах: сколько времени посчиталось и сколько осталось считать.
G>Если в main заменить строчку, согласно комментарию, то происходит замедление выполнения кода на 15%: вместо 189-и секунд вычисления длятся 220 секунд.

G>Запускаю под VS 2012 Ultimate SP1 Windows 7 x86, Intel i5, Console Project Win32 Release.

G>Три вопроса:
G>[b]1. . .

G>2. Каковы реальные причины этого?

G>3. . .

Ну да, на 32-битной платформе 32-битные числа работают быстрее, чем 64-битные... И что тут удивительного?

Проблема твоего теста — в нём отсутствует полезная нагрузка. Гонять холостой цикл много-много раз, конечно, интересно, но лучше сначала написать полезное тело. Преждевременная оптимизация ещё ненаписанного кода — это вообще что-то странное.



G>В программе цикл на 100 млрд, при этом 100 раз (каждый процент выполнения) через cout выводятся данные в секундах: сколько времени посчиталось и сколько осталось считать.
Ну вообще, когда нужно выполнить много мелких операций, имеет смысл объединять их в блоки, соответственно, выполняя блок целиком. Помимо уменьшения числа проверок это откроет компилятору некоторые пути оптимизации (вроде автовекторизации или автораспараллеливания) — сплошная выгода.

Здравствуйте, watchmaker, Вы писали:

W>Ну вообще, когда нужно выполнить много мелких операций, имеет смысл объединять их в блоки, соответственно, выполняя блок целиком.
это зовется SIMD, ну да

Дело в том, что я занимаюсь написанием решения довольно ресурсоемкой задачи. И сейчас нахожусь на этапе ускорения через поиски наиболее оптимальных алгоритмов. Совершенно случайно наткнулся на этот случай, т.к. скорость выполнения упала на 5% программы, которая очень много всего вычисляет. Это сильно удивило. Тогда придумал представленный выше короткий пример, чтобы разобраться.

Отлично понимаю, что операции с 64-битными числами могут выполняться медленнее на 32-битной платформе. Но тут надо внимательно посмотреть на код выше.

Если оставить long long

unsigned long long CalcBars = 0, CurrentBar = 100;

и просто закомментировать этот кусок

// Замедление в основном происходит здесь    
      if (DeltaTime != 0) 
        std::cout << "Average Velocity = " << CalcBars / DeltaTime << " thousands bars/sec." << std::endl;

, то замедления не будет. Удивляет то, что из 100 млрд различных операций, данный кусок кода выполняется всего 100 раз. При этом замедление аж на 15%.

Более того (сейчас попробовал), если этот кусок заменить вообще на абсурдный:

// Замедление в основном происходит здесь      
      if (DeltaTime < DeltaTime) 
        std::cout << "Average Velocity = " << CalcBars / DeltaTime << " thousands bars/sec." << std::endl;

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

Попробуйте у себя запустить.

А если так:

      if (DeltaTime == 0) {}
      else
        std::cout << "Average Velocity = " << CalcBars / DeltaTime << " thousands bars/sec." << std::endl;

?

M>А если так:
M>

M>      if (DeltaTime == 0) {}
M>      else
M>        std::cout << "Average Velocity = " << CalcBars / DeltaTime << " thousands bars/sec." << std::endl;
M>

M>?

Замедляет все равно. Попробуйте и у себя.

G>Замедляет все равно. Попробуйте и у себя.
это был совет не как избавиться от замедления, а как попытаться сделать быстрее оба случая.

машина х64. конфигурация х86.
компилировал так:

/GS /GL /analyze- /W3 /Gy /Zc:wchar_t /Zi /Gm- /O2 /Fd"Release\vc110.pdb" /fp:precise /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_UNICODE" /D "UNICODE" /errorReport:prompt /WX- /Zc:forScope /Gd /Oy- /Oi /MD /EHsc /nologo

с вашими опциями не скомпилилось.

	int
	Finished 1%, Time = 3 / 299 Average Velocity = 401768 thousands bars/sec. Finished 2%, Time = 6 / 296 Average Velocity = 401702 thousands bars/sec. Finished 3%, Time = 9 / 294 Average Velocity = 401017 thousands bars/sec. Finished 4%, Time = 12 / 292 Average Velocity = 46564 thousands bars/sec. Finished 5%, Time = 15 / 289 Average Velocity = 117039 thousands bars/sec. Finished 6%, Time = 18 / 286 Average Velocity = 164062 thousands bars/sec. Finished 7%, Time = 21 / 283 Average Velocity = 197669 thousands bars/sec. Finished 8%, Time = 24 / 279 Average Velocity = 46683 thousands bars/sec. Finished 9%, Time = 27 / 276 Average Velocity = 85949 thousands bars/sec. Finished 10%, Time = 30 / 273 Average Velocity = 117459 thousands bars/sec. Finished 11%, Time = 33 / 270 Average Velocity = 14621 thousands bars/sec. Finished 12%, Time = 36 / 267 Average Velocity = 46783 thousands bars/sec. Finished 13%, Time = 39 / 263 Average Velocity = 74039 thousands bars/sec. Finished 14%, Time = 42 / 260 Average Velocity = 97393 thousands bars/sec. Finished 15%, Time = 45 / 257 Average Velocity = 23223 thousands bars/sec. Finished 16%, Time = 48 / 254 Average Velocity = 46847 thousands bars/sec. Finished 17%, Time = 51 / 251 Average Velocity = 67650 thousands bars/sec. Finished 18%, Time = 54 / 248 Average Velocity = 7489 thousands bars/sec. Finished 19%, Time = 57 / 245 Average Velocity = 28196 thousands bars/sec. Finished 20%, Time = 60 / 242 Average Velocity = 46827 thousands bars/sec. Finished 21%, Time = 63 / 239 Average Velocity = 63677 thousands bars/sec. Finished 22%, Time = 66 / 236 Average Velocity = 14639 thousands bars/sec. Finished 23%, Time = 69 / 233 Average Velocity = 31427 thousands bars/sec. Finished 24%, Time = 72 / 230 Average Velocity = 46823 thousands bars/sec. Finished 25%, Time = 75 / 227 Average Velocity = 4339 thousands bars/sec. Finished 26%, Time = 78 / 224 Average Velocity = 19581 thousands bars/sec. Finished 27%, Time = 81 / 221 Average Velocity = 33699 thousands bars/sec. Finished 28%, Time = 84 / 218 Average Velocity = 46820 thousands bars/sec. Finished 29%, Time = 87 / 215 Average Velocity = 10199 thousands bars/sec. Finished 30%, Time = 91 / 212 Average Velocity = 23215 thousands bars/sec. Finished 31%, Time = 94 / 209 Average Velocity = 35402 thousands bars/sec. Finished 32%, Time = 97 / 206 Average Velocity = 2569 thousands bars/sec. Finished 33%, Time = 100 / 203 Average Velocity = 14638 thousands bars/sec. Finished 34%, Time = 103 / 200 Average Velocity = 26002 thousands bars/sec. Finished 35%, Time = 106 / 197 Average Velocity = 36716 thousands bars/sec. Finished 36%, Time = 109 / 194 Average Velocity = 7487 thousands bars/sec. Finished 37%, Time = 112 / 191 Average Velocity = 18124 thousands bars/sec. Finished 38%, Time = 115 / 187 Average Velocity = 28200 thousands bars/sec. Finished 39%, Time = 118 / 184 Average Velocity = 1435 thousands bars/sec. Finished 40%, Time = 121 / 181 Average Velocity = 11426 thousands bars/sec. Finished 41%, Time = 124 / 178 Average Velocity = 20934 thousands bars/sec. Finished 42%, Time = 127 / 175 Average Velocity = 29988 thousands bars/sec. Finished 43%, Time = 130 / 172 Average Velocity = 5661 thousands bars/sec. Finished 44%, Time = 133 / 169 Average Velocity = 14651 thousands bars/sec. Finished 45%, Time = 136 / 166 Average Velocity = 23244 thousands bars/sec. Finished 46%, Time = 139 / 163 Average Velocity = 646 thousands bars/sec. Finished 47%, Time = 142 / 160 Average Velocity = 9170 thousands bars/sec. Finished 48%, Time = 145 / 157 Average Velocity = 17342 thousands bars/sec. Finished 49%, Time = 148 / 154 Average Velocity = 25183 thousands bars/sec. Finished 50%, Time = 151 / 151 Average Velocity = 4346 thousands bars/sec. Finished 51%, Time = 154 / 148 Average Velocity = 12129 thousands bars/sec. Finished 52%, Time = 157 / 145 Average Velocity = 19614 thousands bars/sec. Finished 53%, Time = 160 / 142 Average Velocity = 64 thousands bars/sec. Finished 54%, Time = 163 / 139 Average Velocity = 7496 thousands bars/sec. Finished 55%, Time = 166 / 136 Average Velocity = 14660 thousands bars/sec. Finished 56%, Time = 169 / 133 Average Velocity = 21569 thousands bars/sec. Finished 57%, Time = 172 / 130 Average Velocity = 3349 thousands bars/sec. Finished 58%, Time = 175 / 127 Average Velocity = 10207 thousands bars/sec. Finished 59%, Time = 178 / 124 Average Velocity = 16830 thousands bars/sec. Finished 60%, Time = 181 / 121 Average Velocity = 23235 thousands bars/sec. Finished 61%, Time = 184 / 118 Average Velocity = 6200 thousands bars/sec. Finished 62%, Time = 187 / 115 Average Velocity = 12571 thousands bars/sec. Finished 63%, Time = 190 / 112 Average Velocity = 18741 thousands bars/sec. Finished 64%, Time = 193 / 109 Average Velocity = 2571 thousands bars/sec. Finished 65%, Time = 196 / 106 Average Velocity = 8703 thousands bars/sec. Finished 66%, Time = 200 / 103 Average Velocity = 14649 thousands bars/sec. Finished 67%, Time = 203 / 100 Average Velocity = 20420 thousands bars/sec. Finished 68%, Time = 206 / 96 Average Velocity = 5177 thousands bars/sec. Finished 69%, Time = 209 / 93 Average Velocity = 10917 thousands bars/sec. Finished 70%, Time = 212 / 90 Average Velocity = 16494 thousands bars/sec. Finished 71%, Time = 215 / 87 Average Velocity = 1948 thousands bars/sec. Finished 72%, Time = 218 / 84 Average Velocity = 7495 thousands bars/sec. Finished 73%, Time = 221 / 81 Average Velocity = 12889 thousands bars/sec. Finished 74%, Time = 224 / 78 Average Velocity = 18139 thousands bars/sec. Finished 75%, Time = 227 / 75 Average Velocity = 4344 thousands bars/sec. Finished 76%, Time = 230 / 72 Average Velocity = 9568 thousands bars/sec. Finished 77%, Time = 233 / 69 Average Velocity = 14657 thousands bars/sec. Finished 78%, Time = 236 / 66 Average Velocity = 1436 thousands bars/sec. Finished 79%, Time = 239 / 63 Average Velocity = 6499 thousands bars/sec. Finished 80%, Time = 242 / 60 Average Velocity = 11435 thousands bars/sec. Finished 81%, Time = 245 / 57 Average Velocity = 16249 thousands bars/sec. Finished 82%, Time = 248 / 54 Average Velocity = 3653 thousands bars/sec. Finished 83%, Time = 251 / 51 Average Velocity = 8446 thousands bars/sec. Finished 84%, Time = 254 / 48 Average Velocity = 13125 thousands bars/sec. Finished 85%, Time = 257 / 45 Average Velocity = 1009 thousands bars/sec. Finished 86%, Time = 260 / 42 Average Velocity = 5665 thousands bars/sec. Finished 87%, Time = 263 / 39 Average Velocity = 10216 thousands bars/sec. Finished 88%, Time = 266 / 36 Average Velocity = 14663 thousands bars/sec. Finished 89%, Time = 269 / 33 Average Velocity = 3071 thousands bars/sec. Finished 90%, Time = 272 / 30 Average Velocity = 7499 thousands bars/sec. Finished 91%, Time = 275 / 27 Average Velocity = 11830 thousands bars/sec. Finished 92%, Time = 278 / 24 Average Velocity = 646 thousands bars/sec. Finished 93%, Time = 281 / 21 Average Velocity = 4958 thousands bars/sec. Finished 94%, Time = 284 / 18 Average Velocity = 9178 thousands bars/sec. Finished 95%, Time = 287 / 15 Average Velocity = 13309 thousands bars/sec. Finished 96%, Time = 290 / 12 Average Velocity = 2574 thousands bars/sec. Finished 97%, Time = 293 / 9 Average Velocity = 6689 thousands bars/sec. Finished 98%, Time = 296 / 6 Average Velocity = 10720 thousands bars/sec. Finished 99%, Time = 299 / 3 Average Velocity = 335 thousands bars/sec.

	long
	Finished 1%, Time = 2 / 270 Average Velocity = 36630036 thousands bars/sec. Finished 2%, Time = 5 / 266 Average Velocity = 36737692 thousands bars/sec. Finished 3%, Time = 8 / 263 Average Velocity = 36841458 thousands bars/sec. Finished 4%, Time = 10 / 260 Average Velocity = 36788374 thousands bars/sec. Finished 5%, Time = 13 / 258 Average Velocity = 36797174 thousands bars/sec. Finished 6%, Time = 16 / 255 Average Velocity = 36769211 thousands bars/sec. Finished 7%, Time = 19 / 252 Average Velocity = 36811106 thousands bars/sec. Finished 8%, Time = 21 / 249 Average Velocity = 36840893 thousands bars/sec. Finished 9%, Time = 24 / 247 Average Velocity = 36839950 thousands bars/sec. Finished 10%, Time = 27 / 244 Average Velocity = 36818851 thousands bars/sec. Finished 11%, Time = 29 / 241 Average Velocity = 36801605 thousands bars/sec. Finished 12%, Time = 32 / 239 Average Velocity = 36770338 thousands bars/sec. Finished 13%, Time = 35 / 236 Average Velocity = 36791758 thousands bars/sec. Finished 14%, Time = 38 / 233 Average Velocity = 36810138 thousands bars/sec. Finished 15%, Time = 40 / 230 Average Velocity = 36812526 thousands bars/sec. Finished 16%, Time = 43 / 228 Average Velocity = 36840045 thousands bars/sec. Finished 17%, Time = 46 / 225 Average Velocity = 36840394 thousands bars/sec. Finished 18%, Time = 48 / 222 Average Velocity = 36864094 thousands bars/sec. Finished 19%, Time = 51 / 219 Average Velocity = 36873871 thousands bars/sec. Finished 20%, Time = 54 / 216 Average Velocity = 36882676 thousands bars/sec. Finished 21%, Time = 56 / 214 Average Velocity = 36880927 thousands bars/sec. Finished 22%, Time = 59 / 211 Average Velocity = 36888613 thousands bars/sec. Finished 23%, Time = 62 / 208 Average Velocity = 36895633 thousands bars/sec. Finished 24%, Time = 65 / 206 Average Velocity = 36884490 thousands bars/sec. Finished 25%, Time = 67 / 203 Average Velocity = 36899824 thousands bars/sec. Finished 26%, Time = 70 / 200 Average Velocity = 36897227 thousands bars/sec. Finished 27%, Time = 73 / 197 Average Velocity = 36895326 thousands bars/sec. Finished 28%, Time = 75 / 195 Average Velocity = 36900855 thousands bars/sec. Finished 29%, Time = 78 / 192 Average Velocity = 36906004 thousands bars/sec. Finished 30%, Time = 81 / 189 Average Velocity = 36911265 thousands bars/sec. Finished 31%, Time = 83 / 186 Average Velocity = 36915748 thousands bars/sec. Finished 32%, Time = 86 / 184 Average Velocity = 36919952 thousands bars/sec. Finished 33%, Time = 89 / 181 Average Velocity = 36923903 thousands bars/sec. Finished 34%, Time = 92 / 178 Average Velocity = 36927621 thousands bars/sec. Finished 35%, Time = 94 / 176 Average Velocity = 36931128 thousands bars/sec. Finished 36%, Time = 97 / 173 Average Velocity = 36922698 thousands bars/sec. Finished 37%, Time = 100 / 170 Average Velocity = 36926516 thousands bars/sec. Finished 38%, Time = 102 / 167 Average Velocity = 36929775 thousands bars/sec. Finished 39%, Time = 105 / 165 Average Velocity = 36932867 thousands bars/sec. Finished 40%, Time = 108 / 162 Average Velocity = 36935805 thousands bars/sec. Finished 41%, Time = 111 / 159 Average Velocity = 36928287 thousands bars/sec. Finished 42%, Time = 113 / 157 Average Velocity = 36936390 thousands bars/sec. Finished 43%, Time = 116 / 154 Average Velocity = 36939042 thousands bars/sec. Finished 44%, Time = 119 / 151 Average Velocity = 36941573 thousands bars/sec. Finished 45%, Time = 121 / 148 Average Velocity = 36943992 thousands bars/sec. Finished 46%, Time = 124 / 146 Average Velocity = 36946604 thousands bars/sec. Finished 47%, Time = 127 / 143 Average Velocity = 36948814 thousands bars/sec. Finished 48%, Time = 129 / 140 Average Velocity = 36955484 thousands bars/sec. Finished 49%, Time = 132 / 138 Average Velocity = 36952964 thousands bars/sec. Finished 50%, Time = 135 / 135 Average Velocity = 36959285 thousands bars/sec. Finished 51%, Time = 137 / 132 Average Velocity = 36957057 thousands bars/sec. Finished 52%, Time = 140 / 129 Average Velocity = 36958854 thousands bars/sec. Finished 53%, Time = 143 / 127 Average Velocity = 36956461 thousands bars/sec. Finished 54%, Time = 146 / 124 Average Velocity = 36958455 thousands bars/sec. Finished 55%, Time = 148 / 121 Average Velocity = 36963856 thousands bars/sec. Finished 56%, Time = 151 / 119 Average Velocity = 36965404 thousands bars/sec. Finished 57%, Time = 154 / 116 Average Velocity = 36967138 thousands bars/sec. Finished 58%, Time = 156 / 113 Average Velocity = 36961273 thousands bars/sec. Finished 59%, Time = 159 / 110 Average Velocity = 36966260 thousands bars/sec. Finished 60%, Time = 162 / 108 Average Velocity = 36971310 thousands bars/sec. Finished 61%, Time = 164 / 105 Average Velocity = 36972609 thousands bars/sec. Finished 62%, Time = 167 / 102 Average Velocity = 36970560 thousands bars/sec. Finished 63%, Time = 170 / 100 Average Velocity = 36975302 thousands bars/sec. Finished 64%, Time = 173 / 97 Average Velocity = 36976479 thousands bars/sec. Finished 65%, Time = 175 / 94 Average Velocity = 36977620 thousands bars/sec. Finished 66%, Time = 178 / 91 Average Velocity = 36982041 thousands bars/sec. Finished 67%, Time = 181 / 89 Average Velocity = 36979799 thousands bars/sec. Finished 68%, Time = 183 / 86 Average Velocity = 36971591 thousands bars/sec. Finished 69%, Time = 186 / 83 Average Velocity = 36972736 thousands bars/sec. Finished 70%, Time = 189 / 81 Average Velocity = 36967795 thousands bars/sec. Finished 71%, Time = 192 / 78 Average Velocity = 36968961 thousands bars/sec. Finished 72%, Time = 194 / 75 Average Velocity = 36970095 thousands bars/sec. Finished 73%, Time = 197 / 73 Average Velocity = 36968389 thousands bars/sec. Finished 74%, Time = 200 / 70 Average Velocity = 36963775 thousands bars/sec. Finished 75%, Time = 202 / 67 Average Velocity = 36962200 thousands bars/sec. Finished 76%, Time = 205 / 64 Average Velocity = 36960486 thousands bars/sec. Finished 77%, Time = 208 / 62 Average Velocity = 36961655 thousands bars/sec. Finished 78%, Time = 211 / 59 Average Velocity = 36960168 thousands bars/sec. Finished 79%, Time = 213 / 56 Average Velocity = 36964079 thousands bars/sec. Finished 80%, Time = 216 / 54 Average Velocity = 36965160 thousands bars/sec. Finished 81%, Time = 219 / 51 Average Velocity = 36966214 thousands bars/sec. Finished 82%, Time = 221 / 48 Average Velocity = 36967243 thousands bars/sec. Finished 83%, Time = 224 / 45 Average Velocity = 36965777 thousands bars/sec. Finished 84%, Time = 227 / 43 Average Velocity = 36966787 thousands bars/sec. Finished 85%, Time = 229 / 40 Average Velocity = 36967772 thousands bars/sec. Finished 86%, Time = 232 / 37 Average Velocity = 36963809 thousands bars/sec. Finished 87%, Time = 235 / 35 Average Velocity = 36964806 thousands bars/sec. Finished 88%, Time = 238 / 32 Average Velocity = 36965936 thousands bars/sec. Finished 89%, Time = 240 / 29 Average Velocity = 36966887 thousands bars/sec. Finished 90%, Time = 243 / 27 Average Velocity = 36963110 thousands bars/sec. Finished 91%, Time = 246 / 24 Average Velocity = 36964071 thousands bars/sec. Finished 92%, Time = 248 / 21 Average Velocity = 36965011 thousands bars/sec. Finished 93%, Time = 251 / 18 Average Velocity = 36965931 thousands bars/sec. Finished 94%, Time = 254 / 16 Average Velocity = 36964651 thousands bars/sec. Finished 95%, Time = 256 / 13 Average Velocity = 36965555 thousands bars/sec. Finished 96%, Time = 259 / 10 Average Velocity = 36966441 thousands bars/sec. Finished 97%, Time = 262 / 8 Average Velocity = 36967308 thousands bars/sec. Finished 98%, Time = 265 / 5 Average Velocity = 36968297 thousands bars/sec. Finished 99%, Time = 267 / 2 Average Velocity = 36960433 thousands bars/sec.

Аналогично, запустил на x64-машине с x86-конфигурацией.

Не понял, почему у вас не запустился мой вариант командной строки компилятора:

/GS /GL /analyze- /W3 /Gy /Zc:wchar_t /Zi /Gm- /O2 /Fd"Release\vc110.pdb" /fp:precise /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_UNICODE" /D "UNICODE" /errorReport:prompt /WX- /Zc:forScope /Gd /Oy- /Oi /MD /Fa"Release\" /EHsc /nologo /Fo"Release\" /Fp"Release\Test.pch"

подчеркнул отличие от вашей конфигурации. Не силен пока в их интерпретации. Но, вроде, ничего существенного они не дают.

Результаты работы:

	int
	Finished 1%, Time = 1 / 191 Average Velocity = 628620 thousands bars/se Finished 2%, Time = 3 / 189 Average Velocity = 628458 thousands bars/se Finished 3%, Time = 5 / 187 Average Velocity = 628512 thousands bars/se Finished 4%, Time = 7 / 185 Average Velocity = 73561 thousands bars/sec Finished 5%, Time = 9 / 183 Average Velocity = 184734 thousands bars/se Finished 6%, Time = 11 / 181 Average Velocity = 259140 thousands bars/se Finished 7%, Time = 13 / 179 Average Velocity = 312383 thousands bars/se Finished 8%, Time = 15 / 177 Average Velocity = 73637 thousands bars/sec Finished 9%, Time = 17 / 175 Average Velocity = 135209 thousands bars/se Finished 10%, Time = 19 / 173 Average Velocity = 184581 thousands bars/se Finished 11%, Time = 21 / 172 Average Velocity = 22968 thousands bars/sec Finished 12%, Time = 23 / 170 Average Velocity = 73510 thousands bars/sec Finished 13%, Time = 25 / 168 Average Velocity = 116255 thousands bars/se Finished 14%, Time = 27 / 166 Average Velocity = 152973 thousands bars/se Finished 15%, Time = 28 / 164 Average Velocity = 36485 thousands bars/sec Finished 16%, Time = 30 / 161 Average Velocity = 73635 thousands bars/sec Finished 17%, Time = 32 / 160 Average Velocity = 106416 thousands bars/se Finished 18%, Time = 34 / 158 Average Velocity = 11774 thousands bars/sec Finished 19%, Time = 36 / 156 Average Velocity = 44348 thousands bars/sec Finished 20%, Time = 38 / 154 Average Velocity = 73651 thousands bars/sec Finished 21%, Time = 40 / 152 Average Velocity = 100152 thousands bars/se Finished 22%, Time = 42 / 150 Average Velocity = 23027 thousands bars/sec Finished 23%, Time = 44 / 148 Average Velocity = 49435 thousands bars/sec Finished 24%, Time = 46 / 146 Average Velocity = 73636 thousands bars/sec Finished 25%, Time = 48 / 144 Average Velocity = 6825 thousands bars/sec. Finished 26%, Time = 50 / 142 Average Velocity = 30810 thousands bars/sec Finished 27%, Time = 52 / 140 Average Velocity = 53029 thousands bars/sec Finished 28%, Time = 53 / 138 Average Velocity = 73667 thousands bars/sec Finished 29%, Time = 55 / 136 Average Velocity = 16049 thousands bars/sec Finished 30%, Time = 57 / 134 Average Velocity = 36535 thousands bars/sec Finished 31%, Time = 59 / 132 Average Velocity = 55710 thousands bars/sec Finished 32%, Time = 61 / 131 Average Velocity = 4043 thousands bars/sec. Finished 33%, Time = 63 / 129 Average Velocity = 23047 thousands bars/sec Finished 34%, Time = 65 / 127 Average Velocity = 40936 thousands bars/sec Finished 35%, Time = 67 / 125 Average Velocity = 57806 thousands bars/sec Finished 36%, Time = 69 / 123 Average Velocity = 11790 thousands bars/sec Finished 37%, Time = 71 / 121 Average Velocity = 28537 thousands bars/sec Finished 38%, Time = 73 / 119 Average Velocity = 44405 thousands bars/sec Finished 39%, Time = 75 / 117 Average Velocity = 2260 thousands bars/sec. Finished 40%, Time = 77 / 115 Average Velocity = 17992 thousands bars/sec Finished 41%, Time = 78 / 113 Average Velocity = 32953 thousands bars/sec Finished 42%, Time = 80 / 111 Average Velocity = 47207 thousands bars/sec Finished 43%, Time = 82 / 109 Average Velocity = 8910 thousands bars/sec. Finished 44%, Time = 84 / 107 Average Velocity = 23057 thousands bars/sec Finished 45%, Time = 86 / 105 Average Velocity = 36571 thousands bars/sec Finished 46%, Time = 88 / 103 Average Velocity = 1016 thousands bars/sec. Finished 47%, Time = 90 / 102 Average Velocity = 14426 thousands bars/sec Finished 48%, Time = 92 / 100 Average Velocity = 27275 thousands bars/sec Finished 49%, Time = 94 / 98 Average Velocity = 39604 thousands bars/sec Finished 50%, Time = 96 / 96 Average Velocity = 6833 thousands bars/sec. Finished 51%, Time = 98 / 94 Average Velocity = 19075 thousands bars/sec Finished 52%, Time = 100 / 92 Average Velocity = 30839 thousands bars/sec Finished 53%, Time = 102 / 90 Average Velocity = 101 thousands bars/sec. Finished 54%, Time = 104 / 88 Average Velocity = 11783 thousands bars/sec Finished 55%, Time = 106 / 86 Average Velocity = 23035 thousands bars/sec Finished 56%, Time = 107 / 84 Average Velocity = 33886 thousands bars/sec Finished 57%, Time = 109 / 82 Average Velocity = 5265 thousands bars/sec. Finished 58%, Time = 111 / 80 Average Velocity = 16047 thousands bars/sec Finished 59%, Time = 113 / 79 Average Velocity = 26463 thousands bars/sec Finished 60%, Time = 115 / 77 Average Velocity = 36530 thousands bars/sec Finished 61%, Time = 117 / 75 Average Velocity = 9746 thousands bars/sec. Finished 62%, Time = 119 / 73 Average Velocity = 19765 thousands bars/sec Finished 63%, Time = 121 / 71 Average Velocity = 29464 thousands bars/sec Finished 64%, Time = 123 / 69 Average Velocity = 4043 thousands bars/sec. Finished 65%, Time = 125 / 67 Average Velocity = 13684 thousands bars/sec Finished 66%, Time = 127 / 65 Average Velocity = 23035 thousands bars/sec Finished 67%, Time = 129 / 63 Average Velocity = 32109 thousands bars/sec Finished 68%, Time = 131 / 61 Average Velocity = 8138 thousands bars/sec. Finished 69%, Time = 133 / 59 Average Velocity = 17159 thousands bars/sec Finished 70%, Time = 134 / 57 Average Velocity = 25921 thousands bars/sec Finished 71%, Time = 136 / 55 Average Velocity = 3060 thousands bars/sec. Finished 72%, Time = 138 / 53 Average Velocity = 11776 thousands bars/sec Finished 73%, Time = 140 / 52 Average Velocity = 20253 thousands bars/sec Finished 74%, Time = 142 / 50 Average Velocity = 28506 thousands bars/sec Finished 75%, Time = 144 / 48 Average Velocity = 6827 thousands bars/sec. Finished 76%, Time = 146 / 46 Average Velocity = 15033 thousands bars/sec Finished 77%, Time = 148 / 44 Average Velocity = 23028 thousands bars/sec Finished 78%, Time = 150 / 42 Average Velocity = 2257 thousands bars/sec. Finished 79%, Time = 152 / 40 Average Velocity = 10210 thousands bars/sec Finished 80%, Time = 154 / 38 Average Velocity = 17966 thousands bars/sec Finished 81%, Time = 156 / 36 Average Velocity = 25532 thousands bars/sec Finished 82%, Time = 158 / 34 Average Velocity = 5741 thousands bars/sec. Finished 83%, Time = 159 / 32 Average Velocity = 13271 thousands bars/sec Finished 84%, Time = 161 / 30 Average Velocity = 20619 thousands bars/sec Finished 85%, Time = 163 / 28 Average Velocity = 1585 thousands bars/sec. Finished 86%, Time = 165 / 26 Average Velocity = 8901 thousands bars/sec. Finished 87%, Time = 167 / 25 Average Velocity = 16050 thousands bars/sec Finished 88%, Time = 169 / 23 Average Velocity = 23033 thousands bars/sec Finished 89%, Time = 171 / 21 Average Velocity = 4825 thousands bars/sec. Finished 90%, Time = 173 / 19 Average Velocity = 11781 thousands bars/sec Finished 91%, Time = 175 / 17 Average Velocity = 18582 thousands bars/sec Finished 92%, Time = 177 / 15 Average Velocity = 1015 thousands bars/sec. Finished 93%, Time = 179 / 13 Average Velocity = 7787 thousands bars/sec. Finished 94%, Time = 181 / 11 Average Velocity = 14415 thousands bars/sec Finished 95%, Time = 183 / 9 Average Velocity = 20901 thousands bars/sec Finished 96%, Time = 185 / 7 Average Velocity = 4043 thousands bars/sec. Finished 97%, Time = 186 / 5 Average Velocity = 10503 thousands bars/sec Finished 98%, Time = 188 / 3 Average Velocity = 16833 thousands bars/sec Finished 99%, Time = 190 / 1 Average Velocity = 525 thousands bars/sec.

	long
	Finished 1%, Time = 2 / 220 Average Velocity = 44843049 thousands bars/sec. Finished 2%, Time = 4 / 217 Average Velocity = 44984255 thousands bars/sec. Finished 3%, Time = 6 / 215 Average Velocity = 44937088 thousands bars/sec. Finished 4%, Time = 8 / 213 Average Velocity = 44984255 thousands bars/sec. Finished 5%, Time = 11 / 211 Average Velocity = 45016656 thousands bars/sec. Finished 6%, Time = 13 / 208 Average Velocity = 45038282 thousands bars/sec. Finished 7%, Time = 15 / 206 Average Velocity = 45053742 thousands bars/sec. Finished 8%, Time = 17 / 204 Average Velocity = 45065344 thousands bars/sec. Finished 9%, Time = 19 / 201 Average Velocity = 45072115 thousands bars/sec. Finished 10%, Time = 22 / 199 Average Velocity = 45079565 thousands bars/sec. Finished 11%, Time = 24 / 197 Average Velocity = 45113398 thousands bars/sec. Finished 12%, Time = 26 / 195 Average Velocity = 45116174 thousands bars/sec. Finished 13%, Time = 28 / 192 Average Velocity = 45118522 thousands bars/sec. Finished 14%, Time = 31 / 190 Average Velocity = 45120536 thousands bars/sec. Finished 15%, Time = 33 / 188 Average Velocity = 45142650 thousands bars/sec. Finished 16%, Time = 35 / 186 Average Velocity = 45122535 thousands bars/sec. Finished 17%, Time = 37 / 183 Average Velocity = 45123958 thousands bars/sec. Finished 18%, Time = 39 / 181 Average Velocity = 45125222 thousands bars/sec. Finished 19%, Time = 42 / 179 Average Velocity = 45126353 thousands bars/sec. Finished 20%, Time = 44 / 177 Average Velocity = 45127372 thousands bars/sec. Finished 21%, Time = 46 / 175 Average Velocity = 45127323 thousands bars/sec. Finished 22%, Time = 48 / 172 Average Velocity = 45128205 thousands bars/sec. Finished 23%, Time = 50 / 170 Average Velocity = 45129010 thousands bars/sec. Finished 24%, Time = 53 / 168 Average Velocity = 45129748 thousands bars/sec. Finished 25%, Time = 55 / 166 Average Velocity = 45129612 thousands bars/sec. Finished 26%, Time = 57 / 164 Average Velocity = 45118522 thousands bars/sec. Finished 27%, Time = 59 / 161 Average Velocity = 45130879 thousands bars/sec. Finished 28%, Time = 62 / 159 Average Velocity = 45131445 thousands bars/sec. Finished 29%, Time = 64 / 157 Average Velocity = 45131972 thousands bars/sec. Finished 30%, Time = 66 / 155 Average Velocity = 45131784 thousands bars/sec. Finished 31%, Time = 68 / 152 Average Velocity = 45132266 thousands bars/sec. Finished 32%, Time = 70 / 150 Average Velocity = 45132718 thousands bars/sec. Finished 33%, Time = 73 / 148 Average Velocity = 45142403 thousands bars/sec. Finished 34%, Time = 75 / 146 Average Velocity = 45142530 thousands bars/sec. Finished 35%, Time = 77 / 144 Average Velocity = 45133336 thousands bars/sec. Finished 36%, Time = 79 / 141 Average Velocity = 45142764 thousands bars/sec. Finished 37%, Time = 81 / 139 Average Velocity = 45151134 thousands bars/sec. Finished 38%, Time = 84 / 137 Average Velocity = 45151018 thousands bars/sec. Finished 39%, Time = 86 / 135 Average Velocity = 45158750 thousands bars/sec. Finished 40%, Time = 88 / 132 Average Velocity = 45150294 thousands bars/sec. Finished 41%, Time = 90 / 130 Average Velocity = 45142750 thousands bars/sec. Finished 42%, Time = 93 / 128 Average Velocity = 45150124 thousands bars/sec. Finished 43%, Time = 95 / 126 Average Velocity = 45157157 thousands bars/sec. Finished 44%, Time = 97 / 123 Average Velocity = 45164336 thousands bars/sec. Finished 45%, Time = 99 / 121 Average Velocity = 45163945 thousands bars/sec. Finished 46%, Time = 101 / 119 Average Velocity = 45170223 thousands bars/sec. Finished 47%, Time = 104 / 117 Average Velocity = 45176235 thousands bars/sec. Finished 48%, Time = 106 / 115 Average Velocity = 45182424 thousands bars/sec. Finished 49%, Time = 108 / 112 Average Velocity = 45187945 thousands bars/sec. Finished 50%, Time = 110 / 110 Average Velocity = 45193654 thousands bars/sec. Finished 51%, Time = 112 / 108 Average Velocity = 45192333 thousands bars/sec. Finished 52%, Time = 115 / 106 Average Velocity = 45197740 thousands bars/sec. Finished 53%, Time = 117 / 103 Average Velocity = 45202558 thousands bars/sec. Finished 54%, Time = 119 / 101 Average Velocity = 45213255 thousands bars/sec. Finished 55%, Time = 121 / 99 Average Velocity = 45217620 thousands bars/sec. Finished 56%, Time = 123 / 97 Average Velocity = 45222194 thousands bars/sec. Finished 57%, Time = 126 / 95 Average Velocity = 45226250 thousands bars/sec. Finished 58%, Time = 128 / 92 Average Velocity = 45235811 thousands bars/sec. Finished 59%, Time = 130 / 90 Average Velocity = 45239847 thousands bars/sec. Finished 60%, Time = 132 / 88 Average Velocity = 45243409 thousands bars/sec. Finished 61%, Time = 134 / 86 Average Velocity = 45252225 thousands bars/sec. Finished 62%, Time = 137 / 83 Average Velocity = 45255474 thousands bars/sec. Finished 63%, Time = 139 / 81 Average Velocity = 45258945 thousands bars/sec. Finished 64%, Time = 141 / 79 Average Velocity = 45261989 thousands bars/sec. Finished 65%, Time = 143 / 77 Average Velocity = 45269983 thousands bars/sec. Finished 66%, Time = 145 / 75 Average Velocity = 45272768 thousands bars/sec. Finished 67%, Time = 147 / 72 Average Velocity = 45275776 thousands bars/sec. Finished 68%, Time = 150 / 70 Average Velocity = 45278395 thousands bars/sec. Finished 69%, Time = 152 / 68 Average Velocity = 45281235 thousands bars/sec. Finished 70%, Time = 154 / 66 Average Velocity = 45283702 thousands bars/sec. Finished 71%, Time = 156 / 64 Average Velocity = 45286099 thousands bars/sec. Finished 72%, Time = 158 / 61 Average Velocity = 45288715 thousands bars/sec. Finished 73%, Time = 161 / 59 Average Velocity = 45290979 thousands bars/sec. Finished 74%, Time = 163 / 57 Average Velocity = 45297617 thousands bars/sec. Finished 75%, Time = 165 / 55 Average Velocity = 45295599 thousands bars/sec. Finished 76%, Time = 167 / 52 Average Velocity = 45302003 thousands bars/sec. Finished 77%, Time = 169 / 50 Average Velocity = 45299980 thousands bars/sec. Finished 78%, Time = 172 / 48 Average Velocity = 45301954 thousands bars/sec. Finished 79%, Time = 174 / 46 Average Velocity = 45308037 thousands bars/sec. Finished 80%, Time = 176 / 44 Average Velocity = 45309862 thousands bars/sec. Finished 81%, Time = 178 / 41 Average Velocity = 45311896 thousands bars/sec. Finished 82%, Time = 180 / 39 Average Velocity = 45309875 thousands bars/sec. Finished 83%, Time = 183 / 37 Average Velocity = 45307655 thousands bars/sec. Finished 84%, Time = 185 / 35 Average Velocity = 45309642 thousands bars/sec. Finished 85%, Time = 187 / 33 Average Velocity = 45307719 thousands bars/sec. Finished 86%, Time = 189 / 30 Average Velocity = 45305602 thousands bars/sec. Finished 87%, Time = 192 / 28 Average Velocity = 45300231 thousands bars/sec. Finished 88%, Time = 194 / 26 Average Velocity = 45301978 thousands bars/sec. Finished 89%, Time = 196 / 24 Average Velocity = 45303687 thousands bars/sec. Finished 90%, Time = 198 / 22 Average Velocity = 45294869 thousands bars/sec. Finished 91%, Time = 200 / 19 Average Velocity = 45296618 thousands bars/sec. Finished 92%, Time = 203 / 17 Average Velocity = 45298551 thousands bars/sec. Finished 93%, Time = 205 / 15 Average Velocity = 45296914 thousands bars/sec. Finished 94%, Time = 207 / 13 Average Velocity = 45298585 thousands bars/sec. Finished 95%, Time = 209 / 11 Average Velocity = 45300221 thousands bars/sec. Finished 96%, Time = 211 / 8 Average Velocity = 45302037 thousands bars/sec. Finished 97%, Time = 214 / 6 Average Velocity = 45303604 thousands bars/sec. Finished 98%, Time = 216 / 4 Average Velocity = 45305139 thousands bars/sec. Finished 99%, Time = 218 / 2 Average Velocity = 45303533 thousands bars/sec.

Т.е. у меня замедление, а у вас наоборот — ускорение.

Но самое странное, когда (чтобы не перепутать случаи) добавил эти строчки:

int main(int argc, char* argv[])
{
//  unsigned long int CalcBars = 0, CurrentBar = 100;
// Замена на эту строчку замедляет выполнение программы на ~ 15%.
  unsigned long long CalcBars = 0, CurrentBar = 100;

  std::cout << "SizeOf(Type) = " << sizeof(unsigned long long) << " bytes." << std::endl; // добавил
  std::cout << "SizeOf(CalcBars) = " << sizeof(&CalcBars) << " bytes." << std::endl; // добавил
  
  for (long long i = 0; i < AMOUNT; i++)
  .....

Результат стал таким:

SizeOf(Type) = 8 bytes.
SizeOf(CalcBars) = 4 bytes.
Finished 1%, Time = 4 / 489
Average Velocity = 20222446 th
Finished 2%, Time = 9 / 485
Average Velocity = 20189783 th
Finished 3%, Time = 14 / 480
...

Т.е. замедлилось еще в > 2 раза. Да еще и sizeof переменной показывает 4 байта, вместо 8-ми.

Попробовал на удаленной машине запустить — аналогично.

Помогите разобраться, почему этот бред происходит?!

G>Т.е. замедлилось еще в > 2 раза. Да еще и sizeof переменной показывает 4 байта, вместо 8-ми.
Здесь я ступил, sizeof правильно отработал. Однако, объяснить такое доп. замедление не в состоянии.

Здравствуйте, getch, Вы писали:

G>Короткий пример...

При смене типа, декларацию функции Print() не поправляли?

VF>При смене типа, декларацию функции Print() не поправляли?
Пробовал с/без соответствующей поправкой — на скорости выполнения не сказывается.

Попробовал еще одну абсурдную идею. Если так написать:

  if (CalcBars < CalcBars) 
  {
    std::cout << "SizeOf(Type) = " << sizeof(unsigned long long) << " bytes." << std::endl;
    std::cout << "SizeOf(CalcBars) = " << sizeof(CalcBars) << " bytes." << std::endl;
  }

так же происходит замедление в > 2 раза.

Здравствуйте, getch, Вы писали:

G>Пробовал с/без соответствующей поправкой — на скорости выполнения не сказывается.

А если убрать опцию /fp:precise ?
Моя идея — что float инструкции смешиваются с long long арифметикой, и в 32-битной системе происходит какое-то дорогое переключение.
У меня 64-бит, Ваш результат не повторяется.

VF>А если убрать опцию /fp:precise ?
Изменил на /fp:fast. Каждый случай стал немного быстрее, но между ними все равно пропасть по производительности.

VF>У меня 64-бит, Ваш результат не повторяется.
Visual Studio Ultimate предлагает только Win32 конфигурацию. Win64 в VS отсутствует, хоть OS x64.

Как получить Win64 конфигурацию?

Здравствуйте, getch, Вы писали:

G>Как получить Win64 конфигурацию?

В окне с конфигурацией х64, кликните "Configuration manager...", потом в "Active solution platform:" — <New...>

VF>В окне с конфигурацией х64, кликните "Configuration manager...", потом в "Active solution platform:" — <New...>
Спасибо, переключился на x64-конфигурацию. Оба варианты стали выполняться с одинаковой производительностью. Но медленнее Win32-конфигурации на 40%.

При этом проблема
G>Попробовал еще одну абсурдную идею. Если так написать:

G>

G>  if (CalcBars < CalcBars) 
G>  {
G>    std::cout << "SizeOf(Type) = " << sizeof(unsigned long long) << " bytes." << std::endl;
G>    std::cout << "SizeOf(CalcBars) = " << sizeof(CalcBars) << " bytes." << std::endl;
G>  }
G>

G>так же происходит замедление в > 2 раза.

осталась актуальной.

Не хотелось бы останавливаться на медленном Win64-варианте, т.к. все таки речь не о программировании ради программирования, а о решении практической задачи — для него нужна хорошая производительность.

Могли бы вы попробовать у себя Win32-конфигурацию представленного кода?

Здравствуйте, getch, Вы писали:

G>Могли бы вы попробовать у себя Win32-конфигурацию представленного кода?

Пробую, но получается порядочный разброс: long int тест взял 616 и 674 секунды (!) на двух прогонах.
Машина слабенькая (ядер-то 12, но всего 2GH).
Попробую ещё во вторник.
А на укороченном тесте у Вас такая же разница? Может, срезать раз в 10?

VF>А на укороченном тесте у Вас такая же разница? Может, срезать раз в 10?
Срезал в 10 раз. Соответствено, длительность выполнения любого варианта стала ровно в 10 раз короче.
Относительная разница в скоростях осталась попрежнему той же (и необъяснимой).

Давай уже генери asm код и показывай что там такое!

KA>Давай уже генери asm код и показывай что там такое!
Сгенерил код для исходника в первом посте. Ассемблера не знаю, поэтому приложил варианты сразу от нескольких ключей (/FA, /FAs, /FAcs).
Отличий совсем немного:

Здравствуйте, getch, Вы писали:

<>

Подозреваю, что дело в оптимизаторе.
Если нет места, где счётчик используется, то этот счётчик можно просто выкинуть.
Если место есть (и компилятор не смог догадаться, что условие всегда ложно; либо догадался, но далеко идущих выводов не сделал), — то не выкидывает и молотит 32- или 64-битную арифметику соответственно.

К>Если нет места, где счётчик используется, то этот счётчик можно просто выкинуть.

Поясните дилетанту, что имеется в виду под счетчиком? Как помочь компилятору не тупить?

К сожалению, походу обсуждения родилась непонятная проблема, которая актуальна и для int и для long:
G>Т.е. у меня замедление, а у вас наоборот — ускорение.

G>Но самое странное, когда (чтобы не перепутать случаи) добавил эти строчки:

G>

int main(int argc, char* argv[])
G>{
G>//  unsigned long int CalcBars = 0, CurrentBar = 100;
G>// Замена на эту строчку замедляет выполнение программы на ~ 15%.
G>  unsigned long long CalcBars = 0, CurrentBar = 100;

G>  std::cout << "SizeOf(Type) = " << sizeof(unsigned long long) << " bytes." << std::endl; // добавил
G>  std::cout << "SizeOf(CalcBars) = " << sizeof(&CalcBars) << " bytes." << std::endl; // добавил
G>  
G>  for (long long i = 0; i < AMOUNT; i++)
G>  .....
G>

G>Результат стал таким:
G>

SizeOf(Type) = 8 bytes.
G>SizeOf(CalcBars) = 4 bytes.
G>Finished 1%, Time = 4 / 489
G>Average Velocity = 20222446 th
G>Finished 2%, Time = 9 / 485
G>Average Velocity = 20189783 th
G>Finished 3%, Time = 14 / 480
G>...

G>Т.е. замедлилось еще в > 2 раза.

G>Попробовал на удаленной машине запустить — аналогично.

G>Помогите разобраться, почему этот бред происходит?!

Здравствуйте, getch, Вы писали:

К>>Если нет места, где счётчик используется, то этот счётчик можно просто выкинуть.
G>Поясните дилетанту, что имеется в виду под счетчиком? Как помочь компилятору не тупить?

А, не, это не счётчик. Но всё равно.
Если CalcBars используется, то он передаётся в функцию, и это стоит определённых денег.
Если не используется, то не передаётся.


G>К сожалению, походу обсуждения родилась непонятная проблема, которая актуальна и для int и для long:
G>>Т.е. у меня замедление, а у вас наоборот — ускорение.

G>>Но самое странное, когда (чтобы не перепутать случаи) добавил эти строчки:

G>>[ccode]
G>> std::cout << "SizeOf(Type) = " << sizeof(unsigned long long) << " bytes." << std::endl; // добавил
G>> std::cout << "SizeOf(CalcBars) = " << sizeof(&CalcBars) << " bytes." << std::endl; // добавил
G>>

Ничего странного нет.
Во-первых, sizeof(указатель-на-CalcBars) = sizeof(void*) = 4 байта на x86.
Во-вторых, пока ты не брал адрес, компилятор имел право держать эту переменную "в уме", в каком-то из 64-битных регистров. А с адресом, ты приземлил переменную в локальное хранилище, на стек. Вот тебе, бабушка, и двукратные тормоза.

Здравствуйте, Кодт, Вы писали:

К>Если CalcBars используется, то он передаётся в функцию, и это стоит определённых денег.
К>Если не используется, то не передаётся.

При включённой оптимизации, разумеется.
На ассемблерном листинге видно, что функция Print была проинлайнена внутрь main.
Ну а дальше компилятор сам решает, какие локальные переменные используются, а какие можно было бы и выкинуть.

К>Во-вторых, пока ты не брал адрес, компилятор имел право держать эту переменную "в уме", в каком-то из 64-битных регистров. А с адресом, ты приземлил переменную в локальное хранилище, на стек. Вот тебе, бабушка, и двукратные тормоза.

Да даже если делаю так:

std::cout << "SizeOf(Type) = " << sizeof(unsigned long long) << " bytes." << std::endl;
// std::cout << "SizeOf(CalcBars) = " << sizeof(&CalcBars) << " bytes." << std::endl; // закомментировал обращение к переменной

Двухкратное просидание производительности никуда не девается.

Понимаю, что можно теоретизировать и высказывать различные гипотезы. Но многие из них разбиваются о реальность, если все же запустить пример у себя. Попробуйте просто.

Почему тормоза таки происходят? Если нет объяснения, то, может, есть рецепт, как избежать этих проблем?

К>На ассемблерном листинге видно, что функция Print была проинлайнена внутрь main.
К>Ну а дальше компилятор сам решает, какие локальные переменные используются, а какие можно было бы и выкинуть.

Непонятно, почему от типа переменной зависит решение компилятора, используется ли она или нет?
Тут очень многие, наверное, используют VS 2012. Как правильно делать-то, чтобы идиотские тормоза не всплывали?

Здравствуйте, getch, Вы писали:

G>Непонятно, почему от типа переменной зависит решение компилятора, используется ли она или нет?

Используется она или нет, зависит от наличия sizeof(&CalcBars) и if(does-not-matter) cout << CalcBars.

Если есть адрес — будет переменная на стеке. Это дороже всего.
Если нет адреса — будет в регистре. Это дешевле.
Если не используется — то вообще прекрасно.

Чем дороже, тем ярче разница между long long и long.

G>Тут очень многие, наверное, используют VS 2012. Как правильно делать-то, чтобы идиотские тормоза не всплывали?

Так уже сказал watchmaker — профилировать не что попало надуманное, а реальный код.
Или сломать оптимизацию. Может быть, __declspec (noinline) Print будет достаточно.

К>Так уже сказал watchmaker — профилировать не что попало надуманное, а реальный код.
К>Или сломать оптимизацию. Может быть, __declspec (noinline) Print будет достаточно.
Говорил уже, как в нагруженном коде получил тормоза. Потом методом исключения создал этот пример. Если этот пример начинаю загружать различными вычислениями, от этого разницы в тормозах никуда не уходит.
На очень сильно загруженной вычислениями задаче происходит падение на 5%. При этом замена int на long делается для переменной, которая практически ну никак не участвует в расчетах.
И прошу заметить, что средняя скорость на любом интервале падает одинаково — 5%. Т.е. эффект такой же, как будто на 5% понизил частоту процессора.

А замедление в два раза после добавления безобидной строчки cout перед циклом (без обращения к CalcBars) — это вообще безобразие.

Никого не хочу задеть, но, судя по ответам, складывается впечатление, что никого особо не заботит падение производительности своих программ. Работает — и хорошо.

Все же хотел бы разобраться, не закрывая глаза на явные странности.

В ходе обсуждения, возможно, потерялась сама суть. Поэтому повторю. Есть код:

#include <iostream>
#include <windows.h>

void Print( long long Amount, unsigned long long CalcBars )
{
  static int ProcentCount = 0;
  static long long Count = 0, CountP = 0, Procent = Amount / 100;
  static unsigned long int StartTime = GetTickCount();

  CountP++;

    if (CountP > Procent)
    {
      Count += CountP;

      CountP = 0;
      ProcentCount++;
      
   unsigned long int DeltaTime = GetTickCount() - StartTime;

      if (Count != 0)
     std::cout << "Finished " << ProcentCount << "%, Time = " << DeltaTime / 1000 <<
                     " / " << (int)((double)DeltaTime * (Amount - Count) / (Count * 1000.)) << std::endl;

// Замедление в основном происходит здесь    
      if (DeltaTime != 0) 
        std::cout << "Average Velocity = " << CalcBars / DeltaTime << " thousands bars/sec." << std::endl;
    }
  
 return;
}

#define AMOUNT 100000000000LL

int main(int argc, char* argv[])
{
  unsigned long int CalcBars = 0, CurrentBar = 100;
//  unsigned long long CalcBars = 0, CurrentBar = 100; // раскомментировав эту строчу, получите замедление на 15%.

//  std::cout << "SizeOf(Type) = " << sizeof(unsigned long long) << " bytes." << std::endl; // раскомментировав эту строчу, получите замедление в два раза.

  
  for (long long i = 0; i < AMOUNT; i++)
  {
    Print(AMOUNT, CalcBars);

    CalcBars += CurrentBar;
  }

  return(0);
}

Запускается все под Win32-конфигурацией, т.к. Win64 объективно работает по какой-то причине значительно медленней.

Здравствуйте, getch, Вы писали:

Судя по ассемблерным листингам, замедление происходит в

CalcBars += CurrentBar;

из-за дополнительного adc для unsigned long long.

Ops>Это ввод-вывод-то безобидный, да еще с endl, который сбрасывает буфферы?

Да, совершенно безобидный, т.к. вызывается всего один раз и перед циклом for:

//  std::cout << "SizeOf(Type) = " << sizeof(unsigned long long) << " bytes." << std::endl; // раскомментировав эту строчу, получите замедление в два раза.

//  std::cout << std::endl; // А ВОТ ТАК НЕ ЗАМЕДЛЯЕТ!

  
  for (long long i = 0; i < AMOUNT; i++)

Либо же я что-то глубоко не понимаю, раз считаю странным замедление скорости выполнения всей программы в два раза лишь от того, что в начале программы что-то вывели на консоль.
Чтобы мне не быть голословным, убедитесь в этом у себя, запустив.

Здравствуйте, cserg, Вы писали:
C>Судя по ассемблерным листингам, замедление происходит в
C>

CalcBars += CurrentBar;

C>из-за дополнительного adc для unsigned long long.

Проверил. Действительно, в этом месте. Спасибо! Есть ли вариант ускорения подобных выражений для long?

P.S. Осталось разобраться с замедлением в два раза...

Я скачал и запустил,
Мне кажется у тебя неправильные измерительные приборы.
Вот мой вывод, колебания просто огромны, по ним ничего нельзя замерить.

Finished 1%, Time = 2 / 296
Average Velocity = 405927 thousands bars/se
Finished 2%, Time = 5 / 292
Average Velocity = 406946 thousands bars/se
Finished 3%, Time = 8 / 290
Average Velocity = 405927 thousands bars/se
Finished 4%, Time = 11 / 287
Average Velocity = 47411 thousands bars/sec
Finished 5%, Time = 14 / 284
Average Velocity = 118983 thousands bars/se
Finished 6%, Time = 18 / 282
Average Velocity = 166622 thousands bars/se
Finished 7%, Time = 21 / 279
Average Velocity = 200604 thousands bars/se
Finished 8%, Time = 24 / 276
Average Velocity = 47289 thousands bars/sec
Finished 9%, Time = 27 / 273
Average Velocity = 86992 thousands bars/sec
Finished 10%, Time = 30 / 270
Average Velocity = 118800 thousands bars/se
Finished 11%, Time = 33 / 267
Average Velocity = 14780 thousands bars/sec
Finished 12%, Time = 36 / 264
Average Velocity = 47268 thousands bars/sec
Finished 13%, Time = 39 / 261
Average Velocity = 74809 thousands bars/sec
Finished 14%, Time = 42 / 258
Average Velocity = 98296 thousands bars/sec
Finished 15%, Time = 45 / 255
Average Velocity = 23432 thousands bars/sec
Finished 16%, Time = 48 / 252
Average Velocity = 47243 thousands bars/sec
Finished 17%, Time = 51 / 249
Average Velocity = 68248 thousands bars/sec
Finished 18%, Time = 54 / 246
Average Velocity = 7554 thousands bars/sec.
Finished 19%, Time = 57 / 243

KA>Я скачал и запустил,
KA>Мне кажется у тебя неправильные измерительные приборы.
KA>Вот мой вывод, колебания просто огромны, по ним ничего нельзя замерить.

Измерительные приборы как раз правильные — скорость исполнения на любом этапе выполнения программы одинаковая. Расчетное время окончания вычислений в самом начале выполнения программы полностью совпадает с фактическим. Колебания практически отсутствуют. Возможно, вас ввел в заблуждение сильные изменения показателя "Average Velocity" в режиме unsigned long int. Это простое переполнение типа (100 млрд не вписываются). В режиме unsigned long long переполнения нет — показатель "Average Velocity" стабильный.

В программе нет детских ошибок. Все перепроверил перед тем, как постить. Посмотирите внимательно код — он очень простой.

unsigned long int:

Finished 1%, Time = 1 / 191
Average Velocity = 628620 thousands bars/se
......
Finished 99%, Time = 190 / 1 - расчетное время (191 сек.) совпадает с фактическим.
Average Velocity = 525 thousands bars/sec. - результат переполнения unsigned long int

unsigned long long:

Finished 1%, Time = 2 / 220
Average Velocity = 44843049 thousands bars/sec.
......
[b]Finished 99%, Time = 218 / 2[b] - расчетное время (220 сек.) совпадает с фактическим.
Average Velocity = 45303533 thousands bars/sec. - показатель стабилен: нет переполнения unsigned long long

Здравствуйте, getch, Вы писали:

странно все это... вы говорите, что производительность критична, но при этом, вы реализовали задачу на уровне первого класса %)
если вы таки не лжете, и производительность таки критична, скажите, почему реализация в один поток? или, что лучше, почему не используется OMP? или, что гораздо лучше — OMP+SIMD.
или ваша задача не имеет практического применения? это просто исследовательская работа на тему "почему 64ех битные операции на 32ух битном хосте выполняются медленнее?"

Здравствуйте, getch, Вы писали:

G>На очень сильно загруженной вычислениями задаче происходит падение на 5%. При этом замена int на long делается для переменной, которая практически ну никак не участвует в расчетах.

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

G>А замедление в два раза после добавления безобидной строчки cout перед циклом (без обращения к CalcBars) — это вообще безобразие.

Вот это действительно странно.
Попробуй сравнить дизасмы программ со строчкой и без неё. Скорее всего, у оптимизатора крыша поехала.

G>Никого не хочу задеть, но, судя по ответам, складывается впечатление, что никого особо не заботит падение производительности своих программ. Работает — и хорошо.

Ешё как заботит. За один процент бьёмся.
Я вот, например, тремя профайлерами воспользовался, чтобы найти узкие места. Несколько мест изничтожил, одно само внезапно испарилось, зато пара мест не поддаётся пониманию.
Например, код

bool isZero = some->var == 0;

три инструкции (воспроизвожу по памяти)

mov edx, dword ptr [some+var]
test edx, edx
setz cl

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

X>странно все это... вы говорите, что производительность критична, но при этом, вы реализовали задачу на уровне первого класса %)
X>если вы таки не лжете, и производительность таки критична, скажите, почему реализация в один поток? или, что лучше, почему не используется OMP? или, что гораздо лучше — OMP+SIMD.
X>или ваша задача не имеет практического применения? это просто исследовательская работа на тему "почему 64ех битные операции на 32ух битном хосте выполняются медленнее?"почему 64ех битные операции на 32ух битном хосте выполняются медленнее?

Все как раз очень практично. Дело в том, что мне нужно оптимизировать именно однопоточный вариант, т.к. далее планирую ускорить расчеты в ~1000 раз через запуск в облаке (режим мат. моделирования). Там C-подобный однопоточный язык, но для облака в целях безопасности не разрешается использование DLL. Зато есть встроенная поддержка OpenCL, которую потом добавлю, когда разберусь с ней.

Поэтому такой десткий сад на первый взгляд. К тому же я дилетант в программировании.

Здравствуйте, Кодт, Вы писали:

К>Здравствуйте, getch, Вы писали:

G>>На очень сильно загруженной вычислениями задаче происходит падение на 5%. При этом замена int на long делается для переменной, которая практически ну никак не участвует в расчетах.
К>Ну как же она не используется, если в цикле делается её инкремент на каждой итерации.
К>Дальше всё упирается в оптимизирующий компилятор: сможет он её выбросить за ненадобностью, приземлить в регистр или приземлить на стек.

Да, в этом разобрались, спасибо.

G>>А замедление в два раза после добавления безобидной строчки cout перед циклом (без обращения к CalcBars) — это вообще безобразие.
К>Вот это действительно странно.
К>Попробуй сравнить дизасмы программ со строчкой и без неё. Скорее всего, у оптимизатора крыша поехала.

Приложил Asm. К сожалению, не знаю ассемблера. Странно только, что длина Asm варианта с выводом на консоль (который в 2 раза медленней) меньше, чем без вывода.

G>>Никого не хочу задеть, но, судя по ответам, складывается впечатление, что никого особо не заботит падение производительности своих программ. Работает — и хорошо.
К>Ешё как заботит. За один процент бьёмся.
К>Я вот, например, тремя профайлерами воспользовался, чтобы найти узкие места. Несколько мест изничтожил, одно само внезапно испарилось, зато пара мест не поддаётся пониманию.

По наивности своей идеализировал возможности столь популярного оптимизатора компилятора VSC++. Теперь понимаю, что оптимизатор далеко не идеал.

Здравствуйте, getch, Вы писали:

К>>Попробуй сравнить дизасмы программ со строчкой и без неё. Скорее всего, у оптимизатора крыша поехала.

G>Приложил Asm. К сожалению, не знаю ассемблера. Странно только, что длина Asm варианта с выводом на консоль (который в 2 раза медленней) меньше, чем без вывода.

Ха, так очевидно же.
Если в main есть вывод, то он не стал инлайнить Print.
Вместо этого он
— вынужден честно вычислять CalcBars
— делает вызов
— не может выполнить оптимизации, связанные с выполнением тела Print в цикле

G>По наивности своей идеализировал возможности столь популярного оптимизатора компилятора VSC++. Теперь понимаю, что оптимизатор далеко не идеал.

А вот незачем /Oy делать. Это довольно глючный режим, а в старых версиях там вообще баги встречались.
Попробуй /Ox.

Попробовал с long long. В упор не вижу проблемы.

Вот 64 бита,

U:\Users\user\Documents\Visual Studio 2008\Projects\testrsdn\x64\Release>testrsdn.exe

SizeOf(Type) = 8 bytes.
Finished 1%, Time = 2 / 200
Average Velocity = 49309664 thousands bars/sec.
Finished 2%, Time = 4 / 199
Average Velocity = 49115913 thousands bars/sec.
Finished 3%, Time = 6 / 198
Average Velocity = 48804294 thousands bars/sec.
Finished 4%, Time = 8 / 196

Вот 32 бита.

U:\Users\user\Documents\Visual Studio 2008\Projects\testrsdn\Release>testrsdn.exe

SizeOf(Type) = 8 bytes.
Finished 1%, Time = 3 / 302
Average Velocity = 32701111 thousands bars/sec.
Finished 2%, Time = 6 / 299
Average Velocity = 32701111 thousands bars/sec.
Finished 3%, Time = 9 / 297
Average Velocity = 32647731 thousands bars/sec.
Finished 4%, Time = 12 / 293
Average Velocity = 32703785 thousands bars/sec.

Здравствуйте, Кодт, Вы писали:
К>Ха, так очевидно же.
К>Если в main есть вывод, то он не стал инлайнить Print.
К>Вместо этого он
К>- вынужден честно вычислять CalcBars
К>- делает вызов
К>- не может выполнить оптимизации, связанные с выполнением тела Print в цикле

Если закомментировать строчку:

CalcBars += CurrentBar;

Двухкратное замедление остается. Непонятно, что мешает компилятору заинлайнить Print в цикле. Все смахивает больше просто на баг компилятора.

К>А вот незачем /Oy делать. Это довольно глючный режим, а в старых версиях там вообще баги встречались.
К>Попробуй /Ox.

Манипуляции с /Oy (опустить указатели на фреймы) не помогают убрать двухкратное замедление, при этом /Ox прописан. Однако, на моих задачах включение этой (/Oy) опции дает +5% к скорости.

Здравствуйте, Kubyshev Andrey, Вы писали:

KA>Попробовал с long long. В упор не вижу проблемы.

KA>Вот 64 бита,

KA>U:\Users\user\Documents\Visual Studio 2008\Projects\testrsdn\x64\Release>testrsdn.exe

KA>SizeOf(Type) = 8 bytes.
KA>Finished 1%, Time = 2 / 200
KA>Average Velocity = 49309664 thousands bars/sec.
KA>Finished 2%, Time = 4 / 199
KA>Average Velocity = 49115913 thousands bars/sec.
KA>Finished 3%, Time = 6 / 198
KA>Average Velocity = 48804294 thousands bars/sec.
KA>Finished 4%, Time = 8 / 196

KA>Вот 32 бита.

KA>U:\Users\user\Documents\Visual Studio 2008\Projects\testrsdn\Release>testrsdn.exe

KA>SizeOf(Type) = 8 bytes.
KA>Finished 1%, Time = 3 / 302
KA>Average Velocity = 32701111 thousands bars/sec.
KA>Finished 2%, Time = 6 / 299
KA>Average Velocity = 32701111 thousands bars/sec.
KA>Finished 3%, Time = 9 / 297
KA>Average Velocity = 32647731 thousands bars/sec.
KA>Finished 4%, Time = 12 / 293
KA>Average Velocity = 32703785 thousands bars/sec.

Какие ключи у вас стоят?

У меня для long long на x64 раскомментирование строчки:

std::cout << "SizeOf(CalcBars) = " << std::endl;

дает замедление на 60%. На Win32 — в два раза.

Результаты long long без этой строчки такие:
x64:

D:\Ivan\Documents\Projects\Test\x64\Release\Test.exe

Finished 1%, Time = 2 / 205
Average Velocity = 48216007 thousands bars/sec.

win32:

D:\Ivan\Documents\Projects\Test\Release\Test.exe

Finished 1%, Time = 2 / 216
Average Velocity = 45787545 thousands bars/sec.

Соответственно, для long int:
x64:

D:\Ivan\Documents\Projects\Test\x64\Release\Test.exe

Finished 1%, Time = 2 / 208
Average Velocity = 577280 thousands bars/sec.

win32:

D:\Ivan\Documents\Projects\Test\Release\Test.exe

Finished 1%, Time = 2 / 233
Average Velocity = 516242 thousands bars/sec.

Как уже выше показали после анализа asm, работа с long long дороже. Разовое замедление, к сожалению, на баг компилятора похоже.

G>Все как раз очень практично. Дело в том, что мне нужно оптимизировать именно однопоточный вариант, т.к. далее планирую ускорить расчеты в ~1000 раз через запуск в облаке (режим мат. моделирования). Там C-подобный однопоточный язык, но для облака в целях безопасности не разрешается использование DLL. Зато есть встроенная поддержка OpenCL, которую потом добавлю, когда разберусь с ней.

Может, кто посоветует другое облачное решение, где все также автоматизировано (ничего придумывать для распараллеливания почти не нужно), но есть возможность запускать компилируемый код от стандартных языков программирования?

Здравствуйте, getch, Вы писали:

G>Если закомментировать строчку:
G>

CalcBars += CurrentBar;

G>Двухкратное замедление остается.

Потому что не эта строчка влияет на встраивание, а та, где cout.

G> Непонятно, что мешает компилятору заинлайнить Print в цикле. Все смахивает больше просто на баг компилятора.

Где здесь баг? Оптимизатор имеет право поступать на своё усмотрение, сохраняя логику работы программы. К логике претензии есть?
Если хочешь, попробуй объявить __forceinline Print, может быть, это поможет.

К>>А вот незачем /Oy делать. Это довольно глючный режим, а в старых версиях там вообще баги встречались.
К>>Попробуй /Ox.
G>Манипуляции с /Oy (опустить указатели на фреймы) не помогают убрать двухкратное замедление, при этом /Ox прописан. Однако, на моих задачах включение этой (/Oy) опции дает +5% к скорости.

/Ox и /Oy, по-моему, взаимоисключающие опции. Компилятор должен сделать выбор между "быстрее" и "короче", и что он выберет —

Но вопрос сейчас не об этом. А о том, как писать код, дружественный к оптимизатору.
Я вот не думаю, что интенсивная работа со статическими переменными — это дружественный код.
Если бы я был компилятором, то встретив в теле Print любую внешнюю функцию — будь то подгружаемая из внешней dll GetTickCount или сводящаяся к ряду косвенностей и виртуальных вызовов cout<<anything, — должен был бы записать текущие значения статиков из регистров в память, а по возвращении из внешней функции — всосать их в регистры обратно. Потому что, а вдруг там рекурсия?

Здравствуйте, Кодт, Вы писали:

К>Но вопрос сейчас не об этом. А о том, как писать код, дружественный к оптимизатору.
К>Я вот не думаю, что интенсивная работа со статическими переменными — это дружественный код.
К>Если бы я был компилятором, то встретив в теле Print любую внешнюю функцию — будь то подгружаемая из внешней dll GetTickCount или сводящаяся к ряду косвенностей и виртуальных вызовов cout<<anything, — должен был бы записать текущие значения статиков из регистров в память, а по возвращении из внешней функции — всосать их в регистры обратно. Потому что, а вдруг там рекурсия?

Ну а как без статиков тогда обойтись? Запихивать все на глобальный уровень — архитектурно-эстетически противно, да и также при каждом вызове функции надо будет их в регисры пропихивать.

G>Какие ключи у вас стоят?

G>У меня для long long на x64 раскомментирование строчки:
G>

std::cout << "SizeOf(CalcBars) = " << std::endl;

G>дает замедление на 60%. На Win32 — в два раза.

Никакого замедления нет, ключи самые обычные, я ничего не менял.
/O2 /Oi /GL /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_UNICODE" /D "UNICODE" /FD /EHsc /MD /Gy /Yu"stdafx.h" /Fp"Release\testrsdn.pch" /Fo"Release\\" /Fd"Release\vc90.pdb" /W3 /nologo /c /Zi /TP /errorReport:prompt

Пацаны, хорошь гадать на пустом месте, ниче не замедляется.

Здравствуйте, Kubyshev Andrey, Вы писали:

KA>Никакого замедления нет, ключи самые обычные, я ничего не менял.
KA>/O2 /Oi /GL /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_UNICODE" /D "UNICODE" /FD /EHsc /MD /Gy /Yu"stdafx.h" /Fp"Release\testrsdn.pch" /Fo"Release\\" /Fd"Release\vc90.pdb" /W3 /nologo /c /Zi /TP /errorReport:prompt

KA>Пацаны, хорошь гадать на пустом месте, ниче не замедляется.

Т.е. скорость выполнения кода c/без обозначенной выше строчки не меняется? Только что запустил с вашими ключами, разница в два раза. У меня на разных машинах ситуация повторяется.

Здравствуйте, getch, Вы писали:

Все у вас работает так как и должно. Магии здесь никакой нет. Замедление на 15% происходит, когда складываются 64 битные значения вместо 32 битных в цикле. Замедление в 2 раза происходит, когда inlining для Print отрубается после добавления cout перед циклом. В этом случае добавляется инструкция call в тело цикла. Проблема у вас в том, что цикл повторяется огромное число раз. Небольшое изменение в теле цикла сильно влияет на результат. Интересно, что это за задача такая в которой 100 млрд. итераций?

Здравствуйте, cserg, Вы писали:

C>Все у вас работает так как и должно. Магии здесь никакой нет. Замедление на 15% происходит, когда складываются 64 битные значения вместо 32 битных в цикле. Замедление в 2 раза происходит, когда inlining для Print отрубается после добавления cout перед циклом. В этом случае добавляется инструкция call в тело цикла. Проблема у вас в том, что цикл повторяется огромное число раз. Небольшое изменение в теле цикла сильно влияет на результат. Интересно, что это за задача такая в которой 100 млрд. итераций?

Странно просто, что компилятор делает call в цикле за вместо inlining Print. Как на это решение влияет cout перед циклом — не ясно. Но факт — влияет все же. Хотя ничто ему не мешает сделать все правильно.

100 млрд — это с потолка взятое число для примера. Но вообще подобное количество вычислений — далеко не редкость. Занимаюсь просто исследованием временных рядов. А там без огромных вычислений довольно туго, поэтому и облако и GPU в планах подключить. Многосуточные расчеты — обычное дело. Ну как и при мат. моделировании и расчетах физических свойств огромных по размерам сеток. Вообщем, задач загрузить под завязку даже суперкомрьютеры полно. Лишь бы не в лоб и со знанием дела.

Здравствуйте, Кодт, Вы писали:

К>Если нужна помощь в рефакторинге реального кода, так это... код в студию. Что-нибудь придумаем.

Спасибо за желание помочь. Достигну значимых результатов в своей области — не постесняюь, воспользуюсь вашим предложением.
Не все сразу.

Здравствуйте, getch, Вы писали:

G>Странно просто, что компилятор делает call в цикле за вместо inlining Print. Как на это решение влияет cout перед циклом — не ясно. Но факт — влияет все же. Хотя ничто ему не мешает сделать все правильно.

Может, ему сам факт cout<< не нравится.
Может, критическое значение имеет размер функции main: если она меньше порога по длине, или нагрузке на стек, или нагрузке на регистры, то инлайнит содержимое, а если больше порога — то заведомо не инлайнит.
Попробуй засунуть этот cout<< внутрь Print и посмотреть, проинлайнится он или нет.

Здравствуйте, getch, Вы писали:

G>Если поместить cout в Print (только ни к чему), то замедления не происходит. Вообщем, данное замедление — это просто баг, оправдание которому быть не может. Надеюсь, исправят.

Это не баг, а "хочу фичу! хочухочухочу!"
Никто не обещает инлайнить функцию во что бы то ни стало. Даже __forceinline не даёт 100% гарантии.
Чёрт знает, по какой эвристике компилятор решил, что без cout инлайн возможен, а с ним — нет.

Кстати!!!! Баг у тебя, а не у компилятора.
Ты почему не написал inline void Print ??
Всё, тема закрыта.

Здравствуйте, Кодт, Вы писали:

К>Кстати!!!! Баг у тебя, а не у компилятора.
К>Ты почему не написал inline void Print ??
Потому что компилятор настроен так, чтобы инлайнить все, что только может. Дописал все же inline — замедление никуда не делось.

К>Всё, тема закрыта.
Согласен. Пусть тема остается, как простой пример явного бага оптимизатора компилятора.

Здравствуйте, getch, Вы писали:

G>Согласен. Пусть тема остается, как простой пример явного бага оптимизатора компилятора.

ага. ошибка в модуле чтения мыслей

G>3. Как правильно писать код, чтобы ради ускорения думать только об алгоритмической оптимизации, а не о таких далеко не очевидных технических нюансах?[/b]

1. Никак
2. Читать интеловскую документацию по написанию кода

G> 2. Каковы реальные причины этого?

3. у меня было такое. Скорее всего, где-то, в какой-то оптимизации вижуал не доказал, что один тип приводится к другому, и потратил время на сложный каст к беззнаковому/из беззнакового. Вижуал ведь здесь ещё может цикл попробовать соптимиздить, а не только то, что внутри, есть пара способов для этого. К тому же, скорее всего у тебя генерится 32 разрядный код, а работаешь ты с 64битными числами, что может порождать довольно сложный код. Попробуй в варианте с беззнаковым все типы заменить на unsigned long long int, например, и скажи нам, что выйдет. плохо мешать разные типы в одном коде, даже если речь идёт о типе счётчика.

4. В вижуале есть возможность вывести асм-код при отладке, сделай это, и приведи его, тогда можно будет точно сказать, в чём проблема

извиняюсь, невнимательно прочитал вопрос