is it possible to create 2 different semaphore for guarding same resource in VxWorks? - vxworks

Question

Please can anybody help me on this issue.
Is it possible for 2 different tasks to create 2 different semaphore for gaurding same critical resource in VxWorks?

Answer 1

This should be covered in the vxWorks documentation.
In general, you should decouple the creation of the semaphore from the use of the semaphore.
/**Initialization Code**/
SEM_ID semM;
semM = semMCreate (...);
...
taskSpawn(task1...);
taskSpawn(task2...);
...
/* Task 1 code */
void task1() {
...
semTake (semM, WAIT_FOREVER);
...<Task 1 critical section>
semGive (semM);
...
}
/* Task 2 code */
void task2() {
...
semTake (semM, WAIT_FOREVER);
...< Task 2 critical section>
semGive (semM);
...
}
In this instance, semM is a global variable available to both tasks.
If that offends you, with VxWorks 6.x you can also use the semOpen() API which gives semaphores names.
Do a semOpen in each task to create/retrieve the semaphore and it's ID.
When the mutex is created, it is available to the first task that does a semTake (be it task 1 or task 2).
If you need things to happen in a specific order then you need a combination of mutex (for mutual exclusion) and synchronization (via Binary semaphore for example).
Taking the above example a modifying a bit to make sure that task2 only runs once task1 has done something.
/**Initialization Code**/
SEM_ID semM;
SEM_ID semSync;
semM = semMCreate (...);
semSync = semBCreate (...);
...
void task1() {
...
/* Access Shared Structure */
semTake (semM, WAIT_FOREVER);
...<Task 1 critical section>
semGive (semM);
/* Notify Task 2 that something is available */
semGive (semSync);
...
}
void task2() {
...
/* Wait for Task 1 to let me know there is something to do */
semTake (semSync, WAIT_FOREVER);
/* Access Shared Structure */
semTake (semM, WAIT_FOREVER);
...< Task 2 critical section>
semGive (semM);
...
}

Answer 2

I think you missing here something,
in vxWorks, all tasks share the same memory space, therefore, you must protected global data between tasks with Mutex.
The idea is to use only one Mutex (that its sem_id is well known for all tasks that want to use it).
You can protect the data using one Mutex (there is no limitation about the number of tasks using the same Mutex).
if you do want to access the same memory space between 2 tasks in vxWorks, the best way to do it is:
create access function
int access_func(void)
{
static SEM_ID sem_id=0;
if(sem_id == 0)
{
/* create mutex semaphore \u2013 semMCreate(\u2026) */
}
return_code=semTake(sem_id, time_out);
if(return_code != 0) return errno;
/* read or write to or from global memory */
semGive(sem_id);
}
Notes:
There are several options in semMCreate and several options in semTake
You can create the mutex at the system init (recommended).
If the mutex is not read, and the sem_id is still zero, semTake return ERROR (you can check the return code and the system errno)