Question

I’m pretty new to threads and would like some insight. I’m trying to get the percentage each thread has completed for its calculation. Each thread will report its percentage to a different element of the same array. I have this working with pthread_join immediately after pthread_create and a separate thread for reading all the values of the array and printing the percentage but when I have all threads running after each other without waiting for the previous one to finish I get some weird behavior. This is how I’m accessing the shared (global) array.

//global
int *currentProgress;
//main
    currentProgress = malloc(sizeof(int)*threads);
    for(i=0; i<threads; i++)
        currentProgress[i] = 0;
//child threads
currentProgress[myId] = (int)percent; //myId is unique

//progress thread
for(i=0; i<threads; i++)
    progressTotal += currentProgress[i];
progressTotal /= threads;
printf("Percent: %d", progressTotal);

This is essentially the code I think is not being used correctly for multi-threads. When I print out the state of the shared array, I notice that as soon as another thread starts accessing the array (different element though), the previous element immediately goes to some random number… -2147483648 and when the latter element finishes the prior element continues like normal. Should I be using semaphores for this? I thought I could access different elements of an array at the same time and I thought reading them wasn’t an issue.

This is the entire code:

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <stdint.h>
#include <pthread.h>
#include <string.h>

#define STDIN 0


int counter = 0;
uint64_t *factors;
void *getFactors(void *arg);
void *deleteThreads(void *arg);
void *displayProgressThread(void *arg);
int *currentProgress;

struct data
{
    uint64_t num;
    uint64_t incrS;
    uint64_t incrF;
    int threads;
    int member;
} *args;

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

    if(argc < 3) {printf("not enough arguments"); exit(1);}

    int i;
    int threads = atoi(argv[2]);
    pthread_t thread_id[threads];
    pthread_t dThread;

    currentProgress = malloc(sizeof(int)*threads);
    for(i=0; i<threads; i++)
        currentProgress[i] = 0;

    args = (struct data*)malloc(sizeof(struct data));
    args->num = atoll(argv[1]);
    args->threads = threads;

    uint64_t increment = (uint64_t)sqrt((uint64_t)args->num)/threads;
    factors = (uint64_t*)malloc(sizeof(uint64_t)*increment*threads);

    pthread_create(&dThread, NULL, displayProgressThread, (void*)args);

    //for the id of each thread
    args->member = 0;
    for(i=0; i<threads; i++)
    {
            args->incrS = (i)*increment +1;
            args->incrF = (i+1)*increment +1;
            pthread_create(&thread_id[i], NULL, getFactors, (void*)args);
            usleep(5);
    }

    for(i=0; i<threads; i++)
    {
        pthread_join(thread_id[i], NULL);
    }
    sleep(1);
    printf("done\n");
    for (i=0; i<counter; i++)
        printf("\n%llu : %llu", factors[++i], factors[i]);
    return 0;
}

void *getFactors(void *arg)
{
    uint64_t  count;
    int myId;
    int tempCounter = 0, i;
    struct data *temp = (struct data *) arg;
    uint64_t number = temp->num;
    float total = temp->incrF - temp->incrS, percent;

    myId = temp->member++;

    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);

    for(count=temp->incrS; count<=temp->incrF; count++)
    {

        percent = (float)(count-temp->incrS)/total*100;
        currentProgress[myId] = (int)percent;

        if (number%count == 0)
         {
                factors[counter++] = count;
                factors[counter++] = number/count;
         }   
        usleep(1);
    }
    usleep(1);
    pthread_exit(NULL);
}

void *displayProgressThread(void *arg)
{
    struct data *temp = (struct data *) arg;
    int toDelete = 0;
    while(1)
    {
        int i;
        int progressTotal = 0;
        char *percent = malloc(sizeof(char)*20);
        for(i=0; i<toDelete; i++)
            printf("\b \b");

        for(i=0; i<temp->threads; i++){
            progressTotal += currentProgress[i];
        }

        progressTotal /= temp->threads;
        printf("|");
        for(i=0; i<50; i++)
            if(i<progressTotal/2)
                printf("#");
            else
                printf("_");
        printf("| ");
        sprintf(percent, "Percent: %d", progressTotal);
        printf("%s", percent);
        toDelete = 53 + strlen(percent);


usleep(1000);
    fflush(stdout);
    if(progressTotal >= 100)
        pthread_exit(NULL);
}

}

Answer 1

There are some non synchronized pieces of code that are accessed by the threads which cause this problem.

One first place to be synchronized is:

   myId = temp->member++;

But more importantly is that, the main thread is doing:

   args->incrS = (i)*increment +1;
   args->incrF = (i+1)*increment +1;

while at the same time in the threads:

   for(count=temp->incrS; count<= temp->incrF; count++)
    {

        percent = (float)(count-temp->incrS)/total*100;
        currentProgress[myId] = (int)percent;

        if (number%count == 0)
         {
                factors[counter++] = count;
                factors[counter++] = number/count;
         }   
        usleep(1);
    }

The unsynchronized accesses mentioned above affect the calculation of percent value which results in such abnormal happenings. You have to do synchronization in all these places in order to get the kind of behavior you would expect.