почему обработка отсортированного массива быстрее, чем обработка несортированного массива?

<p>вот фрагмент кода c++, который демонстрирует очень своеобразное поведение. по какой-то странной причине сортировка данных чудесным образом делает код почти в шесть раз быстрее:</p><pre class="lang-cpp prettyprint-override"><code>#include <algorithm> #include <ctime> #include <iostream> int main() { // generate data const unsigned arraysize = 32768; int data[arraysize]; for (unsigned c = 0; c < arraysize; ++c) data[c] = std::rand() % 256; // !!! with this, the next loop runs faster. std::sort(data, data + arraysize); // test clock\_t start = clock(); long long sum = 0; for (unsigned i = 0; i < 100000; ++i) { // primary loop for (unsigned c = 0; c < arraysize; ++c) { if (data[c] >= 128) sum += data[c]; } } double elapsedtime = static\_cast<double>(clock() - start) / clocks\_per\_sec; std::cout << elapsedtime << std::endl; std::cout << "sum = " << sum << std::endl; } </code></pre><ul> <li>без <code>std::sort(data, data + arraysize);</code> код выполняется за 11,54 секунды.</li> <li>с отсортированными данными код запускается за 1,93 секунды.</li> </ul><hr><p>первоначально я думал, что это может быть просто аномалия языка или компилятора, поэтому я попробовал java:</p><pre class="lang-java prettyprint-override"><code>import java.util.arrays; import java.util.random; public class main { public static void main(string[] args) { // generate data int arraysize = 32768; int data[] = new int[arraysize]; random rnd = new random(0); for (int c = 0; c < arraysize; ++c) data[c] = rnd.nextint() % 256; // !!! with this, the next loop runs faster arrays.sort(data); // test long start = system.nanotime(); long sum = 0; for (int i = 0; i < 100000; ++i) { // primary loop for (int c = 0; c < arraysize; ++c) { if (data[c] >= 128) sum += data[c]; } } system.out.println((system.nanotime() - start) / 1000000000.0); system.out.println("sum = " + sum); } } </code></pre><p>с похожим, но менее экстремальным результатом.</p><hr><p>моей первой мыслью было, что сортировка переносит данные в кеш, но потом я подумал, насколько это глупо, потому что массив только что сгенерирован.</p><ul> <li>что здесь происходит?</li> <li>почему обработка отсортированного массива быстрее, чем обработка несортированного массива? код суммирует некоторые независимые термины, поэтому порядок не должен иметь значения.</li> </ul>

<p><strong> вы стали жертвой <a href="//en.wikipedia.org/wiki/branch\_predictor">предсказание ветвления</a> не удалось. </strong></p><hr><h2>что такое предсказание отрасли?</h2><p>рассмотрим железнодорожный узел:</p><p> <a href="//commons.wikimedia.org/wiki/file:entroncamento\_do\_transpraia.jpg"><img src="https://i.stack.imgur.com/muxnt.jpg" alt="image showing a railroad junction"></a> <sub> <a href="//commons.wikimedia.org/wiki/file:entroncamento\_do\_transpraia.jpg">изображение</a> от mecanismo, через wikimedia commons. используется по лицензии <a href="//creativecommons.org/licenses/by-sa/3.0/deed.en">cc-by-sa 3.</a> .</sub></p><p>теперь, ради аргумента, предположим, что это еще в 1800-х годах - до дальней связи или радиосвязи.</p><p>вы оператор развязки и слышите прибывающий поезд. вы понятия не имеете, в каком направлении это должно идти. вы останавливаете поезд, чтобы спросить водителя, в каком направлении они хотят. и тогда вы установите переключатель соответствующим образом.</p><p><em> поезда тяжелые и имеют большую инерцию. таким образом, им требуется вечность, чтобы начать и замедлить. </em></p><p>есть ли способ лучше? вы угадываете, в каком направлении будет идти поезд!</p><ul> <li>если вы угадали, это продолжается.</li> <li>если вы догадались, капитан остановится, отступит и закричит на вас, чтобы щелкнуть выключателем. затем он может перезапустить другой путь.</li> </ul><p><strong> если вы каждый раз угадаете правильно </strong>, поезду никогда не придется останавливаться.<br> <strong> если вы слишком часто догадываетесь </strong>, поезд будет тратить много времени на остановку, резервное копирование и перезапуск.</p><hr><p><strong> рассмотрим оператор if: </strong> на уровне процессора это инструкция перехода:</p><p><img src="https://i.stack.imgur.com/pyfwc.png" alt="screenshot of compiled code containing an if statement"></p><p>вы процессор, и вы видите ветку. вы понятия не имеете, по какому пути это пойдет. чем ты занимаешься? вы останавливаете выполнение и ждете, пока предыдущие инструкции не будут выполнены. затем вы продолжаете идти по правильному пути.</p><p><em> современные процессоры сложны и имеют длинные конвейеры. таким образом, им нужно вечно "разогреваться" и "замедляться". </em></p><p>есть ли способ лучше? вы угадываете, в каком направлении пойдет филиал!</p><ul> <li>если вы угадали, вы продолжаете выполнять.</li> <li>если вы угадали, вам нужно промыть конвейер и откатиться до ответвления. затем вы можете перезапустить другой путь.</li> </ul><p><strong> если каждый раз угадывать правильно </strong>, выполнение никогда не остановится.<br> <strong> если вы слишком часто догадываетесь </strong>, вы тратите много времени на остановку, откат и перезапуск.</p><hr><p>это прогноз отрасли. я признаю, что это не лучшая аналогия, так как поезд мог просто сигнализировать направление с флагом. но в компьютерах процессор не знает, в каком направлении пойдет ветка, до последнего момента.</p><p>итак, как вы могли бы стратегически угадать, сколько раз поезд должен вернуться и пойти по другому пути? вы смотрите на прошлую историю! если поезд уходит в 99% времени, значит, вы уехали. если это чередуется, то вы чередуете свои догадки. если это происходит в одну сторону каждые три раза, вы догадаетесь, то же самое ...</p><p><strong> <em> другими словами, вы пытаетесь определить шаблон и следовать ему. </em> </strong> это более или менее как предсказатели веток работают.</p><p>большинство приложений имеют хорошо управляемые ветви. таким образом, современные отраслевые предикторы обычно достигают> 90% показателей успешности но когда они сталкиваются с непредсказуемыми ветвями без распознаваемых шаблонов, предикторы ветвей практически бесполезны.</p><p>дальнейшее чтение: <a href="//en.wikipedia.org/wiki/branch\_predictor">статья "ветка предиктора" в википедии</a> .</p><hr><h2>как указывалось выше, виновником является следующее if-утверждение:</h2><pre><code>if (data[c] >= 128) sum += data[c]; </code></pre><p>обратите внимание, что данные равномерно распределены между 0 и 255. когда данные отсортированы, примерно первая половина итераций не войдет в оператор if. после этого все они введут оператор if.</p><p>это очень удобно для предиктора ветвления, поскольку ветвь последовательно идет в одном и том же направлении много раз. даже простой насыщающий счетчик будет правильно предсказывать ветвь, за исключением нескольких итераций после переключения направления.</p><p><strong> быстрая визуализация: </strong></p><pre><code>t = branch taken n = branch not taken data[] = 0, 1, 2, 3, 4, ... 126, 127, 128, 129, 130, ... 250, 251, 252, ... branch = n n n n n ... n n t t t ... t t t ... = nnnnnnnnnnnn ... nnnnnnnttttttttt ... tttttttttt (easy to predict) </code></pre><p>однако, когда данные полностью случайны, предиктор ветвления становится бесполезным, потому что он не может предсказать случайные данные. таким образом, вероятно, будет около 50% неправильного прогноза (не лучше, чем случайное угадывание).</p><pre><code>data[] = 226, 185, 125, 158, 198, 144, 217, 79, 202, 118, 14, 150, 177, 182, 133, ... branch = t, t, n, t, t, t, t, n, t, n, n, t, t, t, n ... = ttnttttntnntttn ... (completely random - hard to predict) </code></pre><hr><p><strong> так что же можно сделать? </strong></p><p>если компилятор не может оптимизировать переход в условный ход, вы можете попробовать некоторые методы, если вы готовы пожертвовать удобочитаемостью для производительности.</p><p>заменить:</p><pre><code>if (data[c] >= 128) sum += data[c]; </code></pre><p>с:</p><pre><code>int t = (data[c] - 128) >> 31; sum += ~t & data[c]; </code></pre><p>это исключает ветвление и заменяет его на некоторые побитовые операции.</p><p><sub>(обратите внимание, что этот хак не является строго эквивалентным исходному оператору if. но в этом случае он действителен для всех входных значений <code>data[]</code>.)</sub></p><p><strong> тесты: core i7 920 @ 3,5 ггц </strong></p><p>c++ - visual studio 2010 - выпуск x64</p><pre><code>// branch - random seconds = 11.777 // branch - sorted seconds = 2.352 // branchless - random seconds = 2.564 // branchless - sorted seconds = 2.587 </code></pre><p>java - netbeans 7.1.1 jdk 7 - x64</p><pre><code>// branch - random seconds = 10.93293813 // branch - sorted seconds = 5.643797077 // branchless - random seconds = 3.113581453 // branchless - sorted seconds = 3.186068823 </code></pre><p>замечания:</p><ul> <li><strong> с ветвью: </strong> существует огромная разница между отсортированными и несортированными данными.</li> <li><strong> с помощью hack: </strong> нет разницы между отсортированными и несортированными данными.</li> <li>в случае c++ хак на самом деле медленнее, чем с веткой, когда данные сортируются.</li> </ul><p>общее правило - избегать зависимого от данных ветвления в критических циклах (например, в этом примере).</p><hr><p><strong> update: </strong></p><ul> <li> <p>gcc 4.6.1 с <code>-o3</code> или <code>-ftree-vectorize</code> на x64 может генерировать условное перемещение. таким образом, нет никакой разницы между отсортированными и несортированными данными - оба быстры.</p> </li> <li> <p>vc++ 2010 не может сгенерировать условные перемещения для этой ветви даже под <code>/ox</code>.</p> </li> <li> <p> <a href="https://en.wikipedia.org/wiki/intel\_c%2b%2b\_compiler">intel c++ compiler</a> (icc) 11 делает что-то чудесное. он <a href="https://en.wikipedia.org/wiki/loop\_interchange">чередует два цикла</a> , тем самым поднимая непредсказуемую ветвь во внешний цикл. таким образом, он не только защищает от неправильных прогнозов, но и вдвое быстрее, чем может генерировать vc++ и gcc! другими словами, icc воспользовался тестовым циклом, чтобы победить тест ...</p> </li> <li> <p>если вы дадите компилятору intel код без ответвлений, он просто сразу его векторизует ... и так же быстро, как и с ветвью (с циклическим обменом).</p> </li> </ul><p>это говорит о том, что даже зрелые современные компиляторы могут сильно различаться по своей способности оптимизировать код ...</p>

