CODEWITHSUNDEEP
c++multithreading
CPP_NEW
CPP_NEW

Reputation: 197

threading program in C++ not faster

I have a program which reads the file line by line and then stores each possible substring of length 50 in a hash table along with its frequency. I tried to use threads in my program so that it will read 5 lines and then use five different threads to do the processing. The processing involves reading each substring of that line and putting them into hash map with frequency. But it seems there is something wrong which I could not figure out for which the program is not faster then the serial approach. Also, for large input file it is aborted. Here is the piece of code I am using

unordered_map<string, int> m;
mutex mtx;

    void parseLine(char *line, int subLen){
        int no_substr = strlen(line) - subLen;
        for(int i = 0; i <= no_substr; i++) {
            char *subStr = (char*) malloc(sizeof(char)* subLen + 1);
            strncpy(subStr, line+i, subLen);
            subStr[subLen]='\0';
            mtx.lock();
            string s(subStr);
            if(m.find(s) != m.end()) m[s]++;
            else {
                  pair<string, int> ret(s, 1);
                  m.insert(ret);
            }
            mtx.unlock();    
        }
    }


    int main(){    

        char **Array = (char **) malloc(sizeof(char *) * num_thread +1); 
        int num = 0;

        while (NOT END OF FILE) {
            if(num < num_th) {
                 if(num == 0) 
                    for(int x = 0; x < num_th; x++) 
                       Array[x] = (char*) malloc(sizeof(char)*strlen(line)+1);
                 strcpy(Array[num], line);
                 num++;
              }
              else {
                 vector<thread> threads;
                 for(int i = 0; i < num_th; i++) {
                    threads.push_back(thread(parseLine, Array[i]);
                 }
                 for(int i = 0; i < num_th; i++){
                    if(threads[i].joinable()) {
                      threads[i].join();
                    }
                 }
                 for(int x = 0; x < num_th; x++) free(seqArray[x]);
                 num = 0;
              }
            } 
    }

Upvotes: 0

Views: 876

Answers (1)

Sam Varshavchik
Sam Varshavchik

Reputation: 118292

It's a myth that just by the virtue of using threads, the end result must be faster. In general, in order to take advantage of multithreading, two conditions must be met(*):

1) You actually have to have sufficient physical CPU cores, that can run the threads at the same time.

2) The threads have independent tasks to do, that they can do on their own.

From a cursory examination of the shown code, it seems to fail on the second part. It seems to me that, most of the time all of these threads will be fighting each other in order to acquire the same mutex. There's little to be gained from multithreading, in this situation.

(*) Of course, you don't always use threads for purely performance reasons. Multithreading also comes in useful in many other situations too, for example, in a program with a GUI, having a separate thread updating the GUI helps the UI working even while the main execution thread is chewing on something, for a while...

Upvotes: 3

Related Questions