why ostringstream could not work well in multithreading environment

Question

Maybe something is weird. When I use STL ostringstream class in my multithreading environment I found that the execution time of each thread increased linearly as the thread number increased. I don't know why this happened. I try to check the ostringstream source code but could not find any synchronization code. Are there some synchronization place in ostringsstream? I replace ostringsstream with snprintf and the preformance increase largely. My OS is RHEL5.4 64BIT and my server has two xeon 5620 cpu on it.

The following is the running result I use 1 and 8 thread separately with 1000000 loops. the left column is threadid and the right is running time. So it's apparant the per thread running time increase as the thread number increase.

[host]$./multi_thread  1 1000000
1115760960:0.240113
[host]$./multi_thread  8 1000000
1105004864:8.17012
1115494720:8.22645
1125984576:8.22931
1136474432:8.41319
1094252864:8.73788
1167944000:8.74504
1157454144:8.74951
1146964288:8.75174

the code is list as below

#include <iostream>
#include <sstream>
using namespace std;

void * func(void * t)
{
        int n = *((int *) t);
        pthread_t pid = pthread_self();
        timeval t1, t2;
        gettimeofday(&t1, 0);
        for(int i = 0; i < n; i++)
        {
                ostringstream os;
                /*
                   char buf[255];
                   int ret = snprintf(buf, 30, "%d", 2000000);
                   buf[ret] = 0;
                 */
        }
        gettimeofday(&t2, 0);
#define DIFF(a, b) ((b.tv_sec - a.tv_sec) + (b.tv_usec - a.tv_usec) / 1000000.0)
        std::cout << pid << ":" << DIFF(t1, t2) << std::endl;
#undef DIFF

        return NULL;
}

int main(int argc, char *argv[])
{
        int m, n =0;
        m = atoi(argv[1]);
        n = atoi(argv[2]);
        pthread_t tid[m];
        for(int i = 0; i < m; i++)
                pthread_create(&tid[i], NULL, func, &n);
        for(int i = 0; i < m; i++)
                pthread_join(tid[i], NULL);
        return 0;
}

Answer 1

It seems to be a known problem. Here is a solution for MSVC: linking statically. Perhaps this will also work on linux.

ALternatively (suggested for Sun Studio here), make the streams thread local (instead of process local) to prevent them from being locked by each thread as the other accesses them.

Answer 2

Ostringstream allocates memory on the heap. May be the OS dynamic allocation is protected by a Mutex?