<p><strong>прогноз отрасли.</strong></p><p>в отсортированном массиве условие <code>data[c] >= 128</code> сначала <code>false</code> для серии значений, а затем <code>true</code> для всех последующих значений. это легко предсказать. с несортированным массивом вы платите за стоимость ветвления.</p>

<p>причина, по которой производительность резко улучшается при сортировке данных, заключается в том, что штраф за предсказание ветвлений удален, как прекрасно объяснено в <a href="https://stackoverflow.com/questions/11227809/why-is-it-faster-to-process-a-sorted-array-than-an-unsorted-array/11227902#11227902">ответ mysticial</a> .</p><p>теперь, если мы посмотрим на код</p><pre><code>if (data[c] >= 128) sum += data[c]; </code></pre><p>мы можем обнаружить, что смысл этой конкретной ветви <code>if... else...</code> состоит в том, чтобы добавить что-то, когда условие выполнено. этот тип ветви может быть легко преобразован в <strong> оператор условного перемещения </strong>, который будет скомпилирован в инструкцию условного перемещения: <code>cmovl</code>, в системе <code>x86</code>. ветвление и, следовательно, потенциальное наказание за предсказание ветвления удаляются.</p><p>в <code>c</code>, то есть <code>c++</code>, оператор, который будет напрямую (без какой-либо оптимизации) компилироваться в инструкцию условного перемещения в <code>x86</code>, является троичным оператором <code>... ? ... : ...</code>. поэтому мы переписываем приведенное выше утверждение в эквивалентное:</p><pre><code>sum += data[c] >=128 ? data[c] : 0; </code></pre><p>поддерживая читабельность, мы можем проверить коэффициент ускорения.</p><p>для intel <a href="http://en.wikipedia.org/wiki/intel\_core#core\_i7">core i7</a> - 2600k @ 3,4 ггц и visual studio 2010 release mode эталоном является (формат, скопированный из mysticial):</p><p><strong> x86 </strong></p><pre><code>// branch - random seconds = 8.885 // branch - sorted seconds = 1.528 // branchless - random seconds = 3.716 // branchless - sorted seconds = 3.71 </code></pre><p><strong> x64 </strong></p><pre><code>// branch - random seconds = 11.302 // branch - sorted seconds = 1.830 // branchless - random seconds = 2.736 // branchless - sorted seconds = 2.737 </code></pre><p>результат надежен в нескольких тестах. мы получаем значительное ускорение, когда результат ветвления непредсказуем, но мы немного страдаем, когда он предсказуем. фактически, при использовании условного перемещения производительность остается одинаковой независимо от шаблона данных.</p><p>теперь давайте посмотрим более внимательно, исследуя сборку <code>x86</code>, которую они генерируют. для простоты мы используем две функции <code>max1</code> и <code>max2</code>.</p><p><code>max1</code> использует условную ветвь <code>if... else ...</code>:</p><pre><code>int max1(int a, int b) { if (a > b) return a; else return b; } </code></pre><p><code>max2</code> использует троичный оператор <code>... ? ... : ...</code>:</p><pre><code>int max2(int a, int b) { return a > b ? a : b; } </code></pre><p>на компьютере с архитектурой x86-64 <code>gcc -s</code> создает сборку ниже.</p><pre><code>:max1 movl %edi, -4(%rbp) movl %esi, -8(%rbp) movl -4(%rbp), %eax cmpl -8(%rbp), %eax jle .l2 movl -4(%rbp), %eax movl %eax, -12(%rbp) jmp .l4 .l2: movl -8(%rbp), %eax movl %eax, -12(%rbp) .l4: movl -12(%rbp), %eax leave ret :max2 movl %edi, -4(%rbp) movl %esi, -8(%rbp) movl -4(%rbp), %eax cmpl %eax, -8(%rbp) cmovge -8(%rbp), %eax leave ret </code></pre><p><code>max2</code> использует намного меньше кода из-за использования инструкции <code>cmovge</code>. но реальная выгода заключается в том, что <code>max2</code> не включает переходов по ветвям, <code>jmp</code>, что может привести к значительному снижению производительности, если прогнозируемый результат неверен.</p><p>так почему условный ход работает лучше?</p><p>в типичном процессоре <code>x86</code> выполнение инструкции делится на несколько этапов. грубо говоря, у нас разные аппаратные средства для разных этапов. поэтому нам не нужно ждать окончания одной инструкции, чтобы начать новую. это называется <strong> <a href="http://en.wikipedia.org/wiki/pipeline\_%28computing%29">конвейерная обработка</a> </strong>.</p><p>в случае ветвления следующая инструкция определяется предыдущей, поэтому мы не можем выполнить конвейеризацию. мы должны либо ждать, либо прогнозировать.</p><p>в случае условного перемещения выполнение команды условного перемещения делится на несколько этапов, но более ранние этапы, такие как <code>fetch</code> и <code>decode</code>, не зависят от результата предыдущей инструкции; только последним этапам нужен результат. таким образом, мы ждем часть времени выполнения одной инструкции. вот почему версия условного перемещения медленнее, чем ветвь, когда предсказание легко.</p><p>книга <em> <a href="https://rads.stackoverflow.com/amzn/click/com/0136108040">компьютерные системы: взгляд программиста, второе издание</a> </em> объясняет это подробно. вы можете проверить раздел 3.6.6 для <em> условных инструкций перемещения </em>, всю главу 4 для <em> архитектуры процессора </em> и раздел 5.11.2 для специальный режим для <em> штрафов за предсказание и неправильное предсказание </em>.</p><p>иногда некоторые современные компиляторы могут оптимизировать наш код для сборки с большей производительностью, иногда некоторые компиляторы не могут (рассматриваемый код использует собственный компилятор visual studio). зная разницу в производительности между ветвлением и условным перемещением, когда он непредсказуем, может помочь нам написать код с лучшей производительностью, когда сценарий становится настолько сложным, что компилятор не может оптимизировать их автоматически.</p>

