branch-prediction

There are some queries about branch prediction that I am not able to confidently figure out.Assume that I have to work with a static branch predictor. At which stage of the pipeline should branch prediction happen? How to know that a prediction has gone wrong? How does the datapath come to know that a misprediction has happened? If it comes to know that a misprediction has happened, how does it send the signal to take up the not-taken branch? After it has gone wrong, I have to take up that address that was not taken earlier. In the meanwhile, what if some memory-write or register-write has

I have done some reading about Spectre v2 and obviously you get the non technical explanations. Peter Cordes has a more in-depth explanation but it doesn't fully address a few details. Note: I have never performed a Spectre v2 attack so I do not have hands on experience. I have only read up about about the theory. My understanding of Spectre v2 is that you make an indirect branch mispredict for instance if (input < data.size) . If the Indirect Target Array (which I'm not too sure of the details of -- i.e. why it is separate from the BTB structure) -- which is rechecked at decode for RIPs of

When talking about the performance of ifs, we usually talk about how mispredictions can stall the pipeline. The recommended solutions I see are: Trust the branch predictor for conditions that usually have one result; or Avoid branching with a little bit of bit-magic if reasonably possible; or Conditional moves where possible. What I couldn't find was whether or not we can calculate the condition early to help where possible. So, instead of: ... work if (a > b) { ... more work } Do something like this: bool aGreaterThanB = a > b; ... work if (aGreaterThanB) { ... more work } Could something

Have I understood this right, if statements are more dependent on branch prediction and v-table look-up is more dependent on branch target prediction? Regarding v-tables, there is no "branch prediction", just the target prediction? Trying to understand how a v-table is processed by the CPU. Branch prediction is predicting whether or not the branch will be taken . Branch target prediction is prediction where the branch is going to. These two things are independent and can occur in all combinations. Examples of these might be: Unconditional branch, fixed target Infinite loop goto statement break

EDIT: My confusion arises because surely by predicting which branch is taken, you are effectively doing the target prediction too?? This question is intrinsically linked to my first question on the topic: branch prediction vs branch target prediction Looking at the accepted answer: Unconditional branch, fixed target Infinite loop goto statement break or continue statement End of the 'then' clause of an if/else statement (to jump past the else clause) Non-virtual function call Unconditional branch, variable target Returning from a function Virtual function call Function pointer call switch

I'm reading around that branch misprediction can be a hot bottleneck for the performance of an application. As I can see, people often show assembly code that unveil the problem and state that programmers usually can predict where a branch could go the most of the times and avoid branch mispredictons. My questions are: 1- Is it possible to avoid branch mispredictions using some high level programming technique (i.e. no assembly )? 2- What should I keep in mind to produce branch-friendly code in a high level programming language (I'm mostly interested in C and C++)? Code examples and benchmarks

Related to this answer: https://stackoverflow.com/a/11227902/4714970 In the above answer, it's mentioned how you can avoid branch prediction fails by avoiding branches. The user demonstrates this by replacing: if (data[c] >= 128) { sum += data[c]; } With: int t = (data[c] - 128) >> 31; sum += ~t & data[c]; How are these two equivalent (for the specific data set, not strictly equivalent)? What are some general ways I can do similar things in similar situations? Would it always be by using >> and ~ ? Louis Wasserman int t = (data[c] - 128) >> 31; The trick here is that if data[c] >= 128 , then