Weird behavior of gettimeofday - c

Question

I would like to obtain the elapsed time between one thread enters to the Critical Zone and the other takes the permision to enter in the same Critical Zone on ARM CortexA8. For this I have been using the function gettimeofday() in C.
void *Thread1_Routine (); //Create the Semaphore
void *Thread2_Routine (); //Wait for Thread1_Routine's Semaphore
void configured_malloc_behavior();
void Calc_Dif_Time (struct timeval *time1,struct timeval *time2);
//Definition to represent the time
typedef struct te_tim96
{
int64_t sec;
int32_t usec;
}te_tim96;
//Variables to save the time
struct timeval t1,t2;
//Variable to control the order enter Critical zone
char lock=0;
int count=0;
//Variable to make the create the mutex
pthread_mutex_t mutex;
int main (void)
{
//Variables define threads
pthread_t threadadd1, threadadd2;
pthread_attr_t attr1, attr2;
struct sched_param p1, p2;
//Configured malloc behavior
configured_malloc_behavior();
//Init the Thread
pthread_mutex_init(&mutex, NULL);
//Define Threads
pthread_attr_init(&attr1);
pthread_attr_init(&attr2);
//Thread1
pthread_attr_setschedpolicy(&attr1, SCHED_FIFO);
p1.sched_priority= 98; //This is lower than Thread2
pthread_attr_setschedparam(&attr1, &p1);
//Thread2
pthread_attr_setschedpolicy(&attr2, SCHED_FIFO);
p2.sched_priority= 99;
pthread_attr_setschedparam(&attr2, &p2);
//End define Threads
//Init the gpio63 as Output
do Stuff()
//Create the threads
pthread_create(&threadadd1,&attr1,&Thread1_Routine, NULL);
pthread_create(&threadadd2,&attr2,&Thread2_Routine, NULL);
//Wait to end the Threads ()
pthread_join(threadadd1, NULL);
pthread_join(threadadd2, NULL);
return 0;
}
//Thread Producer
void *Thread1_Routine (void)
{
//Variable to write in gpio/value
char value=1;
while (count<MAXCOUNT)
{
sleep (3);
pthread_mutex_lock(&mutex);
lock=lock+1; //Increment variable lock to indicate that the Thread Producer was done.
gettimeofday(&t1, NULL);
pthread_mutex_unlock(&mutex);
}
pthread_exit(NULL);
}
//Thread Consumer
void *Thread2_Routine (void)
{
//Variable to write in gpio/value
char value=0;
while (count<MAXCOUNT)
{
//Wait for the semaphore is free!!!!!
while (lock=0);
pthread_mutex_lock(&mutex);
lock=lock-1; //Decrement variable lock to indicate that the Thread Producer was done.
gettimeofday(&t2, NULL);
Calc_Dif_Time(&t1, &t2); //Function to calculate the latency and plot it
pthread_mutex_unlock(&mutex);
count++; //To incremate the count of how many time goes the thread are made
}
pthread_exit(NULL);
}
void Calc_Dif_Time (struct timeval *time1,struct timeval *time2)
{
struct te_tim96 Tmeasure1, Tmeasure2;
double Elapsedtime;
//TmeasureY=tY
Tmeasure1.sec=(*time1).tv_sec;
Tmeasure1.usec=(*time1).tv_usec;
Tmeasure2.sec=(*time2).tv_sec;
Tmeasure2.usec=(*time2).tv_usec;
//Calculate
//Part in sec to miliseconds
Elapsedtime=(Tmeasure2.sec-Tmeasure1.sec)*1000;
//Part in usec to miliseconds
Elapsedtime+=(Tmeasure2.usec-Tmeasure1.usec)*0.001;
//Work with the rest of the division to convert usec to miliseconds
printf("Time to create the Semaphore[%lld.%6ld] Time to take the Semaphore[%lld.%6ld] Elapsed Time [%f ms]\n", Tmeasure1.sec, Tmeasure1.usec, Tmeasure2.sec, Tmeasure2.usec, Elapsedtime);
Elapsedtime=0; //Reset Elapsedtime to the next measure
}
The program is without error, but my problem, when I execute it, is that the console show the following result:
./R_T_Measure4
Time to create the Semaphore[0. 0] Time to take the Semaphore[4878.153276] Elapsed Time [4878153.276000 ms]
Time to create the Semaphore[0. 0] Time to take the Semaphore[4878.153886] Elapsed Time [4878153.886000 ms]
This result shows how I might that the t1 variable is not pointed well or it is restarted. But I don't know that I am overlooking in this case because t2 works well.
Any help will be grateful
-Regards

Answer 1

Your while loop isn't waiting for the lock to be free. When you do while (lock=0);, that will always return 0, and you will end your loop immediately, and it is also messing up your locking, because you are setting your lock variable. You should use while (lock == 0);

Answer 2

You always call Calc_Dif_Time from thread 2 so if Thread 2 gets the lock before thread 1 t1 will be uninitialised