main.c

VxWorks的信号量实验代码,建立了一个多任务工程,实现了任务的互斥和同步.

#include "VxWorks.h"
#include "stdio.h"
#include "stdlib.h"
#include "semLib.h"
#include "taskLib.h"


#define NUM_SAMPLE 10
#define DELAY_TICKS 8
#define STACK_SIZE 20000

typedef struct _LIST_NODE
{
	int data;
	struct _LIST_NODE *pNextNode;
}LIST_NODE;

int tidCosmos;
int tidSchlep;
int tidCrunch;
int tidMonitor;
int cosmicData = 0;
int result = 0;

LIST_NODE *pCurrNode = NULL;

SEM_ID dataSemId;
SEM_ID syncSemId;
SEM_ID nodeListGuardSemId;


void cosmos(void);
void nodeAdd(int data);
void schlep(void);
void nodeScrap(void);
void crunch(void);
void monitor(void);
void progStop(void);


STATUS progStart(void)
{
	syncSemId = semBCreate(SEM_Q_FIFO,SEM_EMPTY);
	dataSemId = semBCreate(SEM_Q_FIFO,SEM_EMPTY);
	nodeListGuardSemId = semMCreate(SEM_Q_PRIORITY | SEM_INVERSION_SAFE | SEM_DELETE_SAFE);
	pCurrNode = NULL;
	tidCosmos = taskSpawn("tCosmos", 200, 0, STACK_SIZE, (FUNCPTR)cosmos, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	tidSchlep = taskSpawn("tSchlep", 220, 0, STACK_SIZE, (FUNCPTR)schlep, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	tidCrunch = taskSpawn("tCrunch", 230, 0, STACK_SIZE, (FUNCPTR)crunch, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	tidMonitor = taskSpawn("tMonitor", 240, 0, STACK_SIZE, (FUNCPTR)monitor, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);

	return OK;
}

void cosmos(void)
{
	FOREVER
	{
		cosmicData = rand();
		semGive(dataSemId);
		taskDelay(DELAY_TICKS);
	}
	return;
}

void nodeAdd(int data)
{
	LIST_NODE *node;
	if((node = (LIST_NODE*)malloc(sizeof(LIST_NODE))) != NULL)
	{
		node->data = data;

		semTake(nodeListGuardSemId, WAIT_FOREVER);
		node->pNextNode = pCurrNode;
		pCurrNode = node;
		semGive(nodeListGuardSemId);
	}
	else
	{
		printf("nodeAdd: Out of Memory.\n");
		taskSuspend(0);
	}
	return;
}

void schlep(void)
{
	int i;
	FOREVER
	{
		for(i = 0; i < NUM_SAMPLE; i++)
		{

			semTake(dataSemId, WAIT_FOREVER);
			nodeAdd(cosmicData);
		}
		semGive(syncSemId);
	}
	return;
}

void nodeScrap(void)
{
	LIST_NODE *pTmpNode;
	semTake(nodeListGuardSemId, WAIT_FOREVER);
	if(pCurrNode != NULL)
	{
		pTmpNode = pCurrNode;
		pCurrNode = pCurrNode->pNextNode;
		free(pTmpNode);
	}
	semGive(nodeListGuardSemId);
	
	return;
}

void crunch(void)
{
	int sampleSum;
	FOREVER
	{
		sampleSum = 0;
		semTake(syncSemId, WAIT_FOREVER);	
		semTake(nodeListGuardSemId, WAIT_FOREVER);
		while(pCurrNode != NULL)
		{
			sampleSum += pCurrNode->data;
			nodeScrap();
		}
		semGive(nodeListGuardSemId);
		result = sampleSum;
	}
	return;
}

void monitor(void)
{
	BOOL isHot = FALSE;
	BOOL average = 0;
	average = RAND_MAX * NUM_SAMPLE / 2;
	FOREVER
	{
		if((!isHot) && (result >= average))
		{
			isHot = TRUE;
			printf("HOT\n");
		}
		else if(isHot && (result < average))
		{
			isHot = FALSE;
			printf("COOL\n");
		}
	}
	return;
}

void progStop(void)
{	
	result = semTake(nodeListGuardSemId, WAIT_FOREVER);
	
	if(result = OK)
	{
		taskDelete(tidCosmos);
		taskDelete(tidSchlep);
		taskDelete(tidCrunch);
		taskDelete(tidMonitor);
		
		while(pCurrNode != NULL)
		{
			nodeScrap();
		}
	}
	semDelete(dataSemId);
	semDelete(syncSemId);
	semDelete(nodeListGuardSemId);

	printf("BYE!\n");
	return;
}