Why is string to number conversion so slow in C++? - c++

Question

This function reads an array of doubles from a string:
vector<double> parseVals(string& str) {
stringstream ss(str);
vector<double> vals;
double val;
while (ss >> val) vals.push_back(val);
return vals;
}
When called with a string containing 1 million numbers, the function takes 7.8 seconds to execute (Core i5, 3.3GHz). This means that 25000 CPU cycles are spent to parse ONE NUMBER.
user315052 has pointed out that the same code runs an order of magnitude faster on his system, and further testing has shown very large performance differences among different systems and compilers (also see user315052's answer):
1. Win7, Visual Studio 2012RC or Intel C++ 2013 beta: 7.8 sec
2. Win7, mingw / g++ 4.5.2 : 4 sec
3. Win7, Visual Studio 2010 : 0.94 sec
4. Ubuntu 12.04, g++ 4.7 : 0.65 sec
I have found a great alternative in the Boost/Spirit library. The code is safe, concise and extremely fast (0.06 seconds on VC2012, 130x faster than stringstream).
#include <boost/spirit/include/qi.hpp>
namespace qi = boost::spirit::qi;
namespace ascii = boost::spirit::ascii;
vector<double> parseVals4(string& str) {
vector<double> vals;
qi::phrase_parse(str.begin(), str.end(),
*qi::double_ >> qi::eoi, ascii::space, vals);
return vals;
}
Although this solves the problem from the practical standpoint, i would still like to know why the performance of stringstream is so inconsistent. I profiled the program to identify the bottleneck, but the STL code looks like gibberish to me. Comments from anybody familiar with STL internals would be much appreciated.
PS: Optimization is O2 or better in all of the above timings. Neither instantiation of stringstream nor the reallocation of vector figure in the program profile. Virtually all of the time is spent inside the extraction operator.

Answer 1

On my Linux VM running on a 1.6 GHz i7, it takes less than half a second. My conclusion is that the parsing is not as slow as you are observing it to be. There must be some other artifact that you are measuring to cause your observation to be so vastly different from mine. So that we can be more sure we are comparing apples to apples, I'll provide what I did.
Edit: On my Linux system, I have g++ 4.6.3, compiled with -O3. Since I don't have MS or Intel compilers, I used cygwin g++ 4.5.3, also compiled with -O3. On Linux, I got the following output: Another fact is my Windows 7 is 64 bit, as is my Linux VM. I believe cygwin only runs in 32 bit mode.
elapsed: 0.46 stringstream
elapsed: 0.11 strtod
On cygwin, I got the following:
elapsed: 1.685 stringstream
elapsed: 0.171 strtod
I speculate that the difference between cygwin and Linux performance has something to do with MS library dependencies. Note that the cygwin environment is just on the host machine of the Linux VM.
This is the routine I timed that used istringstream.
std::vector<double> parseVals (std::string &s) {
std::istringstream ss(s);
std::vector<double> vals;
vals.reserve(1000000);
double val;
while (ss >> val) vals.push_back(val);
return vals;
}
This is the routine I timed that used strtod.
std::vector<double> parseVals2 (char *s) {
char *p = 0;
std::vector<double> vals;
vals.reserve(1000000);
do {
double val = strtod(s, &p);
if (s == p) break;
vals.push_back(val);
s = p+1;
} while (*p);
return vals;
}
This is the routine I used to populate the string with one million doubles.
std::string one_million_doubles () {
std::ostringstream oss;
double x = RAND_MAX/(1.0 + rand()) + rand();
oss << x;
for (int i = 1; i < 1000000; ++i) {
x = RAND_MAX/(1.0 + rand()) + rand();
oss << " " << x;
}
return oss.str();
}
This is the routine I used to do the timing:
template <typename PARSE, typename S>
void time_parse (PARSE p, S s, const char *m) {
struct tms start;
struct tms finish;
long ticks_per_second;
std::vector<double> vals_vec;
times(&start);
vals_vec = p(s);
times(&finish);
assert(vals_vec.size() == 1000000);
ticks_per_second = sysconf(_SC_CLK_TCK);
std::cout << "elapsed: "
<< ((finish.tms_utime - start.tms_utime
+ finish.tms_stime - start.tms_stime)
/ (1.0 * ticks_per_second))
<< " " << m << std::endl;
}
And, this was the main function:
int main ()
{
std::string vals_str;
vals_str = one_million_doubles();
std::vector<char> s(vals_str.begin(), vals_str.end());
time_parse(parseVals, vals_str, "stringstream");
time_parse(parseVals2, &s[0], "strtod");
}

Answer 2

Your overhead is in both repeated instantiation of the std::stringstream and in the parsing itself. If your numbers are plain and not using any locale dependent formatting, then I suggest #include <cstdlib> and std::strtod().

Answer 3

Converting string to double is slow because your Corei5 CPU does not have that conversion operator built in.
While that CPU natively can convert a short to a float to an int at comparatively faster speeds, the conversion you describe must be done step-by-step, analyzing each character and deciding if it's part of the double and how.
What you're observing is representative of the actual work that needs to be done, considering that each double may look like -.0 or INF or 4E6 or -NAN. It may need to be truncated, it probably needs to be approximated and it may not be a valid double at all.

Answer 4

This is a pretty involved task for the parsing. To parse a double of has to match either a decimal or a floating point number then it has to extract this string and do the actual string conversion. This means that for each double in your string you are going over each double at least twice plus any other functionality that is done to get to the next double. The other part as mentioned is that a vector when it resizes is not the most efficient. But, it is just slow to parse and convert strings.

Answer 5

You construct a stringstream object every time you call that function, which is potentially very expensive.
However, we don't have enough information to answer your question. Are you compiling with optimizations turned on all the way? Is your function being inlined, or is there a function call with every invocation?
For a suggestion on how to speed things up, you should consider boost::lexical_cast<double>(str)