<p>если вам интересно еще больше оптимизаций, которые можно сделать с этим кодом, подумайте об этом:</p><p>начиная с оригинального цикла:</p><pre><code>for (unsigned i = 0; i < 100000; ++i) { for (unsigned j = 0; j < arraysize; ++j) { if (data[j] >= 128) sum += data[j]; } } </code></pre><p>с циклом обмена мы можем смело изменить этот цикл на:</p><pre><code>for (unsigned j = 0; j < arraysize; ++j) { for (unsigned i = 0; i < 100000; ++i) { if (data[j] >= 128) sum += data[j]; } } </code></pre><p>затем вы можете видеть, что условное выражение <code>if</code> является постоянным на протяжении всего цикла <code>i</code>, поэтому вы можете вывести <code>if</code> out:</p><pre><code>for (unsigned j = 0; j < arraysize; ++j) { if (data[j] >= 128) { for (unsigned i = 0; i < 100000; ++i) { sum += data[j]; } } } </code></pre><p>затем вы видите, что внутренний цикл можно свернуть в одно отдельное выражение, предполагая, что это допускает модель с плавающей запятой (например, выбрасывается <code>/fp:fast</code>)</p><pre><code>for (unsigned j = 0; j < arraysize; ++j) { if (data[j] >= 128) { sum += data[j] * 100000; } } </code></pre><p>это в 100 000 раз быстрее, чем раньше.</p>

