Loop vs Double IF statement - performance

Question

What would be more efficient:
For i = 0 to 2
if x[i] == y[i] then do something
//or
if x[0] == y[0] do something
if x[1] == y[1] do something
If I am only doing it twice. Also, ignore the readability.

Answer 1

What would be more efficient:
I think there will be absolutely no difference between the two as your for loop is just from 0 to 2 so you may prefer which ever if more readable to you. However if you for loop is huge(ie, index is very large) then I would recommend to use for loop as it would be more readable.
Also, ignore the readability.
I would not recommend that as it is always advisable to all the programmers to write the code which is more readable for oneself and also for others.

Answer 2

It depends. That's almost always the answer to these things.
There will be several effects at play here.
Firstly, having a loop (ie actually a loop in the machine code, the high level source is really irrelevant except that it may influence the machine code, a loop by 2 has an extremely high chance of being unrolled by a compiler) clearly executes more branches in total, and while a correctly predicted branch usually has no latency, they typically do have a limited throughput.
Secondly, having two distinct branches means that distinct branch prediction histories can be attached to them. That can improve their predictability, particularly if the patterns taken separately both fit in a branch history buffer, but taken together the aggregate pattern is too long to fit. That's very machine dependent, does not happen on all microarchitectures, and very rare in any case since it requires predictable patterns of behaviour of a carefully balanced "long enough but not too long" length.
Thirdly, unrolling that loop likely leads to more code (unless of course the loop overhead is more than the loop body). That puts more pressure on the code cache and the decoders. This effect, unlike the first two, favours the loop.
Lastly, all of these effects are small. In the presence of just about anything else (such as cache misses), they're likely to completely disappear in the noise.

Answer 3

This isn't exactly the same question but I had been wondering what the performance benefit is between doing more work within the same loop and iterating over the set twice. I assumed that was that it would be faster to loop once but I wasn't sure how much or if optimization would equal them out at all.
I finally did a simple test and as you would expect, more work in the same loop is a bit faster.
The test was pretty simple and was done in Swift 3.1 and run with optimization ON:
let itr = 10000000
let passes = 10
print("Running \(itr) iterations through \(passes) passes")
for run in 0..<passes {
print("---------")
var time = CFAbsoluteTimeGetCurrent()
var val1 = 0
for i in 0..<itr {
val1 += i
}
for i in 0..<itr {
val1 += i
}
let t1 = CFAbsoluteTimeGetCurrent() - time
print("\(run).1 - \(val1) -- \(t1)")
time = CFAbsoluteTimeGetCurrent()
var val2 = 0
for i in 0..<itr {
val2 += i
val2 += i
}
let t2 = CFAbsoluteTimeGetCurrent() - time
print("\(run).2 - \(val2) -- \(t2)")
}
And the results:
Running 10000000 iterations through 10 passes
---------
0.1 - 99999990000000 -- 0.127476990222931
0.2 - 99999990000000 -- 0.0763950347900391
---------
1.1 - 99999990000000 -- 0.121748030185699
1.2 - 99999990000000 -- 0.0743749737739563
---------
2.1 - 99999990000000 -- 0.123345971107483
2.2 - 99999990000000 -- 0.0756909847259521
---------
3.1 - 99999990000000 -- 0.11965000629425
3.2 - 99999990000000 -- 0.0711749792098999
---------
4.1 - 99999990000000 -- 0.117263972759247
4.2 - 99999990000000 -- 0.0712859630584717
---------
5.1 - 99999990000000 -- 0.116972029209137
5.2 - 99999990000000 -- 0.0708900094032288
---------
6.1 - 99999990000000 -- 0.121819019317627
6.2 - 99999990000000 -- 0.0748890042304993
---------
7.1 - 99999990000000 -- 0.124098002910614
7.2 - 99999990000000 -- 0.0734890103340149
---------
8.1 - 99999990000000 -- 0.122666001319885
8.2 - 99999990000000 -- 0.07710200548172
---------
9.1 - 99999990000000 -- 0.121197044849396
9.2 - 99999990000000 -- 0.0715969800949097