if_not (a[i] > x) goto ENDIF; if_not (a[i] < y) goto ENDIF; do_something; ENDIF

1. 强制一次评估两个条件：&操作符是算术和操作，它必须评估两边。
2. 让条件更容易预测，从而降低分支错误预测率：两个完全独立的条件，概率为50%，若是一个联合条件，其真实概率为25%。
3. 两个分支合二为一变成一个分支。

#define likely(x)__builtin_expect(!!(x), 1) #define unlikely(x)__builtin_expect(!!(x), 0) if (likely(ptr)) { ptr->do_something(); }

int abs(int a) { int const mask = a >> sizeof(int) * CHAR_BIT - 1; return= (a + mask) ^ mask; }

if (x > y) { x++; }

int new_x = x + 1; x = (x > y) ? new_x : x; // the compiler should recognize this and emit a conditional branch

// 使用分支 if (a > b) { x += y; } // 不使用分支 x += -(a > b) & y;

// 使用分支 x = (a > b) ? val_a : val_b; // 不使用分支 x = val_a; x += -(a > b) & (val_b - val_a);

// 带分支 int get_next_element(int current, int buffer_len) { int next = current + 1; if (next == buffer_len) { return 0; } return next; } // 不带分支 int get_next_element_branchless(int current, int buffer_len) { int next = current + 1; return (next < buffer_len) * next; }