<p>несомненно, некоторые из нас будут заинтересованы в способах идентификации кода, который является проблематичным для предсказателя ветвления цп. у инструмента valgrind <code>cachegrind</code> есть симулятор предсказания ветвлений, включаемый с помощью флага <code>--branch-sim=yes</code>. выполнение этого в примерах из этого вопроса с уменьшением числа внешних циклов до 10000 и компиляцией с помощью <code>g++</code> дает следующие результаты:</p><p><strong> сортировка: </strong></p><pre><code>==32551== branches: 656,645,130 ( 656,609,208 cond + 35,922 ind) ==32551== mispredicts: 169,556 ( 169,095 cond + 461 ind) ==32551== mispred rate: 0.0% ( 0.0% + 1.2% ) </code></pre><p><strong> unsorted: </strong></p><pre><code>==32555== branches: 655,996,082 ( 655,960,160 cond + 35,922 ind) ==32555== mispredicts: 164,073,152 ( 164,072,692 cond + 460 ind) ==32555== mispred rate: 25.0% ( 25.0% + 1.2% ) </code></pre><p>детализация в построчном выводе, производимом <code>cg\_annotate</code>, мы видим для рассматриваемого цикла:</p><p><strong> сортировка: </strong></p><pre><code> bc bcm bi bim 10,001 4 0 0 for (unsigned i = 0; i < 10000; ++i) . . . . { . . . . // primary loop 327,690,000 10,016 0 0 for (unsigned c = 0; c < arraysize; ++c) . . . . { 327,680,000 10,006 0 0 if (data[c] >= 128) 0 0 0 0 sum += data[c]; . . . . } . . . . } </code></pre><p><strong> unsorted: </strong></p><pre><code> bc bcm bi bim 10,001 4 0 0 for (unsigned i = 0; i < 10000; ++i) . . . . { . . . . // primary loop 327,690,000 10,038 0 0 for (unsigned c = 0; c < arraysize; ++c) . . . . { 327,680,000 164,050,007 0 0 if (data[c] >= 128) 0 0 0 0 sum += data[c]; . . . . } . . . . } </code></pre><p>это позволяет легко идентифицировать проблемную строку - в несортированной версии строка <code>if (data[c] >= 128)</code> вызывает 164 050 007 неправильно предсказанных условных ветвлений (<code>bcm</code>) в модели предсказателя ветвления cachegrind, тогда как в отсортированной версии она вызывает только 10 006.</p><hr><p>кроме того, в linux вы можете использовать подсистему счетчиков производительности для выполнения той же задачи, но с собственной производительностью с использованием счетчиков цп.</p><pre><code>perf stat ./sumtest\_sorted </code></pre><p><strong> сортировка: </strong></p><pre><code> performance counter stats for './sumtest\_sorted': 11808.095776 task-clock # 0.998 cpus utilized 1,062 context-switches # 0.090 k/sec 14 cpu-migrations # 0.001 k/sec 337 page-faults # 0.029 k/sec 26,487,882,764 cycles # 2.243 ghz 41,025,654,322 instructions # 1.55 insns per cycle 6,558,871,379 branches # 555.455 m/sec 567,204 branch-misses # 0.01% of all branches 11.827228330 seconds time elapsed </code></pre><p><strong> unsorted: </strong></p><pre><code> performance counter stats for './sumtest\_unsorted': 28877.954344 task-clock # 0.998 cpus utilized 2,584 context-switches # 0.089 k/sec 18 cpu-migrations # 0.001 k/sec 335 page-faults # 0.012 k/sec 65,076,127,595 cycles # 2.253 ghz 41,032,528,741 instructions # 0.63 insns per cycle 6,560,579,013 branches # 227.183 m/sec 1,646,394,749 branch-misses # 25.10% of all branches 28.935500947 seconds time elapsed </code></pre><p>он также может делать аннотации исходного кода с разборкой.</p><pre><code>perf record -e branch-misses ./sumtest\_unsorted perf annotate -d sumtest\_unsorted </code></pre><pre><code> percent | source code & disassembly of sumtest\_unsorted ------------------------------------------------ ... : sum += data[c]; 0.00 : 400a1a: mov -0x14(%rbp),%eax 39.97 : 400a1d: mov %eax,%eax 5.31 : 400a1f: mov -0x20040(%rbp,%rax,4),%eax 4.60 : 400a26: cltq 0.00 : 400a28: add %rax,-0x30(%rbp) ... </code></pre><p>смотрите <a href="https://perf.wiki.kernel.org/index.php/tutorial">учебник по производительности</a> для более подробной информации.</p>

<p>я просто прочитал этот вопрос и его ответы, и я чувствую, что ответ отсутствует.</p><p>обычный способ устранить предсказание ветвления, который, как мне показалось, особенно хорошо работает в управляемых языках, - это поиск в таблице вместо использования ветвления (хотя в этом случае я его не проверял).</p><p>этот подход работает в целом, если:</p><ol> <li>это небольшая таблица, которая, вероятно, будет кэшироваться в процессоре, и</li> <li>вы работаете в довольно узком цикле, и/или процессор может предварительно загрузить данные.</li> </ol><p><strong>история вопроса и почему</strong></p><p>с точки зрения процессора, ваша память работает медленно. чтобы компенсировать разницу в скорости, в ваш процессор встроена пара кешей (кеш l1/l2). итак, представьте, что вы делаете свои вычисления в nice, и выясните, что вам нужен кусок памяти. процессор выполнит операцию загрузки и загрузит часть памяти в кеш, а затем использует кеш для выполнения остальных вычислений. поскольку память относительно медленная, эта "загрузка" замедлит вашу программу.</p><p>как и предсказание ветвлений, это было оптимизировано в процессорах pentium: процессор предсказывает, что ему нужно загрузить часть данных, и пытается загрузить их в кеш, прежде чем операция действительно попадет в кеш. как мы уже видели, предсказание ветвления иногда идет ужасно неправильно - в худшем случае вам нужно вернуться назад и фактически ждать загрузки памяти, которая будет длиться вечно (<strong>другими словами: сбой предсказания ветвлений плохо, загрузка памяти после сбоя предсказания ветвления просто ужасна!</strong>).</p><p>к счастью для нас, если схема доступа к памяти предсказуема, процессор загрузит ее в свой быстрый кеш, и все в порядке.</p><p>первое, что нам нужно знать, это то, что <em> мало </em>? хотя меньший размер, как правило, лучше, практическое правило заключается в том, чтобы придерживаться таблиц поиска размером <= 4096 байт. в качестве верхнего предела: если ваша таблица поиска больше 64 кб, вероятно, стоит пересмотреть.</p><p><strong>построение таблицы</strong></p><p>итак, мы выяснили, что можем создать небольшую таблицу. следующее, что нужно сделать, это установить на место функцию поиска. функции поиска обычно представляют собой небольшие функции, которые используют несколько основных целочисленных операций (и, или, xor, shift, add, remove и, возможно, умножение). вы хотите, чтобы ваш ввод был переведен с помощью функции поиска на какой-то "уникальный ключ" в вашей таблице, который затем просто дает вам ответ на всю работу, которую вы хотели, чтобы он делал.</p><p>в этом случае:> = 128 означает, что мы можем сохранить значение, <128 означает, что мы избавимся от него. самый простой способ сделать это - использовать 'и': если мы сохраняем это, мы и это с 7fffffff; если мы хотим избавиться от него, мы и это с 0. отметим также, что 128 - это степень 2 - так что мы можем пойти дальше и составить таблицу из 32768/128 целых чисел и заполнить ее одним нулем и множеством 7ffffffff годов.</p><p><strong>управляемые языки</strong></p><p>вы можете удивиться, почему это хорошо работает на управляемых языках. в конце концов, управляемые языки проверяют границы массивов с помощью ветки, чтобы убедиться, что вы не ошиблись ...</p><p>ну, не совсем ... :-)</p><p>была проделана определенная работа по устранению этой ветки для управляемых языков. например:</p><pre class="lang-cs prettyprint-override"><code>for (int i = 0; i < array.length; ++i) { // use array[i] } </code></pre><p>в этом случае для компилятора очевидно, что граничное условие никогда не будет выполнено. по крайней мере компилятор microsoft jit (но я ожидаю, что java делает подобные вещи) заметит это и вообще уберет проверку. вау, это означает, что нет ветви. точно так же это будет иметь дело с другими очевидными случаями.</p><p>если у вас возникли проблемы с поиском на управляемых языках - ключ заключается в том, чтобы добавить <code>& 0x[something]fff</code> в вашу функцию поиска, чтобы сделать проверку границ предсказуемой, - и наблюдать, как она идет быстрее.</p><p><strong>результат этого дела</strong></p><pre class="lang-cs prettyprint-override"><code>// generate data int arraysize = 32768; int[] data = new int[arraysize]; random random = new random(0); for (int c = 0; c < arraysize; ++c) { data[c] = random.next(256); } /*to keep the spirit of the code intact, i'll make a separate lookup table (i assume we cannot modify 'data' or the number of loops)*/ int[] lookup = new int[256]; for (int c = 0; c < 256; ++c) { lookup[c] = (c >= 128) ? c : 0; } // test datetime starttime = system.datetime.now; long sum = 0; for (int i = 0; i < 100000; ++i) { // primary loop for (int j = 0; j < arraysize; ++j) { /* here you basically want to use simple operations - so no random branches, but things like &, |, *, -, +, etc. are fine. */ sum += lookup[data[j]]; } } datetime endtime = system.datetime.now; console.writeline(endtime - starttime); console.writeline("sum = " + sum); console.readline(); </code></pre>

<p>поскольку данные распределяются между 0 и 255 при сортировке массива, примерно в первой половине итераций не будет введен оператор <code>if</code><strong>оператор <code>if</code> представлен ниже).</p><pre><code>if (data[c] >= 128) sum += data[c]; </code></pre><p>вопрос в том, что делает вышеприведенное утверждение не выполненным в некоторых случаях, например, в случае отсортированных данных? здесь появляется "предсказатель ветви". предиктор ветвления - это цифровая схема, которая пытается угадать, каким образом пойдет ветвь (например, структура <code>if-then-else</code>), прежде чем это станет известно наверняка. целью предиктора ветвления является улучшение потока в конвейере команд. предсказатели ветвлений играют решающую роль в достижении высокой эффективности!</p><p>--- (давайте сделаем несколько тестов, чтобы понять это лучше</strong></p><p>производительность оператора <code>if</code>- зависит от того, имеет ли его условие предсказуемый шаблон. если условие всегда истинно или всегда ложно, логика предсказания ветвления в процессоре подберет шаблон. с другой стороны, если шаблон непредсказуем, оператор <code>if</code>- будет намного дороже.</p><p>давайте измерим производительность этого цикла с различными условиями:</p><pre><code>for (int i = 0; i < max; i++) if (condition) sum++; </code></pre><p>вот временные параметры цикла с различными паттернами истина-ложь:</p><pre><code>condition pattern time (ms) ------------------------------------------------------- (i & 0×80000000) == 0 t repeated 322 (i & 0xffffffff) == 0 f repeated 276 (i & 1) == 0 tf alternating 760 (i & 3) == 0 tffftfff… 513 (i & 2) == 0 ttffttff… 1675 (i & 4) == 0 ttttffffttttffff… 1275 (i & 8) == 0 8t 8f 8t 8f … 752 (i & 16) == 0 16t 16f 16t 16f … 490 </code></pre><p>шаблон "<strong>плохой</strong>" true-false может сделать оператор <code>if</code>- в шесть раз медленнее, чем шаблон "<strong>хороший</strong>"! конечно, какой шаблон хорош, а какой плох, зависит от точных инструкций, сгенерированных компилятором, и от конкретного процессора.</p><p>таким образом, нет никаких сомнений в отношении влияния отраслевого прогнозирования на производительность!</p>

<p>один из способов избежать ошибок предсказания ветвлений - это создать справочную таблицу и проиндексировать ее, используя данные. стефан де брюин обсуждал это в своем ответе.</p><p>но в этом случае мы знаем, что значения находятся в диапазоне [0, 255], и мы заботимся только о значениях> = 128. это означает, что мы можем легко извлечь один бит, который скажет нам, хотим ли мы значение или нет: сдвигая данные справа 7 бит, у нас осталось 0 бит или 1 бит, и мы хотим добавить значение только тогда, когда у нас есть 1 бит. давайте назовем этот бит "битом решения".</p><p>используя значение 0/1 бита решения в качестве индекса в массиве, мы можем создать код, который будет одинаково быстрым, независимо от того, отсортированы данные или нет. наш код всегда добавляет значение, но когда бит принятия решения равен 0, мы добавим значение туда, где нам все равно. вот код:</p><pre><code>// test clock\_t start = clock(); long long a[] = {0, 0}; long long sum; for (unsigned i = 0; i < 100000; ++i) { // primary loop for (unsigned c = 0; c < arraysize; ++c) { int j = (data[c] >> 7); a[j] += data[c]; } } double elapsedtime = static\_cast<double>(clock() - start) / clocks\_per\_sec; sum = a[1]; </code></pre><p>этот код тратит впустую половину добавления, но никогда не имеет ошибки предсказания ветвления. это значительно быстрее на случайных данных, чем версия с фактическим оператором if.</p><p>но в моем тестировании явная таблица поиска была немного быстрее, чем эта, вероятно, потому что индексирование в таблицу поиска было немного быстрее, чем битовое смещение. это показывает, как мой код настраивает и использует таблицу поиска (невообразимо называемую <code>lut</code> для "таблицы поиска" в коде). вот код c++:</p><pre><code>// declare and then fill in the lookup table int lut[256]; for (unsigned c = 0; c < 256; ++c) lut[c] = (c >= 128) ? c : 0; // use the lookup table after it is built for (unsigned i = 0; i < 100000; ++i) { // primary loop for (unsigned c = 0; c < arraysize; ++c) { sum += lut[data[c]]; } } </code></pre><p>в этом случае таблица поиска составляла всего 256 байт, поэтому она хорошо помещалась в кеш, и все было быстро. этот метод не сработает, если данные будут 24-битными значениями, а нам нужна только половина из них ... таблица поиска была бы слишком большой, чтобы быть практичной. с другой стороны, мы можем объединить два метода, показанных выше: сначала сдвинуть биты, а затем проиндексировать таблицу поиска. для 24-битного значения, для которого нам нужно только верхнее половинное значение, мы могли бы сдвинуть данные вправо на 12 бит и оставить 12-битное значение для индекса таблицы. 12-битный индекс таблицы подразумевает таблицу из 4096 значений, что может быть практичным.</p><p>техника индексации в массив, вместо использования оператора <code>if</code>, может быть использована для определения, какой указатель использовать. я увидел библиотеку, в которой реализованы двоичные деревья, и вместо двух именованных указателей (<code>pleft</code> и <code>pright</code> или чего-либо еще) имел массив указателей длины 2 и использовал технику "бит решения", чтобы решить, какой из них следовать. например, вместо:</p><pre><code>if (x < node->value) node = node->pleft; else node = node->pright; </code></pre><p>эта библиотека будет делать что-то вроде:</p><pre><code>i = (x < node->value); node = node->link[i]; </code></pre><p>вот ссылка на этот код: <a href="http://www.eternallyconfuzzled.com/tuts/datastructures/jsw\_tut\_rbtree.aspx">красные черные деревья</a> , <em> вечно смущенный </em></p>

<p>в отсортированном случае вы можете добиться большего успеха, чем полагаться на успешное предсказание ветвлений или любой метод сравнения без ветвей: полностью удалить ветвь.</p><p>действительно, массив разделен на смежные зоны с помощью <code>data < 128</code>, а другой - с <code>data >= 128</code>. таким образом, вы должны найти точку разделения с помощью <a href="https://en.wikipedia.org/wiki/dichotomic\_search">дихотомический поиск</a> (используя сравнения <code>lg(arraysize) = 15</code>), а затем выполнить прямое накопление с этой точки.</p><p>что-то вроде (не проверено)</p><pre><code>int i= 0, j, k= arraysize; while (i < k) { j= (i + k) >> 1; if (data[j] >= 128) k= j; else i= j; } sum= 0; for (; i < arraysize; i++) sum+= data[i]; </code></pre><p>или, немного более запутанный</p><pre><code>int i, k, j= (i + k) >> 1; for (i= 0, k= arraysize; i < k; (data[j] >= 128 ? k : i)= j) j= (i + k) >> 1; for (sum= 0; i < arraysize; i++) sum+= data[i]; </code></pre><p>еще более быстрый подход, который дает <strong> приближенное </strong> решение как для отсортированного, так и для несортированного: <code>sum= 3137536;</code> (при условии действительно равномерного распределения, 16384 выборки с ожидаемым значением 191.5) <strong>: -) </strong></p>

