Dual core word counter is slow - c

Question

I need to parse a huge document and one of the queries requires me to count the words in certain strings of the document. Those strings usually have between 2000 and 30000 words and my program takes ~12 seconds just to parse it all. The query that takes the longest is unsurprisingly the query which requires a word counting.
I tried using pipes and a fork to try accelerate the process.
How it works:
I take the string and divide it by two. If I happen to divide a word in two - if text[i] != ' ' etc - then the left side of the divided text keeps looking to the left until it encounters a space and only counts words until it reaches that space. The right side counts that half word as a full word and keeps counting until it reaches the end of the string. If I divide between spaces the cycle just doesn't happen and the program proceeds to the next step.
Edit: could be a space or a \n or a \t
After that I do a fork and communicate between forks through a pipe. What goes through the pipe is the word count of one of the halves of the text. It then is added to the word count of the other half and the total is returned.
The problem:
On a test code example, it doesn't seem to help at all. The execution time still seems to be the same as if I did it all in one go.
The big problem
This function is meant to be ran around 60000 times throughout the parsing. And my program takes too long to execute, in fact I had to cancel it after 2 minutes...
Where do I need help?
I need help in knowing exactly why is my function:
a) not even getting slightly faster with this supposedly dual core implementation compared to the single core one.
b) taking so long in the actual program
I hope this isn't a problem with C and forks/pipes are just too slow for what I want and I hope I just don't know something.
--
Here's the code!
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
long count(char* xStr) {
long num = 0;
// state:
const char* iterar = (const char*) xStr;
int in_palavra = 0;
do switch(*iterar) {
case '\0':
case ' ': case '\t': case '\n':
if (in_palavra) { in_palavra = 0; num++; }
break;
default: in_palavra = 1;
} while(*iterar++);
return num;
}
long wordCounter(char* text) {
int LHalf = strlen(text)/2;
int DHalf = LHalf;
while(text[LHalf] != ' ' && text[LHalf] != '\n' && text[LHalf] != '\t') {
if(LHalf > 0){
LHalf--;
}
else break;
}
char* lft = malloc(LHalf);
char* rgt = malloc(DHalf);
strncpy(lft, text, LHalf);
strncpy(rgt, text + DHalf, DHalf);
int fd[2];
pid_t childpid;
pipe(fd);
long size_left;
long size_right;
if((childpid = fork()) == -1) {
perror("Error in fork");
}
if(childpid == 0) {
close(fd[0]);
size_left = count(lft);
int w = write(fd[1], &size_left, sizeof(long));
close(fd[1]); //desnecessario
exit(0);
}
else {
close(fd[1]);
int r = read(fd[0], &size_left, sizeof(long));
size_right = count(rgt);
close(fd[0]);
wait(0);
}
long total = size_right + size_left;
free(lft);
free(rgt);
return total;
}
int main(int argc, char const *argv[]) {
long num = wordCounter("aaa aaa aa a a a a a a sa sa as sas sa sa saa sa sas aa sa sas sa sa"); //23 words
printf("%ld\n", num);
return 0;
}

Answer 1

To follow up on my comment above:
If I/O is your bottleneck:
Consider passing the filename into your word counting program, then managing the disc I/O yourself with simple fread() and fwrite() calls that read the whole file in at once. From the sound of it, your files should fit into memory reasonable at only 300k words - maybe worst case 3Meg files? That should read into memory very quickly.
Then, do your word counting magic on the data. My guess is that you won't even need to worry about threads or the like as scanning through memory should be nearly instant for your task. Heck, I bet even using strtok() looking for spaces and punctuation may be good enough.
But if I am wrong, the good news is that this data can easily be divided into multiple parts and passed to individual pthreads to count the data and then be collected and added when done.
If I/O is not, then the above exercise will show no gain at all, but at least it can be coded pretty quickly as a test case.