In this post I’m going to discuss again the string benchmark I did before to find out what is the fastest way to iterate over an
std::string. If you haven’t read the previous post on this subject go a head and read it as it covers the basic idea behind this benchmark. As I did the last time I did the benchmark, I check 5 ways of iteration:
- Iterating using the native indexes.
- Iterating using the
- Iterating using indexes over the C string representation of the string.
- Iterating using pointers over the C string representation of the string.
- Iterating using the STL iterators.
The basic operation that tests the performance of each kind of iteration hasn’t been changed, and as in the last benchmark I used a test string of 50,000,000 characters. Instead I’ve altered the timing mechanism. In the first test, each one of the iteration methods had it’s one executable and the performance was timed as the execution time timed by the
time command for each executable, this methods has a problematic overhead in the form of the time it takes to load to memory each one of the 50MB binaries. In this test I’ve fixed this problem and now the tests timed using
clock_gettime. This allowed me to preform all tests from within the same executable and without the overhead of the actual loading time. As a bonus the timer in
clock_gettime has much higher resolution, so the results should be much more accurate.
To preform the test download the benchmark’s source code – stringbenchmark2.tar.gz. After you download it go to the directory where you saved the archive and execute
tar -zxvf stringbenchmark2.tar.gz
The last command is the actual benchmark. It will ran each of the tests and print its timing in the format of seconds:nanoseconds. For example a typical output of the benchmark on my system looks like this:
String iteration benchmark String length: 50000000 iteration using indexes 0:588484755 iteration using indexes over C string 0:617691596 iteration using string::at() 0:615612772 iteration using pointers over C string 0:515342342 iteration using iterators 2:166078723
As you can see the results (in the relative speeds between the iteration methods) remained the same as in the last benchmark. Iterating using pointers over the C string representation is the fastest method by a small margin and using iterators is the slowest by far. This time the results are much more accurate and the difference between closely performing methods such as
string::at and using index over the C string repesentation is easily noticeable.