<p>вышеупомянутое поведение происходит из-за предсказания ветви.</p><p>чтобы понять предсказание ветвления, нужно сначала понять <strong> конвейер инструкций </strong>:</p><p>любая инструкция разбита на последовательность шагов, так что разные шаги могут выполняться параллельно параллельно. этот метод известен как конвейер команд и используется для увеличения пропускной способности современных процессоров. чтобы лучше это понять, посмотрите это <a href="https://en.wikipedia.org/wiki/pipeline\_(computing)#concept\_and\_motivation">пример в википедии</a> .</p><p>как правило, современные процессоры имеют довольно длинные конвейеры, но для простоты давайте рассмотрим только эти 4 шага.</p><ol> <li>if - извлечь инструкцию из памяти</li> <li>id - расшифровать инструкцию</li> <li>ex - выполнить инструкцию</li> <li>wb - запись обратно в регистр процессора</li> </ol><p><strong> <em> 4-этапный конвейер в целом для 2 инструкций. </em> </strong> <img src="https://i.stack.imgur.com/pqbbr.png" alt="4-stage pipeline in general"></p><p>возвращаясь к вышеупомянутому вопросу, давайте рассмотрим следующие инструкции:</p><pre><code> a) if (data[c] >= 128) /\ / \ / \ true / \ false / \ / \ / \ / \ b) sum += data[c]; c) for loop or print(). </code></pre><p>без прогнозирования ветвления может произойти следующее:</p><p>чтобы выполнить инструкцию b или инструкцию c, процессор должен будет ждать, пока инструкция a не достигнет стадии ex в конвейере, поскольку решение перейти к инструкции b или инструкции c зависит от результата инструкции a. таким образом, конвейер будет выглядеть так.</p><p><strong> <em> когда условие возвращает true: </em> </strong> <img src="https://i.stack.imgur.com/0h4gp.png" alt="enter image description here"></p><p><strong> <em> когда условие возвращает false: </em> </strong> <img src="https://i.stack.imgur.com/appca.png" alt="enter image description here"></p><p>в результате ожидания результата команды a общее количество циклов цп, проведенных в вышеупомянутом случае (без прогнозирования ветвления; как для истинного, так и для ложного), равно 7.</p><p><strong> так что же такое предсказание ветвления? </strong></p><p>предсказатель ветвления попытается угадать, каким образом пойдет ветвь (структура if-then-else), прежде чем это станет известно наверняка. он не будет ждать, пока инструкция a достигнет стадии ex конвейера, но он угадает решение и перейдет к этой инструкции (b или c в случае нашего примера).</p><p><strong> <em> в случае правильного предположения конвейер выглядит примерно так: </em> </strong> <img src="https://i.stack.imgur.com/zyubs.png" alt="enter image description here"></p><p>если позднее обнаруживается, что предположение было неверным, то частично выполненные инструкции отбрасываются, и конвейер начинается с правильной ветви, что вызывает задержку. время, которое теряется в случае ошибочного прогнозирования ветвления, равно количеству этапов в конвейере от этапа выборки до этапа выполнения. современные микропроцессоры, как правило, имеют довольно длинные конвейеры, поэтому задержка неверного прогнозирования составляет от 10 до 20 тактов. чем длиннее конвейер, тем больше потребность в хорошем <a href="https://en.wikipedia.org/wiki/branch\_predictor">предсказатель ветвления</a> .</p><p>в коде op первый раз, когда выполняется условие, предсказатель ветвления не имеет никакой информации для обоснования предсказания, поэтому в первый раз он случайным образом выберет следующую инструкцию. позже в цикле for он может основывать прогноз на истории. для массива, отсортированного в порядке возрастания, есть три возможности:</p><ol> <li>все элементы меньше 128</li> <li>все элементы больше 128</li> <li>некоторые начинающие новые элементы меньше 128 и позже становятся больше 128</li> </ol><p>предположим, что предиктор всегда будет принимать истинную ветвь при первом запуске.</p><p>так что в первом случае он всегда будет принимать истинную ветвь, поскольку исторически все его предсказания верны. во 2-м случае изначально он будет предсказывать неверно, но после нескольких итераций он будет предсказывать правильно. в третьем случае он изначально будет правильно прогнозировать до тех пор, пока элементы не станут меньше 128. после чего он потерпит неудачу в течение некоторого времени и сам исправится, когда увидит ошибку прогнозирования ветвления в истории.</p><p>во всех этих случаях количество ошибок будет меньше, и в результате всего лишь несколько раз потребуется отменить частично выполненные инструкции и начать заново с правильной ветвью, что приведет к уменьшению циклов цп.</p><p>но в случае случайного несортированного массива прогноз должен отбросить частично выполненные инструкции и большую часть времени начинать с правильной ветви, что приведет к большему количеству циклов цп по сравнению с отсортированным массивом.</p>

