将矢量更改为数组会使我的程序变慢

Question

I profiled a program of mine and found out that the very hotspot was levenshtein_distance , called recursively. I decided to try and optimize it.

lvh_distance levenshtein_distance( const std::string & s1, const std::string & s2 )
{
    const size_t len1 = s1.size(), len2 = s2.size();
    std::vector<unsigned int> col( len2+1 ), prevCol( len2+1 );

    const size_t prevColSize = prevCol.size();
    for( unsigned int i = 0; i < prevColSize; i++ )
        prevCol[i] = i;

    for( unsigned int i = 0, j; i < len1; ++i )
    {
        col[0] = i+1;
        const char s1i = s1[i];
        for( j = 0; j < len2; ++j )
        {
            const auto minPrev = 1 + std::min( col[j], prevCol[1 + j] );
            col[j+1] = std::min( minPrev, prevCol[j] + ( static_cast<unsigned int>( s1i != s2[j] ) ) );
        }
        col.swap( prevCol );
    }
    return prevCol[len2];
}

TL;DR: I changed std::string → std::array

War Story: And after running vtune on it, I found that the line that updates col[j+1] was the one slowing down everything (90% of the time spent on it). I thought: OK, maybe this is an aliasing problem, maybe the compiler cannot determine that the character arrays within the string objects are unaliased as they are masked by the string interface and spends 90% of his time checking that no other part of the program modified them.

So I changed my string into a static array, because there, there is no dynamic memory, and the next step would have been using restrict to help the compiler. But in the meantime, I decided to check if I had gained any performance by doing so.

lvh_distance levenshtein_distance( const std::string & s1, const std::string & s2 )
{
    const size_t len1 = s1.size(), len2 = s2.size();
    static constexpr unsigned MAX_STRING_SIZE = 512;
    assert(len1 < MAX_STRING_SIZE && len2 < MAX_STRING_SIZE);
    static std::array<unsigned int, MAX_STRING_SIZE> col, prevCol;

    for( unsigned int i = 0; i < len2+1; ++i )
        prevCol[i] = i;

    // the rest is unchanged
}

TL;DR : now it runs slow.

What happened is that I lost performance. A lot. Instead of running in ~ 6 seconds, my sample program now runs in 44 seconds. Using vtune to profile again shows that a function is called over and over again: std::swap (for you, gcc folks, this is in bits/move.h), which is in turn called by std::swap_ranges (bits/stl_algobase.h).

I suppose that std::min is implemented using quicksort , which explains why there is swapping around, but I don't understand why swapping, in that case, takes so much time.

EDIT : Compiler options: I am using gcc with options "-O2 -g -DNDEBUG" and a bunch of warning specifiers.

Answer 1

For an experiment I ran a version of your original code largely unmodified with a pair of short strings an got timings of ~36s for the array version and ~8s for the vector version.

Your version seems to depend very much on the choice of MAX_STRING_SIZE . When I used 50 instead of 512 (which just fitted my strings), the timing for the array version went down to about 16s.

I then performed this by-hand translation of your main loop to get rid of the explicit swap. This further reduced the time of the array version to 11s, and more interestingly, now made the array version timing independent of the choice of MAX_STRING_SIZE . When putting it back to 512, the array version still took 11s.

This is good evidence that the explicit swap of the arrays is where the bulk of the perfomance issue with your version was.

There is a still a significant difference between the array and the vector version with the array version talking around 40% longer. I haven't had a chance to investigate exactly why this might be.

for( unsigned int i = 0, j; i < len1; ++i )
{
    {
        col[0] = i+1;
        const char s1i = s1[i];
        for( j = 0; j < len2; ++j )
        {
            const auto minPrev = 1 + std::min( col[j], prevCol[1 + j] );
            col[j+1] = std::min( minPrev, prevCol[j] + ( static_cast<unsigned int>( s1i != s2[j] ) ) );
        }
    }

    if (!(++i < len1))
        return col[len2];

    {
        prevCol[0] = i+1;
        const char s1i = s1[i];
        for( j = 0; j < len2; ++j )
        {
            const auto minPrev = 1 + std::min( prevCol[j], col[1 + j] );
            prevCol[j+1] = std::min( minPrev, col[j] + ( static_cast<unsigned int>( s1i != s2[j] ) ) );
        }
    }
}
return prevCol[len2];

Answer 2

First off: @DanielFischer has already in all probability pointed out what caused your performance degradation: Swapping std::arrays is a linear time operation, while swapping std::vector is a constant time operation. While some compilers may be able to optimize this away, your gcc seems unable to do so.

Also important: Utilizing a static array like you did here makes your code inherently not threadsafe. It is usually not a good idea.

Removing one of the arrays (or vectors) and the associated swap and using a dynamically allocated c-array is actually pretty easy and results in superior performance (at least for my setup).
A few more transformations (like consistently using size_t ) results in the following function:

unsigned int levenshtein_distance3( const std::string & s1, const std::string & s2 )
{
    const size_t len1 = s1.size(), len2 = s2.size();
    ::std::unique_ptr<size_t[]> col(new size_t[len2 + 1]);

    for(size_t i = 0; i < len2+1; ++i )
        col[i] = i;

    for(size_t i = 0; i < len1; ++i )
    {
        size_t lastc = col[0];
        col[0] = i+1;
        const char s1i = s1[i];
        for(size_t j = 0; j < len2; ++j )
        {
            const auto minPrev = 1 + (::std::min)(col[j], col[j + 1]);
            const auto newc = (::std::min)(minPrev, lastc + (s1i != s2[j] ? 1 : 0));
            lastc = col[j+1];
            col[j + 1] = newc;
        }
    }
    return col[len2];
}