This is the mail archive of the
ecos-discuss@sources.redhat.com
mailing list for the eCos project.
CONDITION VARIABLES & MUTEXES
- To: Jonathan Larmour <jlarmour at redhat dot com>
- Subject: [ECOS] CONDITION VARIABLES & MUTEXES
- From: Srinivasan Sriram <pet_jimmy at yahoo dot com>
- Date: Wed, 20 Jun 2001 00:27:09 -0700 (PDT)
- Cc: ecos-discuss at sourceware dot cygnus dot com
Hello!
I'm trying out condition variables for
the first time.
As per the reference manual,
cyg_cond_wait releases the mutex (I don't
have to explicitly use
cyg_mutex_release(&mut)).
But incase of cyg_cond_broadcast, I quote
from the documentation - "Wakes all the
threads waiting on the condition variable.
Each time a thread is awakened it will
become the current owner of the mutex."
But the threads waiting on the condition
variables are not awakened until I
explicitly release the mutex after
cyg_cond_broadcast call.
Please look at my dummy code where thr1
and thr3 act as consumers and thr2 is the
producer.
-----
#include<stdio.h>
#include<cyg/kernel/kapi.h>
cyg_thread thr[3];
char stack[3][4096];
cyg_handle_t hthr1,hthr2,hthr3;
cyg_thread_entry_t fthr1,fthr2,fthr3;
cyg_thread thr1,thr2,thr3;
cyg_mutex_t mut;
cyg_cond_t cond;
int i;
cyg_user_start()
{
cyg_thread_create(1,fthr1,(cyg_addrword_t)0,"THREADA",(void
*)stack[0],4096,&hthr1,&thr[0]);
cyg_thread_create(2,fthr2,(cyg_addrword_t)0,"THREADB",(void
*)stack[1],4096,&hthr2,&thr[1]);
cyg_thread_create(1,fthr3,(cyg_addrword_t)0,"THREADC",(void
*)stack[2],4096,&hthr3,&thr[2]);
cyg_thread_resume(hthr1);
cyg_thread_resume(hthr2);
cyg_thread_resume(hthr3);
cyg_mutex_init(&mut);
cyg_cond_init(&cond,&mut);
}
void fthr1(cyg_addrword_t y)
{
cyg_bool_t a;
a=cyg_mutex_lock(&mut);
printf("thr1 %d\n",(char *)a);
cyg_cond_wait(&cond);
printf("thr1..unlocking \n");
cyg_mutex_unlock(&mut);
printf("thr1 exiting \n");
}
void fthr2(cyg_addrword_t y)
{
cyg_bool_t a;
a=cyg_mutex_lock(&mut);
printf("thr2 %d\n",a);
cyg_thread_delay(200);
cyg_cond_broadcast(&cond);
printf("thr2..after broadcast \n");
cyg_mutex_unlock(&mut); /*I HAVE TO EXPLICITLY USE
THIS*/
printf("thr2 exiting....\n");
}
void fthr3(cyg_addrword_t y)
{
cyg_bool_t a1;
a1=cyg_mutex_lock(&mut);
printf("thr3 %d\n",a1);
cyg_cond_wait(&cond);
printf("thr3...unlocking \n");
cyg_mutex_unlock(&mut);
printf("thr3 exiting \n ");
}
----------
I GET THE FOLLOWING O/P ->
thr1 1
thr3 1
thr2 1
thr2..after broadcast
thr1..unlocking
thr1 exiting
thr3.unlocking
thr3 exiting
thr2 exiting....
----
IN CASE I COMMENT CYG_MUTEX_UNLOCK AND EXPECT
CYG_COND_BROADCAST TO AUTOMATICALLY RELEASE THE
MUTEX, THE THREADS THR1 AND THR3 ARE NOT AWAKENED. THE
O/P IS -
thr1 1
thr3 1
thr2 1
thr2..after broadcast
thr2 exiting....
--------------------
1.
Can anyone explain this? Why should thr2 release the
mutex when cyg_cond_broadcast should automatically
release it?
2. The ecos documentation says, I quote -
The thread can only be awakened by a call to
cyg_cond_signal() or
cyg_cond_broadcast() on the same condition variable.
When the thread is awakened, the
mutex will be reclaimed before this function proceeds.
Since it may have to wait for this,
cyg_cond_wait() should only be used in a loop since
the condition may become false in the
meantime. This is shown in the following example:
extern cyg_mutex_t mutex;
extern cyg_cond_t cond;
cyg_mutex_lock( &mutex );
...
while( condition_not_true )
{
cyg_cond_wait( &cond );
}
...
cyg_mutex_unlock( &mutex );
------
WHY DO WE REQUIRE THE WHILE LOOP? ANY WAY THE
CYG_COND_WAIT CANNOT PROCEED BEFORE IT OBTAINS THE
MUTEX AND BROADCAST FROM THE PRODUCER AND OTHER
THREADS?
ALSO COULD ANYONE EXPLAIN - WHAT IS THE VARIABLE IN
THE WHILE LOOP. WHAT DOES IT TEST?
thanks
Kavita
__________________________________________________
Do You Yahoo!?
Get personalized email addresses from Yahoo! Mail
http://personal.mail.yahoo.com/