<p>официальный ответ будет от</p><ol> <li> <a href="https://software.intel.com/en-us/articles/avoiding-the-cost-of-branch-misprediction">intel - предотвращение ошибочных прогнозов в отрасли</a> </li> <li> <a href="https://software.intel.com/en-us/articles/branch-and-loop-reorganization-to-prevent-mispredicts">intel - реорганизация ветвей и циклов для предотвращения ошибок</a> </li> <li> <a href="https://scholar.google.com/scholar?q=branch%20prediction%20computer%20architecture&hl=da&as\_sdt=0&as\_vis=1&oi=scholart">научные труды - отраслевая компьютерная архитектура прогнозирования</a> </li> <li>книги: дж.л. хеннесси, д.а. паттерсон: компьютерная архитектура: количественный подход</li> <li>статьи в научных публикациях: т.ю. да, я.н. патт сделал много из них по прогнозам отрасли.</li> </ol><p>вы также можете увидеть из этого прекрасного <a href="https://en.wikipedia.org/wiki/branch\_predictor#/media/file:branch\_prediction\_2bit\_saturating\_counter-dia.svg">схема</a> почему предсказатель ветвления запутался.</p><p> <a href="https://i.stack.imgur.com/pbmv2.png"><img src="https://i.stack.imgur.com/pbmv2.png" alt="2-bit state diagram"></a> </p><p>каждый элемент в исходном коде является случайным значением</p><pre><code>data[c] = std::rand() % 256; </code></pre><p>таким образом, предиктор будет менять сторону в качестве удара <code>std::rand()</code>.</p><p>с другой стороны, после сортировки предиктор сначала переходит в состояние строго не принятого, а когда значения изменяются до высокого значения, предиктор за три прогона изменяется полностью от сильно не принятого до строго принятого.</p><hr>

<p>в той же строке (я думаю, что это не было выделено ни одним ответом) хорошо упомянуть, что иногда (особенно в программном обеспечении, где производительность имеет значение - как в ядре linux) вы можете найти некоторые операторы if, подобные следующим:</p><pre><code>if (likely( everything\_is\_ok )) { /* do something */ } </code></pre><p>или аналогично:</p><pre><code>if (unlikely(very\_improbable\_condition)) { /* do something */ } </code></pre><p>и <code>likely()</code>, и <code>unlikely()</code> на самом деле являются макросами, которые определяются с помощью чего-то вроде <code>\_\_builtin\_expect</code> в gcc, чтобы помочь компилятору вставить код прогнозирования в пользу условия с учетом информации, предоставленной пользователем. gcc поддерживает другие встроенные функции, которые могут изменить поведение работающей программы или выдавать низкоуровневые инструкции, такие как очистка кэша и т.д. см. <a href="https://gcc.gnu.org/onlinedocs/gcc/other-builtins.html">эту документацию</a> , которая описывает доступные встроенные функции gcc.</p><p>обычно такого рода оптимизации в основном встречаются в приложениях реального времени или встроенных системах, где время выполнения имеет значение, и оно критично. например, если вы проверяете какое-либо условие ошибки, которое происходит только 1/10000000 раз, то почему бы не сообщить об этом компилятору? таким образом, по умолчанию прогноз ветвления предполагает, что условие ложно.</p>

<p>часто используемые логические операции в c++ создают много веток в скомпилированной программе. если эти ветви находятся внутри циклов и их трудно предсказать, они могут значительно замедлить выполнение. булевы переменные хранятся в виде 8-битных целых чисел со значением <code>0</code> для <code>false</code> и <code>1</code> для <code>true</code>.</p><p>булевы переменные переопределяются в том смысле, что все операторы, которые имеют булевы переменные в качестве входных данных, проверяют, имеют ли входные значения любое другое значение, кроме <code>0</code> или <code>1</code>, но операторы, которые имеют логические переменные в качестве выходных данных, не могут производить никакого другого значения, кроме <code>0</code> или <code>1</code>. это делает операции с булевыми переменными в качестве входных данных менее эффективными, чем необходимо. рассмотрим пример:</p><pre><code>bool a, b, c, d; c = a && b; d = a || b; </code></pre><p>обычно это реализуется компилятором следующим образом:</p><pre><code>bool a, b, c, d; if (a != 0) { if (b != 0) { c = 1; } else { goto cfalse; } } else { cfalse: c = 0; } if (a == 0) { if (b == 0) { d = 0; } else { goto dtrue; } } else { dtrue: d = 1; } </code></pre><p>этот код далеко не оптимален. ветви могут занять много времени в случае неправильных прогнозов. логические операции можно сделать намного более эффективными, если точно известно, что у операндов нет других значений, кроме <code>0</code> и <code>1</code>. причина, по которой компилятор не делает такого предположения, состоит в том, что переменные могут иметь другие значения, если они неинициализированы или получены из неизвестных источников. приведенный выше код можно оптимизировать, если <code>a</code> и <code>b</code> были инициализированы для допустимых значений или если они получены от операторов, которые выдают логический вывод. оптимизированный код выглядит так:</p><pre><code>char a = 0, b = 1, c, d; c = a & b; d = a | b; </code></pre><p><code>char</code> используется вместо <code>bool</code> для того, чтобы сделать возможным использование побитовых операторов (<code>&</code> и <code>|</code>) вместо логических операторов (<code>&&</code> и <code>||</code>). побитовые операторы - это одиночные инструкции, которые занимают только один такт. оператор or (<code>|</code>) работает, даже если <code>a</code> и <code>b</code> имеют другие значения, отличные от <code>0</code> или <code>1</code>. оператор and (<code>&</code>) и оператор exclusive or (<code>^</code>) могут давать противоречивые результаты, если операнды имеют значения, отличные от <code>0</code> и <code>1</code>.</p><p><code>~</code> не может быть использован для не. вместо этого вы можете сделать логическое не для переменной, которая известна как <code>0</code> или <code>1</code>, xor'ом ее с <code>1</code>:</p><pre><code>bool a, b; b = !a; </code></pre><p>можно оптимизировать для:</p><pre><code>char a = 0, b; b = a ^ 1; </code></pre><p><code>a && b</code> нельзя заменить на <code>a & b</code>, если <code>b</code> является выражением, которое не следует оценивать, если <code>a</code> равно <code>false</code> (<code>&&</code> не будет оценивать <code>b</code>, <code>&</code> будет). аналогично, <code>a || b</code> нельзя заменить на <code>a | b</code>, если <code>b</code> является выражением, которое не следует оценивать, если <code>a</code> равно <code>true</code>.</p><p>использование побитовых операторов более выгодно, если операнды являются переменными, чем если операнды являются сравнениями:</p><pre><code>bool a; double x, y, z; a = x > y && z < 5.0; </code></pre><p>в большинстве случаев является оптимальным (если только вы не ожидаете, что выражение <code>&&</code> вызовет много ошибочных предсказаний ветвлений).</p>

<p>это уж точно!...</p><p><strong> прогноз ветвления </strong> заставляет логику работать медленнее из-за переключения, которое происходит в вашем коде! как будто вы идете по прямой улице или улице с большим количеством поворотов, наверняка прямая будет сделана быстрее! ...</p><p>если массив отсортирован, ваше условие ложно на первом шаге: <code>data[c] >= 128</code>, а затем становится истинным значением для всего пути до конца улицы. вот так вы быстрее доберетесь до конца логики. с другой стороны, при использовании несортированного массива вам нужно много поворотов и обработки, которые наверняка замедляют работу вашего кода ...</p><p>посмотрите на изображение, которое я создал для вас ниже. какая улица будет закончена быстрее?</p><p> <a href="https://i.stack.imgur.com/csmca.jpg"><img src="https://i.stack.imgur.com/csmca.jpg" alt="branch prediction"></a> </p><p>таким образом, программно <strong> предсказание ветвления </strong> приводит к замедлению процесса ...</p><p>также, в конце, хорошо знать, что у нас есть два вида предсказаний ветвлений, каждый из которых по-разному повлияет на ваш код:</p><p><strong> 1. статический </strong></p><p><strong> 2. dynamic </strong></p><p> <a href="https://i.stack.imgur.com/zfhdu.jpg"><img src="https://i.stack.imgur.com/zfhdu.jpg" alt="branch prediction"></a> </p><blockquote> <p>предсказание статических переходов используется микропроцессором при первом обнаружении условного перехода, а динамическое прогнозирование ветвления используется для успешного выполнения кода условного перехода.</p> <p>чтобы эффективно написать свой код, чтобы воспользоваться этими правилами, при написании <strong> переключателя if-else </strong> или <strong> </strong> сначала проверьте наиболее распространенные случаи и постепенно переходите к наименее распространенным. циклы не обязательно требуют какого-либо специального упорядочения кода для статического предсказания ветвления, поскольку обычно используется только условие итератора цикла.</p> </blockquote>

