Question

i came across an interview question which asks

while searching a value in an array using 2 perallel threads
which method would be more efficent

(1) read each half of the array on a different thread (spliting it in half)
(2) reading the array on odd and even places (a thread which reads the odd places
and one which reads the even places in the array ).

i don’t understand why one would be more efficent then the other
appricate it if someone would clearify this for me
thanks in advance.

Answer 1

Splitting the array in half is almost certainly the way to go. It will almost never be slower, and may be substantially faster.

The reason is fairly simple: when you’re reading data from memory, the processor will normally read an entire cache line at a time. The exact size varies between processors, but doesn’t matter a whole lot (though, in case you care, something like 64 bytes would be in the ballpark) — the point is that it reads a contiguous chunk of several bytes at a time.

That means with the odd/even version, both processors running both threads will have to read all the data. By splitting the data in half, each core will read only half the data. If your split doesn’t happen to be at a cache line boundary, each will read a little extra (what it needs rounded up to the size of a cache line). On average that will add half a cache line to what each needs to read though.

If the “processors” involved are really two cores on the same processor die, chances are that it won’t make a whole lot of difference either way though. In this case, the bottleneck will normally be reading the data from main memory into the lowest-level processor cache. Even with only one thread, you’ll (probably) be able to search through the data as fast as you can read it from memory, and adding more threads (no matter how you arrange their use of the data) isn’t going to improve things much (if at all).