C++ performance challenge: integer to std::string conversion

 

Can anyone beat the performance of my integer to std::string code, linked below?

There are already several questions that explain how to convert an integer into a std::string in C++, such as this one, but none of the solutions provided are efficient.

Here is compile-ready code for some common methods to compete against:

  • The "C++ way", using stringstream: http://ideone.com/jh3Sa
  • sprintf, which SO-ers usually recommend to the performance conscious: http://ideone.com/82kwR

    • Contrary to popular belief, boost::lexical_cast has its own implementation (white paper) and does not use stringstream and numeric insertion operators. I'd really like to see its performance compared, because this other question suggests that it's miserable.

    And my own contribution, which is competitive on desktop computers, and demonstrates an approach that runs at full speed on embedded systems as well, unlike algorithms dependent on integer modulo:

  • Ben's algorithms: http://ideone.com/SsEUW

    • If you want to use that code, I'll make it available under a simplified BSD license (commercial use allowed, attribution required). Just ask.

    Finally, the function ltoa is non-standard but widely available.

  • ltoa version, for anyone who has a compiler that provides it (ideone doesn't): http://ideone.com/T5Wim

    • I'll post my performance measurements as an answer shortly.

    Rules for algorithms

  • Provide code for a conversion of at least 32-bit signed and unsigned integers into decimal.
  • Produce output as a std::string .
  • No tricks that are incompatible with threading and signals (for example, static buffers).
  • You may assume an ASCII character set.
  • Make sure to test your code on INT_MIN on a two's complement machine where the absolute value is not representable.
  • Ideally, the output should be character-for-character identical with the canonical C++ version using stringstream , http://ideone.com/jh3Sa, but anything that is clearly understandable as the correct number is ok, too.
  • NEW : Although you can use whatever compiler and optimizer options (except completely disabled) you want for the comparison, the code needs to also compile and give correct results under at least VC++ 2010 and g++.

    • Hoped-for Discussion

    Besides better algorithms, I'd also like to get some benchmarks on several different platforms and compilers (let's use MB/s throughput as our standard unit of measure). I believe that the code for my algorithm (I know the sprintf benchmark takes some shortcuts -- now fixed) is well-defined behavior by the standard, at least under the ASCII assumption, but if you see any undefined behavior or inputs for which the output is invalid, please point that out.

    Conclusions:

    Different algorithms perform for g++ and VC2010, likely due to the different implementations of std::string on each. VC2010 clearly does a better job with NRVO, getting rid of return-by-value helped only on gcc.

    Code was found that outperforms sprintf by an order of magnitude. ostringstream falls behind by a factor of 50 and more.

    The winner of the challenge is user434507 who produces code that runs 350% of the speed of my own on gcc. Further entries are closed due to the whims of the SO community.

    The current (final?) speed champions are:

  • For gcc: user434507, at 8 times faster than sprintf : http://ideone.com/0uhhX
  • For Visual C++: Timo, at 15 times faster than sprintf : http://ideone.com/VpKO3 
    • #include <string>

const char digit_pairs[201] = {
  "00010203040506070809"
  "10111213141516171819"
  "20212223242526272829"
  "30313233343536373839"
  "40414243444546474849"
  "50515253545556575859"
  "60616263646566676869"
  "70717273747576777879"
  "80818283848586878889"
  "90919293949596979899"
};


std::string& itostr(int n, std::string& s)
{
    if(n==0)
    {
        s="0";
        return s;
    }

    int sign = -(n<0);
    unsigned int val = (n^sign)-sign;

    int size;
    if(val>=10000)
    {
        if(val>=10000000)
        {
            if(val>=1000000000)
                size=10;
            else if(val>=100000000)
                size=9;
            else 
                size=8;
        }
        else
        {
            if(val>=1000000)
                size=7;
            else if(val>=100000)
                size=6;
            else
                size=5;
        }
    }
    else 
    {
        if(val>=100)
        {
            if(val>=1000)
                size=4;
            else
                size=3;
        }
        else
        {
            if(val>=10)
                size=2;
            else
                size=1;
        }
    }
    size -= sign;
    s.resize(size);
    char* c = &s[0];
    if(sign)
        *c='-';

    c += size-1;
    while(val>=100)
    {
       int pos = val % 100;
       val /= 100%ȍ
                        链接地址: http://www.djcxy.com/p/20962.html
                        
    上一篇:
                            
                                字符串不是std的成员，说g ++（mingw）                            
                            
                        
    
                        
    下一篇:
                            
                                C ++性能挑战：整数到std :: string的转换