<p>на этот вопрос уже много раз отвечали превосходно. тем не менее, я хотел бы обратить внимание группы на еще один интересный анализ.</p><p>недавно этот пример (измененный очень незначительно) также использовался для демонстрации того, как фрагмент кода может быть профилирован в самой программе в windows. попутно автор также показывает, как использовать результаты, чтобы определить, где код проводит большую часть своего времени как в отсортированном, так и в несортированном случае. наконец, в этой части также показано, как использовать малоизвестную функцию hal (уровень аппаратной абстракции), чтобы определить, насколько часто происходит неправильное предсказание ветвления в несортированном случае.</p><p>ссылка здесь: <a href="http://www.geoffchappell.com/studies/windows/km/ntoskrnl/api/ex/profile/demo.htm">http://www.geoffchappell.com/studies/windows/km/ntoskrnl/api/ex/profile/demo.htm</a> </p>

<p>как и то, что уже было упомянуто другими, что скрывается за тайной <a href="https://en.wikipedia.org/wiki/branch\_predictor">branch predictor</a> .</p><p>я не пытаюсь что-то добавить, а объясняю концепцию по-другому. существует краткое введение в вики, которое содержит текст и диаграмму. мне нравится объяснение ниже, которое использует диаграмму для интуитивного развития предиктора ветвей.</p><blockquote> <p>в компьютерной архитектуре предиктор ветвления представляет собой цифровую схему, которая пытается угадать, каким образом пойдет ветвь (например, структура if-then-else), прежде чем это станет известно наверняка. целью предиктора ветвления является улучшение потока в конвейере команд. предсказатели ветвлений играют решающую роль в достижении высокой эффективной производительности во многих современных конвейерных микропроцессорных архитектурах, таких как x86.</p> <p>двустороннее ветвление обычно реализуется с помощью инструкции условного перехода. условный переход может быть либо "не взят" и продолжен с первой ветвью кода, которая следует сразу после условного перехода, либо его можно "взять" и перейти в другое место в памяти программ, где находится вторая ветвь кода. сохраняются. точно неизвестно, будет ли выполнен условный переход или нет, пока условие не будет вычислено и условный переход не пройдет этап выполнения в конвейере команд (см. рис. 1).</p> </blockquote><p> <a href="https://i.stack.imgur.com/unxnb.png"><img src="https://i.stack.imgur.com/unxnb.png" alt="figure 1"></a> </p><p>на основе описанного сценария я написал демонстрационную анимацию, чтобы показать, как выполняются инструкции в конвейере в различных ситуациях.</p><ol> <li>без предсказателя отрасли.</li> </ol><blockquote> <p>без предсказания перехода процессор должен был бы ждать, пока инструкция условного перехода не пройдет этап выполнения, прежде чем следующая команда сможет перейти на этап выборки в конвейере.</p> </blockquote><p>пример содержит три инструкции, и первая из них является инструкцией условного перехода. последние две инструкции могут идти в конвейер, пока не будет выполнена команда условного перехода.</p><p> <a href="https://i.stack.imgur.com/gmfq6.gif"><img src="https://i.stack.imgur.com/gmfq6.gif" alt="without branch predictor"></a> </p><p>для выполнения 3-х инструкций потребуется 9 тактов.</p><ol start="2"> <li>используйте branch predictor и не делайте условного прыжка. давайте предположим, что прогноз <strong> не </strong> делает условный переход.</li> </ol><p> <a href="https://i.stack.imgur.com/ms5p1.gif"><img src="https://i.stack.imgur.com/ms5p1.gif" alt="enter image description here"></a> </p><p>для выполнения 3-х инструкций потребуется 7 тактов.</p><ol start="3"> <li>используйте branch predictor и сделайте условный прыжок. давайте предположим, что прогноз <strong> не </strong> делает условный переход.</li> </ol><p> <a href="https://i.stack.imgur.com/hipg3.gif"><img src="https://i.stack.imgur.com/hipg3.gif" alt="enter image description here"></a> </p><p>для выполнения 3-х инструкций потребуется 9 тактов.</p><blockquote> <p>время, которое теряется в случае ошибочного прогнозирования ветвления, равно количеству этапов в конвейере от этапа выборки до этапа выполнения. современные микропроцессоры, как правило, имеют довольно длинные конвейеры, поэтому задержка неверного прогнозирования составляет от 10 до 20 тактов. в результате увеличение длины конвейера увеличивает потребность в более продвинутом предикторе ветвления.</p> </blockquote><p>как видите, у нас нет причин не использовать branch predictor.</p><p>это довольно простая демонстрация, которая разъясняет самую основную часть branch predictor. если эти картинки раздражают, пожалуйста, удалите их из ответа, и посетители также могут получить демо из <a href="https://github.com/eugene-mark/branchpredictordemo">branchpredictordemo</a> </p>

