Question

So, I am about 99% certain that I have implemented something wrong, but heres the deal.

I have been playing around with Grand Central Dispatch, and put together an experiment calculating MD5 hashes. I am running a macbook air with an i5, so have 4 cores available. This would led me to believe that using Grand Central Dispatch to calculate the hashes would be approx 4 times faster. But, for some reason, it appears to be slower.

Code below

Using GCD

#include <stdio.h>
#include <time.h>
#import <CommonCrypto/CommonDigest.h>
#import <dispatch/dispatch.h>

int main (int argc, const char * argv[])
{

    int i,j,k,l,a;
    int num_chars = 4, total;
    clock_t start, end;
    double elap;

    printf("Calculating hashes for %d chars\n", num_chars);

    total = num_chars ^ 64;

    printf("Calculating %d hashes\n", total);

    dispatch_queue_t queue = dispatch_get_global_queue(0,0);
    dispatch_queue_t main = dispatch_get_main_queue();
    dispatch_group_t group = dispatch_group_create();

    start = clock();

   printf("Starting calculation queue\n");
   for(i=0;i<62;i++) {
        for(j=0;j<62;j++) {
            for(k=0;k<62;k++) {
                for(l=0;l<62;l++) {

                    dispatch_group_async(group, queue, ^{

                        char *letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
                        char buffer[10];
                        char out[100];
                        unsigned char hash[16];

                        sprintf(buffer, "%c%c%c%c", letters[i], letters[j], letters[k], letters[l]);
                        CC_MD5(buffer, strlen(buffer), hash); 

                    });


                }
            }
        }
    }

   printf("Finished calculation queue\n");
   dispatch_group_wait(group, DISPATCH_TIME_FOREVER);

    end = clock();

    elap = ((double) end - start) / CLOCKS_PER_SEC;

    printf("Time taken  %2f\n", elap);
    return 0;
}

Compile and run…

gcc -o a.out main.c
./a.out
Calculating hashes for 4 chars
Calculating 68 hashes
Starting calculation queue
Finished calculation queue
Time taken  35.193133

Looking at Activity Monitor, I can see all 4 cores max out while the script is running.

Now, comment out the dispatching….

#include <stdio.h>
#include <time.h>
#import <CommonCrypto/CommonDigest.h>
#import <dispatch/dispatch.h>

int main (int argc, const char * argv[])
{

    int i,j,k,l,a;
    int num_chars = 4, total;
    clock_t start, end;
    double elap;

    printf("Calculating hashes for %d chars\n", num_chars);

    total = num_chars ^ 64;

    printf("Calculating %d hashes\n", total);

    dispatch_queue_t queue = dispatch_get_global_queue(0,0);
    dispatch_queue_t main = dispatch_get_main_queue();
    dispatch_group_t group = dispatch_group_create();

    start = clock();

   printf("Starting calculation queue\n");
   for(i=0;i<62;i++) {
        for(j=0;j<62;j++) {
            for(k=0;k<62;k++) {
                for(l=0;l<62;l++) {

                    //dispatch_group_async(group, queue, ^{

                        char *letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
                        char buffer[10];
                        char out[100];
                        unsigned char hash[16];

                        sprintf(buffer, "%c%c%c%c", letters[i], letters[j], letters[k], letters[l]);
                        CC_MD5(buffer, strlen(buffer), hash); 

                    //});




   }
        }
    }
}

printf("Finished calculation queue\n");
//dispatch_group_wait(group, DISPATCH_TIME_FOREVER);

end = clock();

elap = ((double) end - start) / CLOCKS_PER_SEC;

printf("Time taken  %2f\n", elap);
return 0;
}

Compile and run

gcc -o b.out main.c
./b.out
Calculating hashes for 4 chars
Calculating 68 hashes
Starting calculation queue
Finished calculation queue
Time taken  7.511273

Looking at Activity Monitor, it only shows 1 core active while the script runs.

Answer 1

There’s probably too little work being done in the dispatch that it doesn’t make the overhead involved with dispatching worthwhile. I would try and increase the amount of work done in each dispatch. I wouldn’t have a clue whether this would help, but try:

1. Moving the dispatch up a few loops, perhaps wrap the k or j loop inside the dispatched block instead, to get it to do more work.

2. Remove the call sprintf and strlen. In fact, the block could be simplified to:

   static const char *letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
   unsigned char hash[16];
   char buffer[4] = { letters[i], letters[j], letters[k], letters[l] };
   
   CC_MD5(buffer, sizeof buffer, hash);