/*
* ======== Task_sleep ========
*/
Void Task_sleep(UInt timeout)
{
Task_PendElem elem;
UInt hwiKey, tskKey;
Clock_Struct clockStruct;
if (timeout == BIOS_NO_WAIT) {
return;
}
Assert_isTrue((timeout != BIOS_WAIT_FOREVER), Task_A_badTimeout);
/* add Clock event if timeout is not FOREVER */
if (BIOS_clockEnabled) {
Clock_Params clockParams;
Clock_Params_init(&clockParams);
clockParams.arg = (UArg)&elem;
clockParams.startFlag = FALSE; /* will start when necessary, thankyou */
Clock_construct(&clockStruct, (Clock_FuncPtr)Task_sleepTimeout, timeout, &clockParams);
elem.clock = Clock_handle(&clockStruct);
}
hwiKey = Hwi_disable();
/* lock scheduler */
tskKey = Task_disable();
/* get task handle and block tsk */
elem.task = Task_self();
Task_blockI(elem.task);
if (BIOS_clockEnabled) {
Clock_startI(elem.clock);
}
/* Only needed for Task_delete() */
Queue_elemClear(&elem.qElem);
elem.task->pendElem = (Ptr)(&elem);
Hwi_restore(hwiKey);
Log_write3(Task_LM_sleep, (UArg)elem.task, (UArg)elem.task->fxn,
(UArg)timeout);
Task_restore(tskKey); /* the calling task will block here */
/* deconstruct Clock if appropriate */
if (BIOS_clockEnabled) {
Clock_destruct(Clock_struct(elem.clock));
}
}
/*
* ======== Semaphore_pend ========
*/
Bool Semaphore_pend(Semaphore_Object *sem, UInt timeout)
{
UInt hwiKey, tskKey;
Semaphore_PendElem elem;
Queue_Handle pendQ;
Clock_Struct clockStruct;
Log_write3(Semaphore_LM_pend, (IArg)sem, (UArg)sem->count, (IArg)((Int)timeout));
/*
* Consider fast path check for count != 0 here!!!
*/
/*
* elem is filled in entirely before interrupts are disabled.
* This significantly reduces latency.
*/
/* add Clock event if timeout is not FOREVER nor NO_WAIT */
if (BIOS_clockEnabled
&& (timeout != BIOS_WAIT_FOREVER)
&& (timeout != BIOS_NO_WAIT)) {
Clock_Params clockParams;
Clock_Params_init(&clockParams);
clockParams.arg = (UArg)&elem;
clockParams.startFlag = FALSE; /* will start when necessary, thankyou */
Clock_construct(&clockStruct, (Clock_FuncPtr)Semaphore_pendTimeout,
timeout, &clockParams);
elem.tpElem.clock = Clock_handle(&clockStruct);
elem.pendState = Semaphore_PendState_CLOCK_WAIT;
}
else {
elem.tpElem.clock = NULL;
elem.pendState = Semaphore_PendState_WAIT_FOREVER;
}
pendQ = Semaphore_Instance_State_pendQ(sem);
hwiKey = Hwi_disable();
/* check semaphore count */
if (sem->count == 0) {
if (timeout == BIOS_NO_WAIT) {
Hwi_restore(hwiKey);
return (FALSE);
}
Assert_isTrue((BIOS_getThreadType() == BIOS_ThreadType_Task),
Semaphore_A_badContext);
/* lock task scheduler */
tskKey = Task_disable();
/* get task handle and block tsk */
elem.tpElem.task = Task_self();
/* leave a pointer for Task_delete() */
elem.tpElem.task->pendElem = (Task_PendElem *)&(elem);
Task_blockI(elem.tpElem.task);
if (((UInt)sem->mode & 0x2) != 0) { /* if PRIORITY bit is set */
Semaphore_PendElem *tmpElem;
Task_Handle tmpTask;
UInt selfPri;
tmpElem = Queue_head(pendQ);
selfPri = Task_getPri(elem.tpElem.task);
while (tmpElem != (Semaphore_PendElem *)pendQ) {
tmpTask = tmpElem->tpElem.task;
/* use '>' here so tasks wait FIFO for same priority */
if (selfPri > Task_getPri(tmpTask)) {
break;
}
else {
tmpElem = Queue_next((Queue_Elem *)tmpElem);
}
}
Queue_insert((Queue_Elem *)tmpElem, (Queue_Elem *)&elem);
}
else {
/* put task at the end of the pendQ */
Queue_enqueue(pendQ, (Queue_Elem *)&elem);
}
/* start Clock if appropriate */
if (BIOS_clockEnabled &&
(elem.pendState == Semaphore_PendState_CLOCK_WAIT)) {
Clock_startI(elem.tpElem.clock);
}
Hwi_restore(hwiKey);
Task_restore(tskKey); /* the calling task will block here */
/* Here on unblock due to Semaphore_post or timeout */
if (Semaphore_supportsEvents && (sem->event != NULL)) {
/* synchronize Event state */
hwiKey = Hwi_disable();
Semaphore_eventSync(sem->event, sem->eventId, sem->count);
Hwi_restore(hwiKey);
}
/* deconstruct Clock if appropriate */
if (BIOS_clockEnabled && (elem.tpElem.clock != NULL)) {
Clock_destruct(Clock_struct(elem.tpElem.clock));
}
elem.tpElem.task->pendElem = NULL;
return ((Bool)(elem.pendState));
}
else {
--sem->count;
if (Semaphore_supportsEvents && (sem->event != NULL)) {
/* synchronize Event state */
Semaphore_eventSync(sem->event, sem->eventId, sem->count);
}
Hwi_restore(hwiKey);
/* deconstruct Clock if appropriate */
if (BIOS_clockEnabled && (elem.tpElem.clock != NULL)) {
Clock_destruct(Clock_struct(elem.tpElem.clock));
}
return (TRUE);
}
}
/*
* ======== Event_pend ========
*/
UInt Event_pend(Event_Object *event, UInt andMask, UInt orMask, UInt timeout)
{
UInt hwiKey, tskKey;
Event_PendElem elem;
UInt matchingEvents;
Queue_Handle pendQ;
Clock_Struct clockStruct;
Assert_isTrue(((andMask | orMask) != 0), Event_A_nullEventMasks);
Log_write5(Event_LM_pend, (UArg)event, (UArg)event->postedEvents,
(UArg)andMask, (UArg)orMask, (IArg)((Int)timeout));
/*
* elem is filled in entirely before interrupts are disabled.
* This significantly reduces latency at the potential cost of wasted time
* if it turns out that there is already an event match.
*/
/* add Clock event if timeout is not FOREVER nor NO_WAIT */
if (BIOS_clockEnabled
&& (timeout != BIOS_WAIT_FOREVER)
&& (timeout != BIOS_NO_WAIT)) {
Clock_Params clockParams;
Clock_Params_init(&clockParams);
clockParams.arg = (UArg)&elem;
clockParams.startFlag = FALSE; /* will start when necessary, thankyou */
Clock_construct(&clockStruct, (Clock_FuncPtr)Event_pendTimeout,
timeout, &clockParams);
elem.tpElem.clock = Clock_handle(&clockStruct);
elem.pendState = Event_PendState_CLOCK_WAIT;
}
else {
elem.tpElem.clock = NULL;
elem.pendState = Event_PendState_WAIT_FOREVER;
}
/* fill in this task's Event_PendElem */
elem.andMask = andMask;
elem.orMask = orMask;
pendQ = Event_Instance_State_pendQ(event);
/* get task handle */
elem.tpElem.task = Task_self();
/* leave a pointer for Task_delete() */
elem.tpElem.task->pendElem = (Task_PendElem *)&(elem);
/* Atomically check for a match and block if none */
hwiKey = Hwi_disable();
/* check if events are already available */
matchingEvents = checkEvents(event, andMask, orMask);
if (matchingEvents != 0) {
Hwi_restore(hwiKey);
/* deconstruct Clock if appropriate */
if (BIOS_clockEnabled && (elem.tpElem.clock != NULL)) {
Clock_destruct(Clock_struct(elem.tpElem.clock));
}
return (matchingEvents);/* yes, then return with matching bits */
}
if (timeout == BIOS_NO_WAIT) {
Hwi_restore(hwiKey);
return (0); /* No match, no wait */
}
Assert_isTrue((BIOS_getThreadType() == BIOS_ThreadType_Task),
Event_A_badContext);
/* lock scheduler */
tskKey = Task_disable();
/* only one Task allowed!!! */
Assert_isTrue(Queue_empty(pendQ), Event_A_eventInUse);
/* add it to Event_PendElem queue */
Queue_enqueue(pendQ, (Queue_Elem *)&elem);
Task_blockI(elem.tpElem.task);
if (BIOS_clockEnabled &&
(elem.pendState == Event_PendState_CLOCK_WAIT)) {
Clock_startI(elem.tpElem.clock);
}
Hwi_restore(hwiKey);
/* unlock task scheduler and block */
Task_restore(tskKey); /* the calling task will switch out here */
/* Here on unblock due to Event_post or Event_pendTimeout */
/* deconstruct Clock if appropriate */
if (BIOS_clockEnabled && (elem.tpElem.clock != NULL)) {
Clock_destruct(Clock_struct(elem.tpElem.clock));
}
elem.tpElem.task->pendElem = NULL;
/* event match? */
if (elem.pendState != Event_PendState_TIMEOUT) {
return (elem.matchingEvents);
}
else {
return (0); /* timeout */
}
}
/*
* ======== Task_Instance_finalize ========
* free stack if alloced during create
*/
Void Task_Instance_finalize(Task_Object *tsk, Int status)
{
Int i, cnt;
/*
* Task's can only be deleted from main and task threads.
* Task's can only be deleted when they are in these states:
* Task_Mode_TERMINATED
* Task_Mode_READY
*/
if (status == 0) {
Assert_isTrue((tsk->mode == Task_Mode_TERMINATED) ||
(tsk->mode == Task_Mode_BLOCKED) ||
((tsk->mode == Task_Mode_READY) && (tsk != Task_self())),
Task_A_badTaskState);
Assert_isTrue((BIOS_getThreadType() == BIOS_ThreadType_Main) ||
(BIOS_getThreadType() == BIOS_ThreadType_Task),
Task_A_badThreadType);
if (tsk->mode == Task_Mode_READY) {
/* remove task from its ready list */
Queue_remove((Queue_Elem *)tsk);
/* if last task in readyQ, remove corresponding bit in curSet */
if (Queue_empty(tsk->readyQ)) {
Task_module->curSet &= ~tsk->mask;
}
}
if (tsk->mode == Task_Mode_BLOCKED) {
Assert_isTrue(tsk->pendElem != NULL, Task_A_noPendElem);
if (tsk->pendElem != NULL) {
Queue_remove(&(tsk->pendElem->qElem));
if (tsk->pendElem->clock) {
Clock_destruct(Clock_struct(tsk->pendElem->clock));
}
}
}
if (tsk->mode == Task_Mode_TERMINATED) {
/* remove task from terminated task list */
Queue_remove((Queue_Elem *)tsk);
}
}
/* return if failed before allocating stack */
if (status == 1) {
return;
}
/* free stack if it was allocated dynamically */
if (tsk->stackHeap != (xdc_runtime_IHeap_Handle)(-1)) {
Memory_free(tsk->stackHeap, tsk->stack, tsk->stackSize);
}
/* return if failed to allocate Hook Env */
if (status == 2) {
return;
}
/* status == 0 or status == 3 - in both cases create hook was called */
#ifndef ti_sysbios_knl_Task_DISABLE_ALL_HOOKS
/* free any allocated Hook Envs */
if (Task_hooks.length > 0) {
if (status == 0) {
cnt = Task_hooks.length;
}
else {
cnt = status - 3; /* # successful createFxn() calls */
}
/*
* only call deleteFxn() if createFxn() was successful
*/
for (i = 0; i < cnt; i++) {
if (Task_hooks.elem[i].deleteFxn != NULL) {
Task_hooks.elem[i].deleteFxn(tsk);
}
}
Memory_free(Task_Object_heap(), tsk->hookEnv,
Task_hooks.length * sizeof (Ptr));
}
#endif
}