<p><strong> коэффициент предсказания ветвлений! </strong></p><p>важно понимать, что неправильное прогнозирование веток не замедляет работу программ. стоимость пропущенного прогноза такая же, как если бы прогноз ветвления не существовал, и вы подождали, пока оценка выражения решит, какой код запустить (дальнейшее объяснение в следующем абзаце).</p><pre><code>if (expression) { // run 1 } else { // run 2 } </code></pre><p>всякий раз, когда есть оператор <code>if-else</code>\<code>switch</code>, выражение должно быть оценено, чтобы определить, какой блок должен быть выполнен. в код сборки, сгенерированный компилятором, вставлены условные инструкции <a href="https://en.wikipedia.org/wiki/branch\_(computer\_science)">ветвь</a> .</p><p>инструкция ветвления может заставить компьютер начать выполнение другой последовательности команд и, таким образом, отклоняться от своего поведения по умолчанию при выполнении команд по порядку (т. е. если выражение ложно, программа пропускает код блока <code>if</code>) в зависимости от некоторого условия, которое это оценка выражения в нашем случае.</p><p>при этом компилятор пытается предсказать результат до его фактической оценки. он будет извлекать инструкции из блока <code>if</code>, и если выражение окажется верным, то замечательно! мы получили время, необходимое для его оценки, и добились прогресса в коде; если нет, то мы запускаем неправильный код, конвейер сбрасывается и запускается правильный блок.</p><h3>визуализация:</h3><p>допустим, вам нужно выбрать маршрут 1 или маршрут 2. в ожидании вашего партнера, чтобы проверить карту, вы остановились на ## и ждали, или вы можете просто выбрать маршрут 1 и, если вам повезло (маршрут 1 - правильный маршрут), тогда здорово, что вам не нужно было ждать, пока ваш партнер проверит карту (вы сэкономили время, которое потребовалось бы ему, чтобы проверить карту), иначе вы просто вернетесь назад.</p><p>в то время как промывка трубопроводов очень быстрая, в наши дни эта игра стоит того. прогнозировать отсортированные данные или данные, которые изменяются медленно, всегда проще и лучше, чем прогнозировать быстрые изменения.</p><pre><code> o route 1 /------------------------------- /|\ / | ---------##/ / \ \ \ route 2 \-------------------------------- </code></pre>

<p>это про предсказание ветвлений. что это?</p><ul> <li> <p>предсказатель ветвей - это одна из древних технологий повышения производительности, которая все еще находит применение в современных архитектурах. хотя простые методы прогнозирования обеспечивают быстрый поиск и эффективность энергопотребления, они страдают от высокой степени неверного прогнозирования.</p> </li> <li> <p>с другой стороны, сложные предсказания ветвления - либо нейронные, либо варианты двухуровневого предсказания ветвления - обеспечивают лучшую точность предсказания, но они потребляют больше энергии, а сложность возрастает экспоненциально.</p> </li> <li> <p>в дополнение к этому, в сложных методах прогнозирования время, затрачиваемое на прогнозирование ветвей, само по себе очень велико - в диапазоне от 2 до 5 циклов - что сопоставимо со временем выполнения фактических ветвей.</p> </li> <li> <p>прогнозирование ветвлений - это, по сути, проблема оптимизации (минимизации), в которой основное внимание уделяется достижению минимально возможного числа пропусков, низкого энергопотребления и низкой сложности с минимальными ресурсами.</p> </li> </ul><p>на самом деле существует три вида ветвей:</p><p><strong> пересылка условных переходов </strong> - в зависимости от времени выполнения пк (программный счетчик) изменяется, чтобы указывать на адрес, перенаправленный в поток команд.</p><p><strong> обратные условные переходы </strong> - пк изменяется, чтобы указывать в обратном направлении в потоке команд. ветвление основано на некотором условии, таком как ветвление назад к началу цикла программы, когда тест в конце цикла указывает, что цикл должен быть выполнен снова.</p><p><strong> безусловные переходы </strong> - это включает переходы, вызовы процедур и возвраты, которые не имеют особых условий. например, команда безусловного перехода может быть закодирована на языке ассемблера как просто "jmp", и поток команд должен быть немедленно направлен в целевое местоположение, на которое указывает инструкция перехода, тогда как условный переход, который может быть закодирован как "jmpne" будет перенаправлять поток команд только в том случае, если результат сравнения двух значений в предыдущих инструкциях "сравнения" показывает, что значения не равны. (схема сегментированной адресации, используемая архитектурой x86, добавляет дополнительную сложность, поскольку переходы могут быть "ближними" (внутри сегмента) или "дальними" (вне сегмента). каждый тип по-разному влияет на алгоритмы прогнозирования ветвлений.)</p><p><strong> статическое/динамическое предсказание ветвления </strong>: предсказание статического ветвления используется микропроцессором при первом обнаружении условного перехода, а динамическое предсказание ветвления используется для последующих выполнений условного кода филиала.</p><p>рекомендации:</p><ul> <li> <p><em> <a href="https://en.wikipedia.org/wiki/branch\_predictor">предиктор ветвления</a> </em></p> </li> <li> <p><em> <a href="http://www.geoffchappell.com/studies/windows/km/ntoskrnl/api/ex/profile/demo.htm">демонстрация самопрофилирования</a> </em></p> </li> <li> <p><em> <a href="https://courses.cs.washington.edu/courses/csep548/06au/lectures/branchpred.pdf">обзор прогноза ветвления</a> </em></p> </li> <li> <p><em> <a href="https://web.njit.edu/~rlopes/mod5.3.pdf">прогнозирование ветвления</a> </em></p> </li> </ul>

<p>помимо того, что предсказание ветвления может замедлить вас, у отсортированного массива есть еще одно преимущество:</p><p>вы можете иметь условие остановки вместо простой проверки значения, таким образом вы только зацикливаетесь на соответствующих данных и игнорируете остальные.<br> прогноз ветвления будет пропущен только один раз.</p><pre><code> // sort backwards (higher values first), may be in some other part of the code std::sort(data, data + arraysize, std::greater<int>()); for (unsigned c = 0; c < arraysize; ++c) { if (data[c] < 128) { break; } sum += data[c]; } </code></pre>

<p>в arm ветвление не требуется, поскольку каждая инструкция имеет 4-битное поле условия, которое проверяется с нулевой стоимостью. это устраняет необходимость в коротких ветвях, и не будет никакого предсказания ветвлений. поэтому отсортированная версия будет работать медленнее, чем несортированная версия в arm, из-за дополнительных издержек сортировки. внутренний цикл будет выглядеть примерно так:</p><pre class="lang-js prettyprint-override"><code>mov r0, #0 // r0 = sum = 0 mov r1, #0 // r1 = c = 0 adr r2, data // r2 = addr of data array (put this instruction outside outer loop) .inner\_loop // inner loop branch label ldrb r3, [r2, r1] // r3 = data[c] cmp r3, #128 // compare r3 to 128 addge r0, r0, r3 // if r3 >= 128, then sum += data[c] -- no branch needed! add r1, r1, #1 // c++ cmp r1, #arraysize // compare c to arraysize blt inner\_loop // branch to inner\_loop if c < arraysize </code></pre>

<p>сортированные массивы обрабатываются быстрее, чем несортированный массив, из-за явления, называемого предсказанием ветвлений.</p><p>предиктор ветвления - это цифровая схема (в компьютерной архитектуре), которая пытается предсказать, как пойдет ветвь, улучшая поток в конвейере команд. схема/компьютер предсказывает следующий шаг и выполняет его.</p><p>неправильный прогноз приводит к возврату к предыдущему шагу и выполнению с другим прогнозом. если предположить, что прогноз верен, код перейдет к следующему шагу. неправильный прогноз приводит к повторению одного и того же шага, пока не произойдет правильный прогноз.</p><p>ответ на ваш вопрос очень прост.</p><p>в несортированном массиве компьютер делает несколько прогнозов, что повышает вероятность возникновения ошибок. принимая во внимание, что в отсортированном массиве компьютер делает меньше прогнозов, что снижает вероятность ошибок. создание большего количества прогнозов требует больше времени.</p><p>сортированный массив: прямая дорога \_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -</p><p>несортированный массив: кривая дорога</p><pre><code>\_\_\_\_\_\_ \_\_\_\_\_\_\_\_ | |\_\_| </code></pre><p>прогноз ветвления: угадывание/предсказание, какая дорога прямая и следование по ней без проверки</p><pre><code>\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ straight road |\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_|longer road </code></pre><p>хотя обе дороги достигают одного и того же пункта назначения, прямая дорога короче, а другая длиннее. если тогда вы выберете другой по ошибке, пути назад не будет, и поэтому вы потратите дополнительное время, если выберете более длинную дорогу. это похоже на то, что происходит на компьютере, и я надеюсь, что это помогло вам лучше понять.</p><hr><p>также я хочу процитировать <a href="https://stackoverflow.com/users/16940/simon-weaver">@ simon\_weaver</a> из комментариев:</p><blockquote> <p>он не делает меньше прогнозов - он делает меньше неправильных прогнозов. это все еще должно предсказывать для каждого раза через цикл ...</p> </blockquote>

<p>предположение другими ответами о том, что нужно сортировать данные, неверно.</p><p>следующий код не сортирует весь массив, а только 200-элементные его сегменты, и, следовательно, работает быстрее всего.</p><p>сортировка только k-элементных разделов завершает предварительную обработку за линейное время <code>o(n)</code>, а не за время <code>o(n.log(n))</code>, необходимое для сортировки всего массива.</p><pre><code>#include <algorithm> #include <ctime> #include <iostream> int main() { int data[32768]; const int l = sizeof data / sizeof data[0]; for (unsigned c = 0; c < l; ++c) data[c] = std::rand() % 256; // sort 200-element segments, not the whole array for (unsigned c = 0; c + 200 <= l; c += 200) std::sort(&data[c], &data[c + 200]); clock\_t start = clock(); long long sum = 0; for (unsigned i = 0; i < 100000; ++i) { for (unsigned c = 0; c < sizeof data / sizeof(int); ++c) { if (data[c] >= 128) sum += data[c]; } } std::cout << static\_cast<double>(clock() - start) / clocks\_per\_sec << std::endl; std::cout << "sum = " << sum << std::endl; } </code></pre><p>это также "доказывает", что это не имеет никакого отношения к каким-либо алгоритмическим проблемам, таким как порядок сортировки, и это действительно предсказание ветвлений.</p>

<p>потому что это отсортировано!</p><p>упорядоченные данные легче извлекать и манипулировать ими, чем неупорядоченные.</p><p>так же, как я выбираю одежду из магазинов (заказал) и из своего гардероба (испортил).</p>