for (const animation& a: animation_list) { a.step_a(); if (a.is_visible()) { a.step_av(); } a.step_b(); if (a.is_visible) { a.step_bv(); }

for (const animation& a: animation_list_visible) { a.step_a(); a.step_av(); a.step_b(); a.step_bv(); } for (const animation& a: animation_list_hidden) { a.step_a(); a.step_b(); }

int average(int* array, int len, bool include_negatives) { int average = 0; int count = 0; for (int i = 0; i < n; i++) { if (include_negatives) { average += array[i]; } else { if (array[i] > 0) { average += array[i]; count++; } } } if (include_negatives) { return average / len; } else { return average / count; } }

template int average(int* array, int len) { int average = 0; int count = 0; for (int i = 0; i < n; i++) { if (include_negatives) { average += array[i]; } else { if (array[i] > 0) { average += array[i]; count++; } } } if (include_negatives) { return average / len; } else { return average / count; } }

int avg; bool should_include_negatives = get_should_include_negatives(); if (should_include_negatives) { avg = average(array, len); } else { avg = average(array, len); }

if (is_visible) { hide(); } process(); if (is_active) { display(); }

if (is_visible) { hide(); process(); display(); } else { process(); }

int larger = 0; for (int i = 0; i < n; i++) { if (a[i] > m) { larger++; } } return larger;

int result[] = { 0, 0 }; for (int i = 0; i < n; i++) { result[a>i]++; } return result[1];

• AMD A8-4500M quad-core x86-64 处理器，每个单独的内核有16 kB的L1 数据缓存，一对内核共享 2M 的 L2 缓存。这是一个现代指令流水处理器，具有分支预测、推测执行和失序执行功能。根据技术规格，该 CPU 的错误预测惩罚（misprediction penalty）约为 20 个周期。
• **Allwinner sun7i A20 dual-core ARMv7 **处理器，每个核心有 32kB 的 L1 数据缓存和 256kB 的 L2 共享缓存。 这是一个廉价的处理器，旨在为嵌入式设备提供分支预测和推测执行，但没有失序执行。
• **Ingenic JZ4780 dual-core MIPS32r2 **处理器，每个内核有 32kB 的 L1 数据缓存和 512kB 的 L2 共享数据缓存。这是一个用于嵌入式设备带指令流水的处理器，有一个简单的分支预测器。根据技术规范，分支预测错误的惩罚约为3个周期。

int count_bigger_than_limit_regular(int* array, int n, int limit) { int limit_cnt = 0; for (int i = 0; i < n; i++) { if (array[i] > limit) { limit_cnt++; } } return limit_cnt; }

int count_bigger_than_limit_branchless(int* array, int n, int limit) { int limit_cnt[] = { 0, 0 }; for (int i = 0; i < n; i++) { limit_cnt[array[i] > limit]++; } return limit_cnt[1]; } int count_bigger_than_limit_arithmetic(int* array, int n, int limit) { int limit_cnt = 0; for (int i = 0; i < n; i++) { limit_cnt += (array[i] > limit); } return limit_cnt; } int count_bigger_than_limit_cmove(int* array, int n, int limit) { int limit_cnt = 0; int new_limit_cnt; for (int i = 0; i < n; i++) { new_limit_cnt = limit_cnt + 1; // The following line is pseudo C++, originally it is written in inline assembly limit_cnt = conditional_load_if(array[i] > limit, new_limit_cnt); } return limit_cnt; }

• count_bigger_than_limit_branchless 在(如上文其他一些避免分支的技巧) 内部使用一个小的两元素数组来计算当数组中的元素大于和小于 limit 时的情况。
• count_bigger_than_limit_arithmetic利用表达式（array[i] > limit）只能有 0 或 1 的值这一事实，用表达式的值来增加计数器。
• count_bigger_than_limit_cmove计算新值，然后使用条件移动来加载它，如果条件为真。我们使用内联汇编来确保编译器会发出 cmov 指令。

int count_bigger_than_limit_joint_simple(int* array, int n, int limit) { int limit_cnt = 0; for (int i = 0; i < n/2; i+=2) { // The two conditions in this if can be joined with & or && if (array[i] > limit && array[i + 1] > limit) { limit_cnt++; } } return limit_cnt; }

int binary_search(int* array, int number_of_elements, int key) { int low = 0, high = number_of_elements-1, mid; while(low <= high) { mid = (low + high)/2; if (array[mid] == key) { return mid; } if(array[mid] < key) { low = mid + 1; } else { high = mid-1; } } return -1; }

// Conditional move implementation int new_low = low + 1; int new_high = high - 1; bool condition = array[mid] > key; // The bellow two lines are pseudo C++, the actual code is written in assembler low = conditional_move_if(new_low, condition); high = conditional_move_if_not(new_high, condition); // Arithmetic implementation int new_low = mid + 1; int new_high = mid - 1; int condition = array[mid] < key; int condition_true_mask = -condition; int condition_false_mask = -(1 - condition); low += condition_true_mask & (new_low - low); high += condition_false_mask & (new_high - high);

• 处理器中的资源数量是有限的。例如，一个典型的高端处理器可能同时处理四条简单的算术指令、两条加载指令、两条存储指令或一条复杂的算术指令。当指令执行完毕后（技术术语是指令retire），资源变得可用，因此处理器可以处理新指令。
• 指令之间存在着数据依赖性。如果当前指令的输入参数依赖于前一条指令的结果，那么在前一条指令完成之前，当前指令不能被处理。它被卡在处理器中占用资源，阻止其他指令进入。

element = load(base_address = array, index = mid) if_not (element < key) goto ELSE low = mid + 1 goto ENDIF ELSE: high = mid - 1 ENDIF: // These are the instructions at the beginning of the next loop mid = low + high mid = mid / 2

element = load(base_address = array, index = mid) load_low =element < key new_low = mid + 1 new_high = mid - 1 low = move_if(condition = load_low, value = https://www.it610.com/article/new_low) high = move_if_not(condition = load_low, value = new_high) // These are the instructions at the beginning of the next loop mid = low + high mid = mid / 2

MISSPREDICTION_PENALTY = 15 cycles INSTRUCTIONS_NEEDED_TO_EXECUTE_DUE_MISSPREDICTION = 50 cyclesRUNTIME = (RUNTIME_PREDICTION_CORRECT + RUNTIME_PREDICTION_NOTCORRECT) / 2 RUNTIME_PREDICTION_CORRECT = 300 cycles RUNTIME_PREDICTION_NOTCORRECT = 300 cycles + MISSPREDICTION_PENALTY + INSTRUCTIONS_NEEDED_TO_EXECUTE_DUE_MISSPREDICTION = 365 cyclesRUNTIME = 332.5 cycles

INSTRUCTIONS_BLOCKED_WAITING_FOR_DATA = https://www.it610.com/article/50 cyclesRUNTIME = 300 cycles + INSTRUCTIONS_BLOCKED_WAITING_FOR_DATA = 350 cycles

推荐阅读

• 

  社保需要交多少年才可以领养老金?养老金是怎么算的
• 

  人造棉是棉绸吗
• 

  教你如何开挂，教你如何自己做挂不用担心被抓
• 

  老竹大方茶的产地及品质特征介绍
• 

  八小时工作制最早出现在哪个国家
• 

  故事里的人——石神与石泓
• 

  家里的小猫得了猫藓,医生照了一下说很严重开了八百多块钱药,请问这个花费正常吗,以后还要花多少钱？
• 

  锦鲤花养殖注意事项 锦鲤水花养殖注意事项
• 

  抖音朋友圈射箭穿心表白图制作教程
• 

  外用药能否治疗早泄 早泄的外用药
• 

  佳能5d拍摄技巧 佳能5ds拍体育
• 

  让龙猫亲近自己的方法有吗
• 

  重庆被起诉了但是实在没有钱还怎么办
• 

  科目4多少分才算合格
• 

  笔记|多线程基础
• 

  用户|为什么iQOO Z3能不让用户做“取舍”？
• 

  FGO情人节三期高难本怎么打 2019女帝情人节高难本攻略
• 

  一辈子闺蜜经典句子有哪些
• 

  大金空调制冷外机不工作怎么办,一般情况就放置在这个位置
• 

  如何搭建直播电商平台，如何做好电商直播平台

• 为什么我建议线上高并发量的日志输出的时候不能带有代码位置
• python制作词云图代码_Python基于WordCloud制作词云图
• Python|【Turtle系列】端正心态正确面对疫情，守护安全防线不放松，共抗疫情，只待春来~
• java|对数器验证算法正确性----bug寻找，文章中含有测试源码
• Python|【Opencv实战】这是我见过的最强大“美颜滤镜”，代码美颜傻瓜式一键操作~（附源码）
• java|java builder模式构建一个对象
• 【仿真】Carla之收集数据快速教程|【仿真】Carla之收集数据快速教程 (附完整代码) [7]
• 靠跳槽3年从7K涨到22K（！那些越跳槽越值钱的人，都做对了什么？）
• 编程语言|宁愿“大小周”、每天只写 200 行代码、月薪 8k-17k 人群再涨！揭晓中国开发者真实现状...
• 腾讯员工平均年薪84万，码农一个月赚7万；每写1行代码能赚19块，公司每天赚9.5亿...