在数组中找到两个最小int64元素的最快方法

Question

I have arrays with sizes from 1000 to 10000 (1k .. 10k). Each element is int64. My task is to find two smallest elements of the arrays, the minimum element and the minimum from the remaining.

I want to get fastest possible single-threaded code in C++ for Intel Core2 or Corei7 (cpu mode is 64 bit).

This function (getting the 2 smallest from array) is the hotspot, it is nested in two or three for loops with huge iteration count.

Current code is like:

int f()
{
    int best; // index of the minimum element
    int64 min_cost = 1LL << 61;
    int64 second_min_cost = 1LL << 62;
    for (int i = 1; i < width; i++) {
     int64 cost = get_ith_element_from_array(i); // it is inlined
     if (cost < min_cost) {
        best = i;
        second_min_cost = min_cost;
        min_cost = cost;
     } else if (cost < second_min_cost) {
        second_min_cost = cost;
     }
    }
    save_min_and_next(min_cost, best, second_min_cost);
}

Answer 1

Look at partial_sort and nth_element

std::vector<int64_t> arr(10000); // large

std::partial_sort(arr.begin(), arr.begin()+2, arr.end());
// arr[0] and arr[1] are minimum two values

If you only wanted the second lowest value, nth_element is your guy

Answer 2

Try inverting the if:

if (cost < second_min_cost) 
{ 
    if (cost < min_cost) 
    { 
    } 
    else
    {
    }
} 

And you should probably initialize min_cost and second_min_cost with the same value, using the max value of int64 (or even better use the suggestion of qbert220)

Answer 3

Some small things (which may be happening already, but may be worth trying I guess).

1. Unroll the loop slightly - say for example iterate in strides of 8 (ie cache line at a time), pre-fetch the next cache line in the body, then process the 8 items. To avoid lots of checks, ensure the end condition is a multiple of 8, and the left over items (less than 8) should be processed outside of the loop - unrolled...

2. For the items of no interest, you are doing two checks in the body, may be you can trim to 1? ie if the cost is less than second_min , then check min as well - else no need to bother...

Answer 4

You'd better check second_min_cost first, since it is the only condition which requires to modify the result. This way, you'll get one branch, instead of 2, into your main loop. This should help quite a bit.

Other than that, there is very little to optimise, your are already close to optimal. Unrolling may help, but i doubt it will bring any significant advantage in this scenario.

So, it becomes :

int f()
{
    int best; // index of the minimum element
    int64 min_cost = 1LL << 61;
    int64 second_min_cost = 1LL << 62;
    for (int i = 1; i < width; i++) {
    int64 cost = get_ith_element_from_array(i); // it is inlined
    if (cost < second_min_cost)
    {
      if (cost < min_cost) 
      {
        best = i;
        second_min_cost = min_cost;
        min_cost = cost;
      } 
      else second_min_cost = cost;
    }
    save_min_and_next(min_cost, best, second_min_cost);
}

Answer 5

What you have there, is O(n) and optimal for random data. That means, you already have the fastest.

The only way you can improve this is by giving certain properties to your array, for example, keeping it sorted at all times or by making it a heap.

Answer 6

The good point is that your algorithm scans the numbers once. You're optimal.

An important source of slowness could come from the way your elements are arranged. If they are in an array, I mean a C array (or C++ vector) where all the elements are contiguous and you scan them forward, then memory-wise you're optimal too. Otherwise, you could have some surprises. For instance, if your elements are in a linked list, or scatter gathered, then you can have penalty for memory accesses.

Answer 7

Make sure your array-reading is will-behaved so it doesn't introduce needless cache-misses.

This code should probably be very close to bandwidth-bound on modern CPU:s, assuming the array-reading is simple. You need to profile and/or calculate if it still seems to have any headroom for CPU optimizations.