cml/libcm
1
0
Förgrening 0
Kod Ärenden Pull-förfrågningar Släpp Wiki Aktiviteter
2080d13eb2
libcm/cmTaskMgr.c

1437 rader
38 KiB
C
Rå Blame Historik

#include "cmGlobal.h"
#include "cmRpt.h"
#include "cmErr.h"
#include "cmCtx.h"
#include "cmMem.h"
#include "cmMallocDebug.h"
#include "cmThread.h"
#include "cmTime.h"
#include "cmTaskMgr.h"
#include "cmLinkedHeap.h"
#include "cmText.h"
cmTaskMgrH_t cmTaskMgrNullHandle = cmSTATIC_NULL_HANDLE;
struct cmTmInst_str;
typedef struct cmTmTask_str
{
unsigned taskId;
cmChar_t* label;
cmTaskMgrFunc_t func;
cmTaskMgrRecv_t recv;
struct cmTmTask_str* link;
} cmTmTask_t;
typedef struct cmTmInst_str
{
unsigned instId; // Task instance id.
struct cmTmTask_str* task; // Pointer to task record for this task instance.
void* funcArg; // Client supplied pointer to cmTaskMgrFuncArg_t.arg;
unsigned progCnt; // Maximum expected progress (cmTaskMgrStatusArg_t.prog) to be used by this task instance.
cmChar_t* label; // Optional instance label.
cmStatusTmId_t status; // Current instance status (See cmStatusTmId_t)
void* result; // Task instance result pointer.
unsigned resultByteCnt; // Size of the task instance result pointer in bytes.
cmTaskMgrCtlId_t ctlId; // ctlId must only be written from the client thread
cmTs1p1cH_t msgQueH; // client->inst 'msg' communication queue
bool deleteOnCompleteFl; // delete this instance when its status indicates that it is killed or complete
struct cmTmInst_str* link;
} cmTmInst_t;
struct cmTm_str* p;
typedef struct cmTmThread_str
{
struct cmTm_str* p; // Pointer to task mgr.
cmThreadH_t thH; // Thread handle.
cmTmInst_t* inst; // Ptr to the task instance this thread is executing.
double durSecs; // Duration of the instance currently assigned to this thread in seconds.
cmTimeSpec_t t0; // Task start time.
cmTimeSpec_t t1; // Time of last review by the master thread.
bool deactivateFl; // True if this instance has been deactivated by the system.
cmTaskMgrFuncArg_t procArg; //
cmChar_t* text; // Temporary text buffer
struct cmTmThread_str* link; // p->threads link.
} cmTmThread_t;
typedef struct cmTm_str
{
cmErr_t err; // Task manager error object.
cmThreadH_t mstrThH; // Master thread handle.
cmTmThread_t* threads; // Thread record list.
unsigned threadRecdCnt; // Current count of records in 'threads' list.
unsigned maxActiveTaskCnt; // Max. number of active tasks.
cmTaskMgrStatusCb_t statusCb; // Client task status callback.
void* statusCbArg; // Client task status callback argument.
unsigned pauseSleepMs; //
cmTs1p1cH_t callQueH; // client->mgr 'inst' communication queue
cmTsMp1cH_t outQueH; // mgr->client communication queue
cmTmTask_t* tasks; // Task list.
cmTmInst_t* insts; // Task instance list.
unsigned nextInstId; // Next available task instance id.
unsigned activeTaskCnt; // Current active task count.
} cmTm_t;
void _cmTaskMgrStatusArgSetup(
cmTaskMgrStatusArg_t* s,
void* arg,
unsigned instId,
cmSelTmId_t selId,
cmStatusTmId_t statusId,
unsigned prog,
const cmChar_t* text,
const void* msg,
unsigned msgByteCnt )
{
s->arg = arg;
s->instId = instId;
s->selId = selId;
s->statusId = statusId;
s->prog = prog;
s->text = text;
s->msg = msg;
s->msgByteCnt = msgByteCnt;
}
// Called by MASTER and WORKER.
cmTmRC_t _cmTmEnqueueStatusMsg0( cmTm_t* p, const cmTaskMgrStatusArg_t* s )
{
enum { arrayCnt = 3 };
const void* msgPtrArray[arrayCnt];
unsigned msgSizeArray[arrayCnt];
msgPtrArray[0] = s;
msgPtrArray[1] = s->text==NULL ? "" : s->text;
msgPtrArray[2] = s->msg;
msgSizeArray[0] = sizeof(cmTaskMgrStatusArg_t);
msgSizeArray[1] = s->text==NULL ? 1 : strlen(s->text)+1;
msgSizeArray[2] = s->msgByteCnt;
if( cmTsMp1cEnqueueSegMsg(p->outQueH, msgPtrArray, msgSizeArray, arrayCnt ) != kOkThRC )
return kQueueFailTmRC;
return kOkTmRC;
}
// Called by MASTER and WORKER.
// This function is called by the worker thread wrapper _cmTmWorkerStatusCb()
// function to enqueue messages being sent back to the client.
cmTmRC_t _cmTmEnqueueStatusMsg1(
cmTm_t* p,
unsigned instId,
cmSelTmId_t selId,
cmStatusTmId_t statusId,
unsigned prog,
const cmChar_t* text,
const void* msg,
unsigned msgByteCnt )
{
cmTaskMgrStatusArg_t s;
_cmTaskMgrStatusArgSetup(&s,p->statusCbArg,instId,selId,statusId,prog,text,msg,msgByteCnt);
return _cmTmEnqueueStatusMsg0(p,&s);
}
// Called by WORKER.
// Worker threads call this function to enqueue status messages
// for delivery to the task mgr client.
void _cmTmWorkerStatusCb( const cmTaskMgrStatusArg_t* status )
{
cmTmThread_t* trp = (cmTmThread_t*)status->arg;
if( _cmTmEnqueueStatusMsg0( trp->p, status ) != kOkTmRC )
{
/// ??????? HOW DO WE HANDLE ERRORS IN THE WORKER THREAD
/// (set an error code in trp and let the master thread notice it.)
assert(0);
}
}
// Called by WORKER.
// This function is called in the worker thread by
// cmTs1p1cDequeueMsg() from within cmTaskMgrWorkerHandleCommand()
// to transfer msg's waiting in the worker's incoming msg queue
// (cmTmInst_t.msgQueH) to the instance recv function (cmTmInst_t.recv).
cmRC_t _cmTmWorkerRecvCb( void* arg, unsigned msgByteCnt, const void* msg )
{
cmTmThread_t* trp = (cmTmThread_t*)arg;
assert(trp->inst->task->recv);
trp->inst->task->recv(&trp->procArg,msg,msgByteCnt);
return cmOkRC;
}
// Called by WORKER.
// This is the wrapper for all worker threads.
bool _cmTmWorkerThreadFunc(void* arg)
{
cmTmThread_t* trp = (cmTmThread_t*)arg;
trp->procArg.reserved = trp;
trp->procArg.arg = trp->inst->funcArg;
trp->procArg.instId = trp->inst->instId;
trp->procArg.statusCb = _cmTmWorkerStatusCb;
trp->procArg.statusCbArg = trp;
trp->procArg.progCnt = trp->inst->progCnt;
trp->procArg.pauseSleepMs= trp->p->pauseSleepMs;
// if the task was paused or killed while it was queued then
// cmTaskMgrHandleCommand() will do the right thing
if( cmTaskMgrWorkerHandleCommand(&trp->procArg) != kStopTmwRC )
{
trp->inst->status = kStartedTmId;
// Notify the client that the instance has started.
_cmTmEnqueueStatusMsg1(trp->p,trp->inst->instId,kStatusTmId,trp->inst->status,0,NULL,NULL,0);
// Execute the client provided task function.
trp->inst->task->func(&trp->procArg);
}
// Notify the client if the instance was killed
if( trp->inst->ctlId == kKillTmId )
{
trp->inst->status = kKilledTmId;
_cmTmEnqueueStatusMsg1(trp->p,trp->inst->instId,kStatusTmId,trp->inst->status,0,NULL,NULL,0);
}
// Notify the client that the instance is completed
// (but don't actually set the status yet)
_cmTmEnqueueStatusMsg1(trp->p,trp->inst->instId,kStatusTmId,kCompletedTmId,0,NULL,NULL,0);
trp->inst->status = kCompletedTmId;
// Force the thread to go into the 'pause' state when it
// returns to it's internal loop. The master thread recognizes paused
// threads as available for reuse.
cmThreadPause(trp->thH,kPauseThFl);
return true;
}
void _cmTmMasterRptError( cmTm_t* p, unsigned rc, const cmChar_t* msg )
{
_cmTmEnqueueStatusMsg1(p,cmInvalidId,kErrorTmId,kInvalidTmId,rc,msg,NULL,0);
}
int _cmTmSortThreadByDur( const void* t0, const void* t1 )
{
double d = ((cmTmThread_t*)t0)->durSecs - ((cmTmThread_t*)t1)->durSecs;
return d== 0 ? 0 : (d<0 ? -1 : 1);
}
// This is the master thread function.
bool _cmTmMasterThreadFunc(void* arg)
{
cmTm_t* p = (cmTm_t*)arg;
unsigned activeThreadCnt = 0;
unsigned activeTaskCnt = 0;
cmTmThread_t* trp = p->threads;
if( p->threadRecdCnt > 0 )
{
cmTmThread_t* thArray[p->threadRecdCnt];
unsigned deactivatedCnt = 0;
//
// Determine the number of active threads and tasks
//
// for each thread record
for(trp=p->threads; trp!=NULL; trp=trp->link)
{
cmThStateId_t thState;
// if this thread is active ...
if( (thState = cmThreadState(trp->thH)) != kPausedThId )
{
assert(trp->inst!=NULL);
thArray[activeThreadCnt] = trp;
++activeThreadCnt;
// if the task assigned to this thread is started then the task is active
if( trp->inst->status == kStartedTmId )
++activeTaskCnt;
// if the deactivatedFl is set then this thread has been deactivated by the system
if( trp->deactivateFl )
++deactivatedCnt;
// update the task lifetime duration
if( trp->inst->status != kCompletedTmId )
{
cmTimeSpec_t t2;
cmTimeGet(&t2);
trp->durSecs += (double)cmTimeElapsedMicros(&trp->t1,&t2) / 1000000.0;
trp->t1 = t2;
}
}
}
//
// thArray[activeThreadCnt] now holds pointers to the
// cmTmThread_t records of the active threads
//
// if more tasks are active than should be - then deactive the youngest
if( activeTaskCnt > p->maxActiveTaskCnt )
{
// sort the active tasks in increasing order of lifetime
qsort(&thArray[0],activeThreadCnt,sizeof(thArray[0]),_cmTmSortThreadByDur);
// determine the number of threads that need to be deactivated
int n = activeTaskCnt - p->maxActiveTaskCnt;
int i,j;
// pause the active threads with the lowest lifetime
for(i=0,j=0; i<activeThreadCnt && j<n; ++i)
if( thArray[i]->deactivateFl == false )
{
thArray[i]->deactivateFl = true;
++deactivatedCnt;
++j;
}
}
//
// if there are deactivated tasks and the max thread count has not been reached
// then re-activate some of the deactivated tasks.
//
if( activeTaskCnt < p->maxActiveTaskCnt && deactivatedCnt > 0 )
{
// sort the active tasks in increasing order of lifetime
qsort(&thArray[0],activeThreadCnt,sizeof(thArray[0]),_cmTmSortThreadByDur);
int n = cmMin(p->maxActiveTaskCnt - activeTaskCnt, deactivatedCnt );
int i;
// re-activate the oldest deactivated tasks first
for(i=activeThreadCnt-1; i>=0 && n>0; --i)
if( thArray[i]->deactivateFl )
{
thArray[i]->deactivateFl = false;
--n;
++activeTaskCnt;
}
}
}
// If the number of activeTaskCnt is less than the limit and a queued task exists
while( activeTaskCnt < p->maxActiveTaskCnt && cmTs1p1cMsgWaiting(p->callQueH) )
{
cmTmInst_t* ip = NULL;
cmTmThread_t* atrp = NULL;
// Find a worker thread that is in the 'paused' state.
// This is the definitive indication that the thread
// does not have an assigned instance and the thread recd can be reused.
for(trp=p->threads; trp!=NULL; trp=trp->link)
if( cmThreadState(trp->thH) == kPausedThId )
{
atrp = trp;
break;
}
// If all the existing worker threads are in use ...
if( atrp==NULL )
{
// ... then create a new worker thread recd
atrp = cmMemAllocZ(cmTmThread_t,1);
// ... create the new worker thread
if( cmThreadCreate(&atrp->thH,_cmTmWorkerThreadFunc,atrp,p->err.rpt) != kOkThRC )
{
cmMemFree(atrp);
atrp = NULL;
_cmTmMasterRptError(p,kThreadFailTmRC,"Worker thread create failed.");
break;
}
else
{
// ... setup the new thread record
atrp->p = p;
atrp->link = p->threads;
p->threads = atrp;
p->threadRecdCnt += 1;
}
}
// if the thread creation failed
if( atrp == NULL )
break;
// dequeue a pending task instance pointer from the input queue
if(cmTs1p1cDequeueMsg(p->callQueH,&ip,sizeof(ip)) != kOkThRC )
{
_cmTmMasterRptError(p,kQueueFailTmRC,"Dequeue failed on incoming task instance queue.");
break;
}
// if the task has a msg recv callback then assign it here
if( ip->task->recv != NULL )
if( cmTs1p1cSetCallback( ip->msgQueH, _cmTmWorkerRecvCb, atrp ) != kOkThRC )
{
_cmTmMasterRptError(p,kQueueFailTmRC,"Worker thread msg queue callback assignment failed.");
break;
}
// setup the thread record associated with the new task
atrp->inst = ip;
atrp->durSecs = 0;
atrp->deactivateFl = false;
cmTimeGet(&atrp->t0);
atrp->t1 = atrp->t0;
// start the worker thread
if( cmThreadPause(atrp->thH,kWaitThFl) != kOkThRC )
_cmTmMasterRptError(p,kThreadFailTmRC,"Worker thread start failed.");
++activeTaskCnt;
}
cmSleepMs(p->pauseSleepMs);
p->activeTaskCnt = activeTaskCnt;
return true;
}
cmTm_t* _cmTmHandleToPtr( cmTaskMgrH_t h )
{
cmTm_t* p = (cmTm_t*)h.h;
assert( p != NULL );
return p;
}
cmTmTask_t* _cmTmTaskFromId( cmTm_t* p, unsigned taskId )
{
cmTmTask_t* tp;
for(tp=p->tasks; tp!=NULL; tp=tp->link)
if( tp->taskId == taskId )
return tp;
return NULL;
}
cmTmInst_t* _cmTmInstFromId( cmTm_t* p, unsigned instId )
{
cmTmInst_t* ip;
for(ip=p->insts; ip!=NULL; ip=ip->link)
if( ip->instId == instId )
return ip;
return NULL;
}
cmTmRC_t _cmTmInstFree( cmTm_t* p, unsigned instId )
{
cmTmInst_t* ip = p->insts;
cmTmInst_t* pp = NULL;
for(; ip!=NULL; ip=ip->link)
{
if( ip->instId == instId )
{
if( pp == NULL )
p->insts = ip->link;
else
pp->link = ip->link;
if( cmTs1p1cDestroy(&ip->msgQueH) != kOkThRC )
return cmErrMsg(&p->err,kQueueFailTmRC,"The 'msg' input queue destroy failed.");
cmMemFree(ip->label);
cmMemFree(ip->result);
cmMemFree(ip);
return kOkTmRC;
}
pp = ip;
}
return cmErrMsg(&p->err,kAssertFailTmRC,"The instance %i could not be found to be deleted.",instId);
}
cmTmRC_t _cmTmDestroy( cmTm_t* p )
{
cmTmRC_t rc = kOkTmRC;
unsigned i;
// stop and destroy the master thread
if( cmThreadDestroy(&p->mstrThH) != kOkThRC )
{
rc = cmErrMsg(&p->err,kThreadFailTmRC,"Master thread destroy failed.");
goto errLabel;
}
// stop and destroy all the worker threads
for(i=0; p->threads != NULL; ++i )
{
if( cmThreadDestroy(&p->threads->thH) != kOkThRC )
{
rc = cmErrMsg(&p->err,kThreadFailTmRC,"Thread destruction failed for the worker thread at index %i.",i);
goto errLabel;
}
cmTmThread_t* trp = p->threads;
p->threads = p->threads->link;
cmMemFree(trp->text);
cmMemFree(trp);
}
// release the call input queue
if( cmTs1p1cDestroy(&p->callQueH) != kOkThRC )
{
rc = cmErrMsg(&p->err,kQueueFailTmRC,"The 'call' input queue destroy failed.");
goto errLabel;
}
// draining the output queue
while( cmTsMp1cMsgWaiting(p->outQueH) )
if(cmTsMp1cDequeueMsg(p->outQueH,NULL,0) != kOkThRC )
cmErrMsg(&p->err,kQueueFailTmRC,"The output queue failed while draingin.");
// release the output queue
if( cmTsMp1cDestroy(&p->outQueH) != kOkThRC )
{
rc = cmErrMsg(&p->err,kQueueFailTmRC,"The input queue destroy failed.");
goto errLabel;
}
// release instance list
while( p->insts != NULL )
_cmTmInstFree(p,p->insts->instId);
// release the task list
cmTmTask_t* tp = p->tasks;
while( tp != NULL )
{
cmTmTask_t* np = tp->link;
cmMemFree(tp->label);
cmMemFree(tp);
tp = np;
}
cmMemFree(p);
errLabel:
return rc;
}
cmRC_t _cmTmMasterOutQueueCb(void* arg, unsigned msgByteCnt, const void* msgDataPtr );
cmTmRC_t cmTaskMgrCreate(
cmCtx_t* ctx,
cmTaskMgrH_t* hp,
cmTaskMgrStatusCb_t statusCb,
void* statusCbArg,
unsigned maxActiveTaskCnt,
unsigned queueByteCnt,
unsigned pauseSleepMs)
{
cmTmRC_t rc = kOkTmRC;
if((rc = cmTaskMgrDestroy(hp)) != kOkTmRC )
return rc;
cmTm_t* p = cmMemAllocZ(cmTm_t,1);
cmErrSetup(&p->err,&ctx->rpt,"Task Mgr.");
p->maxActiveTaskCnt = maxActiveTaskCnt;
p->statusCb = statusCb;
p->statusCbArg = statusCbArg;
p->pauseSleepMs = pauseSleepMs;
// create the master thread
if( cmThreadCreate(&p->mstrThH, _cmTmMasterThreadFunc,p,&ctx->rpt) != kOkThRC )
{
rc = cmErrMsg(&p->err,kThreadFailTmRC,"Thread index %i create failed.");
goto errLabel;
}
// create the call input queue
if(cmTs1p1cCreate( &p->callQueH, queueByteCnt, NULL, NULL, p->err.rpt ) != kOkThRC )
{
rc = cmErrMsg(&p->err,kQueueFailTmRC,"The call input queue creation failed.");
goto errLabel;
}
// create the output queue
if( cmTsMp1cCreate( &p->outQueH, queueByteCnt, _cmTmMasterOutQueueCb, p, p->err.rpt ) != kOkThRC )
{
rc = cmErrMsg(&p->err,kQueueFailTmRC,"The output queue creation failed.");
goto errLabel;
}
hp->h = p;
errLabel:
return rc;
}
cmTmRC_t cmTaskMgrDestroy( cmTaskMgrH_t* hp )
{
cmTmRC_t rc = kOkTmRC;
if( hp==NULL || cmTaskMgrIsValid(*hp)==false )
return rc;
cmTm_t* p = _cmTmHandleToPtr(*hp);
if((rc = _cmTmDestroy(p)) != kOkTmRC )
return rc;
hp->h = NULL;
return rc;
}
void _cmTmWaitForCompletion( cmTm_t* p, unsigned timeOutMs )
{
unsigned durMs = 0;
cmTimeSpec_t t0,t1;
cmTimeGet(&t0);
// Go into timeout loop - waiting for all instances to finish
while( timeOutMs==0 || durMs < timeOutMs )
{
cmTimeGet(&t1);
durMs += cmTimeElapsedMicros(&t0,&t1) / 1000;
t0 = t1;
cmSleepMs(p->pauseSleepMs);
if( p->activeTaskCnt == 0 )
break;
}
}
cmTmRC_t cmTaskMgrClose( cmTaskMgrH_t h, unsigned flags, unsigned timeOutMs )
{
cmTmRC_t rc = kOkTmRC;
cmTm_t* p = _cmTmHandleToPtr(h);
bool fl = false;
// if requested kill any queued tasks
if( cmIsFlag(flags,kKillQueuedTmFl) )
{
cmTmInst_t* ip = p->insts;
for(; ip!=NULL; ip=ip->link)
if( ip->status == kQueuedTmId )
ip->ctlId = kKillTmId;
}
// wait for any existing or queued tasks to complete
_cmTmWaitForCompletion(p,timeOutMs);
// force any queued msgs for the client to be sent
cmTaskMgrOnIdle(h);
// if the 'kill on timeout' flag is set then kill any remaining active tasks
if( cmIsFlag(flags,kTimeOutKillTmFl) )
{
cmTmInst_t* ip = p->insts;
for(; ip!=NULL; ip=ip->link)
if( ip->status != kCompletedTmId )
{
ip->ctlId = kKillTmId;
fl = true;
}
}
// wait for the remaining tasks to complete
if( fl )
_cmTmWaitForCompletion(p,timeOutMs);
// force any queued msgs for the client to be sent
cmTaskMgrOnIdle(h);
return rc;
}
unsigned cmTaskMgrActiveTaskCount( cmTaskMgrH_t h )
{
cmTm_t* p = _cmTmHandleToPtr(h);
return p->activeTaskCnt;
}
bool cmTaskMgrIsValid( cmTaskMgrH_t h )
{ return h.h != NULL; }
const cmChar_t* cmTaskMgrStatusIdToLabel( cmStatusTmId_t statusId )
{
typedef struct map_str
{
cmStatusTmId_t id;
const cmChar_t* label;
} map_t;
map_t a[] =
{
{ kQueuedTmId, "Queued" },
{ kStartedTmId, "Started" },
{ kPausedTmId, "Paused" },
{ kDeactivatedTmId, "Deactivated" },
{ kCompletedTmId, "Completed" },
{ kKilledTmId, "Killed" },
{ kInvalidTmId, "<Invalid>" },
};
int i;
for(i=0; a[i].id!=kInvalidTmId; ++i)
if( a[i].id == statusId )
return a[i].label;
return "<Unknown>";
}
// This function is called by cmTaskMgrIdle() to dispatch
// status updates to the client.
cmRC_t _cmTmMasterOutQueueCb(void* arg, unsigned msgByteCnt, const void* msgDataPtr )
{
cmTm_t* p = (cmTm_t*)arg;
cmTaskMgrStatusArg_t s;
// This is probably not nesessary since changing the memory
// pointed to by msgDataPtr should be safe even though it is marked as const.
memcpy(&s,msgDataPtr,sizeof(s));
// The 'text' and 'msg' data have been serialized after the status record.
// The 'text' is guaranteed to at least contain a terminating zero.
s.text = ((char*)msgDataPtr) + sizeof(s);
// if the 'resultByteCnt' > 0 then there is a result record
if( s.msgByteCnt > 0 )
s.msg = ((char*)msgDataPtr) + sizeof(s) + strlen(s.text) + 1;
else
s.msg = NULL;
s.arg = p->statusCbArg;
p->statusCb( &s );
return cmOkRC;
}
cmTmRC_t cmTaskMgrOnIdle( cmTaskMgrH_t h )
{
cmTmRC_t rc = kOkTmRC;
cmTm_t* p = _cmTmHandleToPtr(h);
// Transmit any msgs waiting to be sent to the client.
while( cmTsMp1cMsgWaiting(p->outQueH) )
{
// calling this function calls: _cmTmMasterOutQueueCb()
if(cmTsMp1cDequeueMsg(p->outQueH,NULL,0) != kOkThRC )
{
rc = cmErrMsg(&p->err,kQueueFailTmRC,"The output queue failed during a dequeue.");
goto errLabel;
}
}
// Step through the instance list and delete instances that are
// completed and also marked for deletion.
cmTmInst_t* ip = p->insts;
while( ip != NULL )
{
cmTmInst_t* np = ip->link;
if( ip->status==kCompletedTmId && ip->deleteOnCompleteFl )
_cmTmInstFree(p,ip->instId);
ip = np;
}
errLabel:
return rc;
}
bool cmTaskMgrIsEnabled( cmTaskMgrH_t h )
{
cmTm_t* p = _cmTmHandleToPtr(h);
return cmThreadState(p->mstrThH) != kPausedThId;
}
cmTmRC_t cmTaskMgrEnable( cmTaskMgrH_t h, bool enableFl )
{
cmTmRC_t rc = kOkTmRC;
cmTm_t* p = _cmTmHandleToPtr(h);
unsigned flags = (enableFl ? 0 : kPauseThFl) | kWaitThFl;
if( cmThreadPause(p->mstrThH, flags ) != kOkThRC )
rc = cmErrMsg(&p->err,kThreadFailTmRC,"The master thread failed to %s.",enableFl ? "enable" : "disable" );
return rc;
}
cmTmRC_t cmTaskMgrInstall(
cmTaskMgrH_t h,
unsigned taskId,
const cmChar_t* label,
cmTaskMgrFunc_t func,
cmTaskMgrRecv_t recv)
{
cmTmRC_t rc = kOkTmRC;
cmTm_t* p = _cmTmHandleToPtr(h);
cmTmTask_t* tp = cmMemAllocZ(cmTmTask_t,1);
if( _cmTmTaskFromId(p,taskId) != NULL )
{
rc = cmErrMsg(&p->err,kInvalidArgTmRC,"The task id %i is already in use.",taskId);
goto errLabel;
}
tp->taskId = taskId;
tp->func = func;
tp->recv = recv;
tp->label = cmMemAllocStr(label);
tp->link = p->tasks;
p->tasks = tp;
errLabel:
return rc;
}
cmTmRC_t cmTaskMgrCall(
cmTaskMgrH_t h,
unsigned taskId,
void* funcArg,
unsigned progCnt,
unsigned queueByteCnt,
const cmChar_t* label,
unsigned* retInstIdPtr )
{
cmTmRC_t rc = kOkTmRC;
cmTm_t* p = _cmTmHandleToPtr(h);
cmTmTask_t* tp = NULL;
cmTmInst_t* ip = NULL;
if( retInstIdPtr != NULL )
*retInstIdPtr = cmInvalidId;
// locate the task for this instance
if((tp = _cmTmTaskFromId(p,taskId)) == NULL )
{
rc = cmErrMsg(&p->err,kInvalidArgTmRC,"Task not found for task id=%i.",taskId);
goto errLabel;
}
// allocate a new instance record
ip = cmMemAllocZ(cmTmInst_t,1);
// setup the instance record
ip->instId = p->nextInstId++;
ip->task = tp;
ip->funcArg = funcArg;
ip->progCnt = progCnt;
ip->label = label==NULL ? NULL : cmMemAllocStr(label);
ip->status = kQueuedTmId;
ip->ctlId = kStartTmId;
// create the msg input queue
if(cmTs1p1cCreate( &ip->msgQueH, queueByteCnt, NULL, NULL, p->err.rpt ) != kOkThRC )
{
rc = cmErrMsg(&p->err,kQueueFailTmRC,"The msg input queue creation failed.");
goto errLabel;
}
// insert the new instance at the end of the instance list
if( p->insts == NULL )
p->insts = ip;
else
{
cmTmInst_t* pp = p->insts;
for(; pp != NULL; pp=pp->link )
if( pp->link == NULL )
{
pp->link = ip;
break;
}
}
// enqueue the instance ptr in the input queue
if( cmTs1p1cEnqueueMsg(p->callQueH,&ip,sizeof(ip)) != kOkThRC )
{
rc = cmErrMsg(&p->err,kQueueFailTmRC,"New task instance command enqueue failed.");
goto errLabel;
}
// set the returned instance id
if( retInstIdPtr != NULL )
*retInstIdPtr = ip->instId;
// notify the client that the instance was enqueued
cmTaskMgrStatusArg_t s;
_cmTaskMgrStatusArgSetup(&s,p->statusCbArg,ip->instId,kStatusTmId,kQueuedTmId,progCnt,NULL,NULL,0);
p->statusCb( &s );
errLabel:
return rc;
}
cmTmRC_t cmTaskMgrCtl( cmTaskMgrH_t h, unsigned instId, cmTaskMgrCtlId_t ctlId )
{
cmTmRC_t rc = kOkTmRC;
cmTm_t* p = _cmTmHandleToPtr(h);
cmTmInst_t* ip = NULL;
if((ip = _cmTmInstFromId(p,instId)) == NULL )
{
cmErrMsg(&p->err,kInvalidArgTmRC,"The task instance associated with id %i could not be found.",instId);
goto errLabel;
}
// Once an instance ctlId is set to kKillTmId don't allow it to change.
if( ip->ctlId == kKillTmId )
return rc;
switch(ctlId )
{
case kStartTmId:
// Acting on a 'start' cmd only makes sense if the previous command was 'pause'
if( ip->ctlId == kPauseTmId )
ip->ctlId = kStartTmId;
break;
case kPauseTmId:
// Acting on a 'pause' command only makes sense if the previous command was a 'start'
if( ip->ctlId == kStartTmId )
ip->ctlId = kPauseTmId;
break;
case kKillTmId:
ip->ctlId = kKillTmId;
break;
}
errLabel:
return rc;
}
cmStatusTmId_t cmTaskMgrStatus( cmTaskMgrH_t h, unsigned instId )
{
cmTm_t* p = _cmTmHandleToPtr(h);
cmTmInst_t* ip = NULL;
cmStatusTmId_t status = kInvalidTmId;
if((ip = _cmTmInstFromId(p,instId)) == NULL )
{
cmErrMsg(&p->err,kInvalidArgTmRC,"The task instance associated with id %i could not be found.",instId);
goto errLabel;
}
status = ip->status;
errLabel:
return status;
}
cmTmRC_t cmTaskMgrSendMsg( cmTaskMgrH_t h, unsigned instId, const void* msg, unsigned msgByteCnt )
{
cmTm_t* p = _cmTmHandleToPtr(h);
cmTmRC_t rc = kOkTmRC;
cmTmInst_t* ip = NULL;
if((ip = _cmTmInstFromId(p,instId)) == NULL )
return cmErrMsg(&p->err,kInvalidArgTmRC,"The task instance associated with id %i could not be found.",instId);
if( cmTs1p1cEnqueueMsg(ip->msgQueH, msg, msgByteCnt ) != kOkThRC )
rc = cmErrMsg(&p->err,kQueueFailTmRC,"Task msg enqueue failed.");
return rc;
}
const cmChar_t* cmTaskMgrTaskIdToLabel( cmTaskMgrH_t h, unsigned taskId )
{
cmTm_t* p = _cmTmHandleToPtr(h);
cmTmTask_t* tp;
if((tp = _cmTmTaskFromId(p,taskId)) == NULL )
return NULL;
return tp->label;
}
const cmChar_t* cmTaskMgrInstIdToLabel( cmTaskMgrH_t h, unsigned instId )
{
cmTm_t* p = _cmTmHandleToPtr(h);
cmTmInst_t* ip;
if((ip = _cmTmInstFromId(p,instId)) == NULL )
return NULL;
return ip->label;
}
const void* cmTaskMgrResult( cmTaskMgrH_t h, unsigned instId )
{
cmTm_t* p = _cmTmHandleToPtr(h);
cmTmInst_t* ip = NULL;
if((ip = _cmTmInstFromId(p,instId)) == NULL )
{
cmErrMsg(&p->err,kInvalidArgTmRC,"The task instance associated with id %i could not be found.",instId);
goto errLabel;
}
if( ip->status != kCompletedTmId )
{
cmErrMsg(&p->err,kOpFailTmRC,"The result of a running task (id:%i) may not be accessed.",instId);
goto errLabel;
}
return ip->result;
errLabel:
return NULL;
}
unsigned cmTaskMgrResultByteCount( cmTaskMgrH_t h, unsigned instId )
{
cmTm_t* p = _cmTmHandleToPtr(h);
cmTmInst_t* ip = NULL;
if((ip = _cmTmInstFromId(p,instId)) == NULL )
{
cmErrMsg(&p->err,kInvalidArgTmRC,"The task instance associated with id %i could not be found.",instId);
goto errLabel;
}
if( ip->status != kCompletedTmId )
{
cmErrMsg(&p->err,kOpFailTmRC,"The result byte count of a running task (id:%i) may not be accessed.",instId);
goto errLabel;
}
return ip->resultByteCnt;
errLabel:
return 0;
}
void* cmTaskMgrFuncArg( cmTaskMgrH_t h, unsigned instId )
{
cmTm_t* p = _cmTmHandleToPtr(h);
cmTmInst_t* ip = NULL;
if((ip = _cmTmInstFromId(p,instId)) == NULL )
{
cmErrMsg(&p->err,kInvalidArgTmRC,"The task instance associated with id %i could not be found.",instId);
goto errLabel;
}
if( ip->status != kCompletedTmId )
{
cmErrMsg(&p->err,kOpFailTmRC,"The function argument of a running task (id:%i) may not be accessed.",instId);
goto errLabel;
}
return ip->funcArg;
errLabel:
return NULL;
}
cmTmRC_t cmTaskMgrInstDelete( cmTaskMgrH_t h, unsigned instId )
{
cmTmRC_t rc = kOkTmRC;
cmTm_t* p = _cmTmHandleToPtr(h);
cmTmInst_t* ip = NULL;
if((ip = _cmTmInstFromId(p,instId)) == NULL )
{
cmErrMsg(&p->err,kInvalidArgTmRC,"The task instance associated with id %i could not be found.",instId);
return 0;
}
ip->deleteOnCompleteFl = true;
return rc;
}
void _cmTaskMgrWorkerHelper( cmTaskMgrFuncArg_t* a, cmSelTmId_t selId, cmStatusTmId_t statusId, unsigned prog, const cmChar_t* text )
{
cmTaskMgrStatusArg_t s;
_cmTaskMgrStatusArgSetup(
&s,
a->statusCbArg,
a->instId,
statusId == kInvalidTmId ? kProgTmId : kStatusTmId,
statusId == kInvalidTmId ? kStartedTmId : statusId,
statusId == kInvalidTmId ? prog : 0,
text,NULL,0);
a->statusCb(&s);
}
cmTmWorkerRC_t cmTaskMgrWorkerHandleCommand( cmTaskMgrFuncArg_t* a )
{
cmTmThread_t* trp = a->reserved;
// Check if we should go into the paused or deactivated state.
if( trp->inst->ctlId == kPauseTmId || trp->deactivateFl == true )
{
cmStatusTmId_t prvStatus = kInvalidTmId;
do
{
// Note that it is possible that the state of the task switch from
// paused <-> deactivated during the course of this loop.
// In either case we continue looping but should report the change
// to the client via a status callback.
// change the instance status to reflect the true status
trp->inst->status = trp->deactivateFl ? kDeactivatedTmId : kPausedTmId;
// if the status actually changed then notify the client
if( trp->inst->status != prvStatus )
{
_cmTaskMgrWorkerHelper(a,kStatusTmId,trp->inst->status,0,NULL);
prvStatus = trp->inst->status;
}
// sleep the thread for pauseSleepMs milliseconds
cmSleepMs(a->pauseSleepMs);
// if the task was unpaused while we slept
}while( trp->inst->ctlId == kPauseTmId || trp->deactivateFl==true );
// we are leaving the paused state because we were restarted or killed.
switch( trp->inst->ctlId )
{
case kStartTmId:
// change the instance status to 'started'.
trp->inst->status = kStartedTmId;
// notify the client of the change in state
_cmTaskMgrWorkerHelper(a,kStatusTmId,kStartedTmId,0,NULL);
break;
case kKillTmId:
// if killed the client will be notified in the worker thread wrapper
// function: _cmTmWorkerThreadFunc()
break;
default:
{ assert(0); }
}
}
else // There was no command to handle so check for incoming msg's.
{
if( cmTs1p1cMsgWaiting(trp->inst->msgQueH) )
{
// if the task registered a msg receive callback
if( trp->inst->task->recv != NULL )
{
if( cmTs1p1cDequeueMsg(trp->inst->msgQueH, NULL, 0 ) != kOkThRC )
{
// ?????
// ????? how do we send error messages back to the client
// ??????
return kOkTmwRC;
}
}
else
{
}
return kRecvTmwRC;
}
}
// if ctlId==kKillTmId then the status update will be handled
// when the task custom function returns in _cmTmWorkerThreadFunc()
return trp->inst->ctlId == kKillTmId ? kStopTmwRC : kOkTmwRC;
}
cmTmRC_t cmTaskMgrWorkerSendStatus( cmTaskMgrFuncArg_t* a, cmStatusTmId_t statusId )
{
_cmTaskMgrWorkerHelper(a,kStatusTmId,statusId,0,NULL);
return kOkTmRC;
}
cmTmRC_t cmTaskMgrWorkerSendProgress( cmTaskMgrFuncArg_t* a, unsigned prog, const cmChar_t* text )
{
_cmTaskMgrWorkerHelper(a,kProgTmId,kInvalidTmId,prog,text);
return kOkTmRC;
}
cmTmRC_t cmTaskMgrWorkerSendProgressV( cmTaskMgrFuncArg_t* a, unsigned prog, const cmChar_t* fmt, va_list vl )
{
cmTmThread_t* trp = a->reserved;
cmTsVPrintfP(trp->text,fmt,vl);
return cmTaskMgrWorkerSendProgress(a,prog,trp->text);
}
cmTmRC_t cmTaskMgrWorkerSendProgressF( cmTaskMgrFuncArg_t* a, unsigned prog, const cmChar_t* fmt, ... )
{
va_list vl;
va_start(vl,fmt);
cmTmRC_t rc = cmTaskMgrWorkerSendProgressV(a,prog,fmt,vl);
va_end(vl);
return rc;
}
cmTmRC_t cmTaskMgrWorkerError( cmTaskMgrFuncArg_t* a, unsigned rc, const cmChar_t* text )
{
_cmTaskMgrWorkerHelper(a, kErrorTmId, kInvalidTmId, rc, text);
return rc;
}
cmTmRC_t cmTaskMgrWorkerErrorV( cmTaskMgrFuncArg_t* a, unsigned rc, const cmChar_t* fmt, va_list vl )
{
cmTmThread_t* trp = a->reserved;
cmTsVPrintfP(trp->text,fmt,vl);
return cmTaskMgrWorkerError(a,rc,trp->text);
}
cmTmRC_t cmTaskMgrWorkerErrorF( cmTaskMgrFuncArg_t* a, unsigned rc, const cmChar_t* fmt, ... )
{
va_list vl;
va_start(vl,fmt);
cmTmRC_t rc0 = cmTaskMgrWorkerErrorV(a,rc,fmt,vl);
va_end(vl);
return rc0;
}
cmTmRC_t cmTaskMgrWorkerSetResult( cmTaskMgrFuncArg_t* a, void* result, unsigned resultByteCnt )
{
cmTmThread_t* trp = a->reserved;
trp->inst->result = result;
trp->inst->resultByteCnt = resultByteCnt;
return kOkTmRC;
}
unsigned cmTaskMgrWorkerMsgByteCount( cmTaskMgrFuncArg_t* a )
{
cmTmThread_t* trp = a->reserved;
return cmTs1p1cDequeueMsgByteCount(trp->inst->msgQueH);
}
unsigned cmTaskMgrWorkerMsgRecv( cmTaskMgrFuncArg_t* a, void* buf, unsigned bufByteCnt )
{
cmTmThread_t* trp = a->reserved;
unsigned retVal = bufByteCnt;
switch( cmTs1p1cDequeueMsg(trp->inst->msgQueH, buf, bufByteCnt ) )
{
case kOkThRC:
break;
case kBufEmptyThRC:
retVal = 0;
break;
case kBufTooSmallThRC:
retVal = cmInvalidCnt;
break;
default:
{ assert(0); }
}
return retVal;
}
cmTmRC_t cmTaskMgrWorkerMsgSend( cmTaskMgrFuncArg_t* a, const void* buf, unsigned bufByteCnt )
{
cmTmThread_t* trp = a->reserved;
return _cmTmEnqueueStatusMsg1(trp->p,trp->inst->instId,kMsgTmId,trp->inst->status,0,NULL,buf,bufByteCnt);
}
//-----------------------------------------------------------------------------
enum { kMaxTestInstCnt = 3 };
typedef struct cmTmTestInst_str
{
unsigned instId;
} cmTmTestInst_t;
typedef struct cmTmTestApp_str
{
cmErr_t* err;
cmTmTestInst_t insts[kMaxTestInstCnt];
} cmTmTestApp_t;
void _cmTmTestReportStatus( cmRpt_t* rpt, const cmTaskMgrStatusArg_t* s )
{
cmRptPrintf(rpt,"inst:%i ",s->instId );
switch( s->selId )
{
case kStatusTmId:
{
const cmChar_t* label = cmTaskMgrStatusIdToLabel(s->statusId);
cmRptPrintf(rpt,"status '%s'",label);
}
break;
case kProgTmId:
cmRptPrintf(rpt,"prog %i",s->prog);
break;
case kErrorTmId:
cmRptPrintf(rpt,"error %s",cmStringNullGuard(s->msg));
break;
default:
{ assert(0); }
}
cmRptPrintf(rpt,"\n");
}
// Test client status callback function.
void _cmTmTestStatusCb( const cmTaskMgrStatusArg_t* s )
{
// s.arg set from cmTaskMgrCreate( ..., statusCbArg, ...);
cmTmTestApp_t* app = (cmTmTestApp_t*)s->arg;
unsigned i;
// locate the instance record assoc'd with this callback
for(i=0; i<kMaxTestInstCnt; ++i)
if( app->insts[i].instId == s->instId )
break;
if( i==kMaxTestInstCnt )
cmRptPrintf(app->err->rpt,"instId %i not found.\n",s->instId);
_cmTmTestReportStatus(app->err->rpt,s);
}
// Test worker function.
void _cmTmTestFunc(cmTaskMgrFuncArg_t* arg )
{
if( cmTaskMgrWorkerHandleCommand(arg) == kStopTmwRC )
return;
unsigned prog = 0;
for(; prog<arg->progCnt; ++prog)
{
if( cmTaskMgrWorkerHandleCommand(arg) == kStopTmwRC )
break;
cmSleepMs(1000);
if( cmTaskMgrWorkerSendProgress(arg,prog,NULL) == kStopTmwRC )
break;
}
}
cmTmRC_t cmTaskMgrTest(cmCtx_t* ctx)
{
cmTmRC_t rc = kOkTmRC;
cmTaskMgrH_t tmH = cmTaskMgrNullHandle;
unsigned threadCnt = 2;
unsigned queueByteCnt = 1024;
unsigned pauseSleepMs = 50;
unsigned nextInstId = 0;
unsigned taskId = 0;
const cmChar_t* taskLabel = "Task Label";
cmTmTestApp_t app;
char c;
memset(&app,0,sizeof(app));
app.err = &ctx->err;
// create the task mgr
if( cmTaskMgrCreate( ctx,&tmH,_cmTmTestStatusCb,&app,threadCnt,queueByteCnt,pauseSleepMs) != kOkTmRC )
{
rc = cmErrMsg(&ctx->err,kTestFailTmRC,"Task mgr create failed.");
goto errLabel;
}
// install a task
if( cmTaskMgrInstall(tmH, taskId, taskLabel, _cmTmTestFunc, NULL ) != kOkTmRC )
{
rc = cmErrMsg(&ctx->err,kTestFailTmRC,"Task mgr task install failed.");
goto errLabel;
}
// go into interactive mode
printf("q=quit e=enable c=call i=idle\n");
while((c = getchar()) != 'q')
{
switch(c)
{
case 'i':
cmTaskMgrOnIdle(tmH);
cmRptPrintf(&ctx->rpt,"idled\n");
break;
case 'e':
{
// toggle the enable state of the task mgr.
bool fl = !cmTaskMgrIsEnabled(tmH);
if( cmTaskMgrEnable(tmH,fl) != kOkTmRC )
rc = cmErrMsg(&ctx->err,kTestFailTmRC,"Test enable failed.");
else
cmRptPrintf(&ctx->rpt,"%s\n", fl ? "enabled" : "disabled" );
}
break;
case 'c':
if( nextInstId < kMaxTestInstCnt )
{
void* funcArg = app.insts + nextInstId;
unsigned progCnt = 5;
if( cmTaskMgrCall( tmH, taskId, funcArg, progCnt, queueByteCnt, "My Inst", &app.insts[nextInstId].instId ) != kOkTmRC )
rc = cmErrMsg(&ctx->err,kTestFailTmRC,"Test call failed.");
else
{
++nextInstId;
cmRptPrintf(&ctx->rpt,"called\n");
}
}
}
}
errLabel:
// destroy the task mgr
if( cmTaskMgrDestroy(&tmH) != kOkTmRC )
rc = cmErrMsg(&ctx->err,kTestFailTmRC,"Task mgr destroy failed.");
return rc;
}
Referens i nytt ärende View Git Blame Copy Permalink