vxWorks互斥信号量示例
#include "vxWorks.h"
#include "semLib.h"
#include "taskLib.h"
#include "logLib.h"
#include "sysLib.h"
#include "stdio.h"
#define CONSUMER_TASK_PRI 98 /* Priority of the consumerTask task*/
#define PRODUCER_TASK_PRI 99 /* Priority of the producerTask task*/
#define PRODUCED 1 /* Flag to indicate produced status*/
#define CONSUMED 0 /* Flag to indicate consumed status*/
#define NUM_ITEMS 5 /* Number of items */
struct shMem /* Shared Memory data structure */
{
int tid; /* task id */
int count; /* count number of item produced */
int status; /* 0 if consumed or 1 if produced*/
};
LOCAL STATUS protectSharedResource (); /* protect shared data structure */
LOCAL STATUS releaseProtectedSharedResource (); /* release protected access */
LOCAL STATUS producerTask (); /* producer task */
LOCAL STATUS consumerTask (); /* consumer task */
LOCAL struct shMem shMemResource; /* shared memory structure */
LOCAL SEM_ID mutexSemId; /* mutual exclusion semaphore id*/
LOCAL BOOL notFinished; /* Flag that indicates the
* completion */
STATUS TestMSem()
{
notFinished = TRUE; /* initialize the global flag */
/* Create the mutual exclusion semaphore*/
if ((mutexSemId = semMCreate(SEM_Q_PRIORITY | SEM_DELETE_SAFE
| SEM_INVERSION_SAFE)) == NULL)
{
perror ("Error in creating mutual exclusion semaphore");
return (ERROR);
}
/* Spwan the consumerTask task */
if (taskSpawn ("tConsumerTask", CONSUMER_TASK_PRI, 0, 5000,
(FUNCPTR) consumerTask, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
== ERROR)
{
perror ("consumerTask: Error in spawning demoTask");
return (ERROR);
}
/* Spwan the producerTask task */
if (taskSpawn ("tProducerTask", PRODUCER_TASK_PRI, 0, 5000,
(FUNCPTR) producerTask, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
== ERROR)
{
perror ("producerTask: Error in spawning demoTask");
return (ERROR);
}
/* Polling is not recommended. But used for making this demonstration
* simple */
while (notFinished)
taskDelay (sysClkRateGet ());
/* When done delete the mutual exclusion semaphore*/
if (semDelete (mutexSemId) == ERROR)
{
perror ("Error in deleting mutual exclusion semaphore");
return (ERROR);
}
return (OK);
}
/*****************************************************************************
* producerTask - produce the message, and write the message to the global
* shared data structure by obtaining exclusive access to
* that structure which is shared with the consumerTask.
*
* RETURNS: OK or ERROR
*
*/
STATUS producerTask ()
{
int count = 0;
int notDone = TRUE;
printf("in producerTask\n");
while (notDone)
{
/* Produce NUM_ITEMS, write each of these items to the shared
* global data structure.
*/
if (count < NUM_ITEMS)
{
/* Obtain exclusive access to the global shared data structure */
if (protectSharedResource() == ERROR)
return (ERROR);
/* Access and manipulate the global shared data structure */
if (shMemResource.status == CONSUMED)
{
count++;
shMemResource.tid = taskIdSelf ();
shMemResource.count = count;
shMemResource.status = PRODUCED;
}
/* Release exclusive access to the global shared data structure */
if (releaseProtectedSharedResource () == ERROR)
return (ERROR);
logMsg ("ProducerTask: tid = %#x, producing item = %d\n",
taskIdSelf (), count,0,0,0,0);
taskDelay (sysClkRateGet()/6); /* relingiush the CPU so that
* consumerTask can access the
* global shared data structure.
*/
}
else
notDone = FALSE;
}
return (OK);
}
/*****************************************************************************
* consumerTask - consumes the message from the global shared data
* structure and updates the status filled to CONSUMED
* so that producerTask can put the next produced message
* in the global shared data structure.
*
* RETURNS: OK or ERROR
*
*/
STATUS consumerTask ()
{
int notDone = TRUE;
printf("in consumerTask\n");
/* Initialize to consumed status */
if (protectSharedResource() == ERROR)
return (ERROR);
shMemResource.status = CONSUMED;
if (releaseProtectedSharedResource () == ERROR)
return (ERROR);
while (notDone)
{
taskDelay (sysClkRateGet()/6); /* relingiush the CPU so that
* producerTask can access the
* global shared data structure.
*/
/* Obtain exclusive access to the global shared data structure */
if (protectSharedResource() == ERROR)
return (ERROR);
/* Access and manipulate the global shared data structure */
if ((shMemResource.status == PRODUCED) && (shMemResource.count > 0))
{
logMsg ("ConsumerTask: Consuming item = %d from tid = %#x\n\n",
shMemResource.count, shMemResource.tid,0,0,0,0);
shMemResource.status = CONSUMED;
}
if (shMemResource.count >= NUM_ITEMS)
notDone = FALSE;
/* Release exclusive access to the global shared data structure */
if (releaseProtectedSharedResource () == ERROR)
return (ERROR);
}
notFinished = FALSE;
return (OK);
}
/*****************************************************************************
* protectSharedResource - Protect access to the shared data structure with
* the mutual exclusion semaphore.
*
* RETURNS: OK or ERROR
*
*/
LOCAL STATUS protectSharedResource ()
{
if (semTake (mutexSemId, WAIT_FOREVER) == ERROR)
{
perror ("protectSharedResource: Error in semTake");
return (ERROR);
}
else
return (OK);
}
/*****************************************************************************
* releaseProtectedSharedResource - Release the protected access to the
* shared data structure using the mutual
* exclusion semaphore
*
* RETURNS: OK or ERROR
*
*/
LOCAL STATUS releaseProtectedSharedResource ()
{
if (semGive (mutexSemId) == ERROR)
{
perror ("protectSharedResource: Error in semTake");
return (ERROR);
}
else
return (OK);
}