/** @file OSX_TAsk.c @brief Generic Purpose Task Template implementation. Copyright 2006~2010 Digital STREAM Technology, Inc. All Rights Reserved */ #include "DHL_OSAL.h" #include "DHL_DBG.h" #include "OSX_Task.h" //#include "DHL_DBG_Priv.h" //#include "DHL_OSAL_Config.h" //#include ////#include //#include "mmac/types.h" //#include "mmac/rtos.h" DHL_MODULE("osx", 0); #if COMMENT ____Config____(){} #endif #define USE_STRICT_CHECK 1 /* 엄격한 체크 수행. 개발 중에만 사용하면 될 것으로 보임. */ #if COMMENT ____Types____(){} #endif /* 태스크 이름 최대 길이. */ #define OSX_MAX_TASK_NAME 8 /* task command proc 에서 사용할 argument의 최대 갯수. 너무 많으면 send message에서 memcpy overhead 문제가 있음. 경험상 4 정도면 충분하며, 더 많은 데이터를 전달하고자 한다면 pointer를 전달하고 synchronous call을 사용해야 한다. */ #define OSX_MAX_CMD_PARAMS OSX_MAX_USER_PARAMS /* 태스크 msg que의 디폴트 크기. task start 할 때 caller가 지정한다. 지정하지 않을 경우 디폴트로 이 값이 적용된다. */ #define OSX_DEFAULT_MSG_QUE_SIZE 20 /* osx task generation serial number type. value '0' means task is not valid. (not initialized, not created, ...) */ typedef UINT8 T_OSX_TASK_SN; // allocated 임을 나타내는 지시어. typedef UINT8 T_OSX_TAS_MAGIC; // validity를 나타내는 지시어. /* */ #define OSX_TASK_MAGIC 0xA6 /* Command schedule 정보를 보관하는 구조체. */ typedef struct { T_OSX_TASK_CMD idCmd; // command id BOOLEAN used; // TRUE if this entry is used (and active) UINT32 period; // interval (if periodic execution), or delay (if delayed execution) // unit is in ms UINT32 start; // time of schedule registration. // if this cmd executed periodically, 'start' is reset to NOW at every execution. UINT16 flags; // flags F_OSX_TASK_PROC fn; // command execution function UINT32 params[OSX_MAX_CMD_PARAMS]; // command arguements } S_OSX_CMD_SCHED; struct S_OSX_TASK_t; // forward declare typedef struct { struct S_OSX_TASK_t *xt; // back link to parent osx task info //-------- OS handles -------- DHL_OS_TASK_ID tid; // OSAL task id (handle) DHL_OS_MSGQ_ID msgQue; // message queue of this task DHL_OS_SEMA_ID semAck; // binary semaphore for returning ACK. DHL_OS_SEMA_ID mutexAck; // mutex for guard semAck //-------- some params -------- int nCmdParam; // number of command parameter. copied from xt->setting->num_cmd_param. // OSX_MAX_CMD_PARAMS 보다 클 수 없다. } S_OSX_TASK_PUBLIC; typedef struct S_OSX_TASK_t { T_OSX_TAS_MAGIC magic; // validity indicator // OSX_TASK_MAGIC 값을 가지면 이 구조체 정보는 allocated 되었으며 valid 함을 의미. T_OSX_TASK_SN serial; // 초기화 일련번호. 0이면 이 task 정보는 미사용(not-allocated)이라는 의미임. // 이 serial 번호는 task가 생성될 때 값이 부여되고, shutdown되면 0이 된다. // 이 serial 번호는 현재 동작 중인 task 들과 중복되지 않는다. /* 할당 순서: serial = s#; magic = MAGIC_VALUE; see p_alloc_osx_task(), OSX_TaskStart() 해제 순서: magic = 0; serial = 0; see p_shutdown_task(), p_free_osx_task() */ UINT8 index; // task list 에서의 순서 index. array 라면 array index임. S_OSX_TASK_PUBLIC pti; // public task information. // 이 정보들은 임의 task에서 필요로 하는 것들이다. // 여기에 접근하려면 mutex가 필요하다. //-------- state -------- /* task 이름 */ char name[OSX_MAX_TASK_NAME+1]; /* task 초기화 설정 파라미터 */ S_OSX_TASK_INIT_SETTING setting; // user settings parameter for task init int nMaxQueSize; // copied from setting->msg_que_size. T_OSX_TASK_CMD curServicedCmdId; // 현재 task에서 서비스 중인 cmd id. // task가 idle 상태일 경우에는 0이 된다. //struct OSX_TASK_t *next; // for management.. next task info.. //-------- 예약 명령 지원 코드 -------- int nMaxSlot; // maximum number of element of sclist. (size of sclist) int nScheduledCmd; // 현재 등록된 예약 명령 갯수. // nMaxSlot 보다 클 수 없다. int maxActiveIndex; // 예약 명령 리스트에서 현재 active 한 cmd의 배열 인덱스 값의 최대값. // list 중간에 있는 cmd 를 stop 시켜 없애면 배열 가운데가 빈 상태가 되는데, // 이 경우 nActiveTimer와 무관한 값이 될 수 있다. // main task에서 이 값을 알고 있으면 loop 오버헤드를 약간 줄일 수 있다. S_OSX_CMD_SCHED *sclist; // 예약 명령 (scheduled command) 리스트 정보. } S_OSX_TASK; /* internal task command id. S_OSX_TASK_CMD::idCmd 에서 사용자 command 와 같이 사용된다. 여기의 값들은 사용자가 user command id로 사용할 수 없다. 사용하려고 하면 API 안에서 에러가 발생한다. */ typedef enum //E_OSX_TASK_CMD_t { eTASK_CMD_BEGIN = OSX_CMD_RESERVED, // this is just marker. eTASK_CMD_DELETE, // Timer entry 하나를 삭제한다. // 삭제(취소)할 command id는 params[0]을 통해 전달한다. eTASK_CMD_DELETE_ALL, // 모든 예약 cmd entry 삭제. // eTASK_CMD_SHOW, eTASK_CMD_QUERY, eTASK_CMD_SYNC, // 특정 명령이 wait 모드(blocking mode, synchronous mode)로 동작해야한 하는 경우 // 이 command를 사용하면 task 실행과 동기화가 되어 // wait 모드의 효과가 난다. // app 에서 직접 semaphore, mutex 등을 관리하는 것이 번거로울 경우 // 간단하게 이 명령을 활용하면 된다. eTASK_CMD_SHUTDOWN, } E_OSX_TASK_CMD; /* task 명령 메시지 구조체. 실제로 OS의 SendMessage를 통해 전달되는 메시지이다. 이 구조체 크기가 커질 수록 SendMessage 내의 부하가 비례하여 커진다. 따라서 불필요한 필드는 추가하지 않도록 신경을 써야 한다. */ typedef struct { T_OSX_TASK_CMD idCmd; // Command ID // this command ID should be unique in S_OSX_TASK. // 여기에 사용되는 값들은 일반 숫자 값이거나 E_OSX_TASK_CMD 내부 명령이 사용된다. T_OSX_TASK_SN snTask; // task serial number UINT16 flags; // 각종 flag. UINT32 nDelayMs; // timer expire 주기. // eTASK_CMD_DELETE 인 경우 pResult 역할을 한다. F_OSX_TASK_PROC func; // 이 command id에 의해 실행될 명령 함수. UINT32 params[OSX_MAX_CMD_PARAMS]; // cmd parameter (func argument) // 이 params는 가변 길이 배열이다. // task 초기화 과정에서 특정 size(갯수)로 고정된다. // 따라서 params 필드가 이 S_OSX_TASK_CMD 구조체의 맨 뒤에 위치해야 한다. } S_OSX_TASK_CMD; /** S_OSX_TASK_CMD 의 크기는 가변이다. 정확한 size는 nCmdParam 값에 따라 달라진다. SendMessage 할 때 그냥 최대 지원 갯수인 OSX_MAX_CMD_PARAMS 를 사용하지 않는 이유는 불필요한 memcopy overhead를 줄이기 위함이다. */ #define OSX_COMMAND_SIZE(num_param) (\ sizeof(S_OSX_TASK_CMD) \ - sizeof(UINT32)*OSX_MAX_CMD_PARAMS \ + sizeof(UINT32)*(num_param) \ ) #ifndef min #define min(a,b) ((a)<(b)?(a):(b)) #endif /* H_OSX_TASK 핸들 구성. task list의 index와 serial number로 구성한다. 최대 task 갯수는 256 으로 한정. 8 비트면 됨. serial 번호는 0~0xFF 면 충분. 8비트면 됨. MSB 16 bits: osx task list index | 0x100 LSB 16 bits: osx task generation serial */ #define MAKE_OSX_HANDLE(index, serial) (0x10000 | (((index)&0xff)<<8UL) | ((serial)&0xff)) #define INDEX_FROM_HANDLE(handle) ( ((handle)>>8) & 0xff ) #define SERIAL_FROM_HANDLE(handle) ( (handle)&0xff ) #if COMMENT ____Variables____(){} #endif /* 생성된 모든 osx task 리스트. S_OSX_TASK *s_osx_task_list; */ /* osx task list 정보. */ S_OSX_TASK s_osx_tasks[OSX_MAX_TASK]; /* task serial 번호 발급 용 변수. 이 변수의 값은 가장 마지막에 발급한 번호임. serial 0 은 발급하면 안된다. '미사용'의 의미로 사용되므로. */ T_OSX_TASK_SN s_osx_serial; /* osx task 정보에 대한 mutex. 사용되는 곳: 1. 최초에 task start 하는 시점에서만 사용되며, (called in arbitrary task) 그 이후에는 생성된 task 에서만 사용하는 것으로 한다. 2. 임의 task에서 task public 정보를 가져올 때 사용된다. */ DHL_OS_SEMA_ID s_osx_mutex; S_OSX_TASK *s_osx_traced; // trace 하고자 하는 task handle. // 전체 task 리스트를 확인한 후에 핸들 값을 지정해 주면 된다. /* 이 함수는 임의 task에서 호출된다. */ static S_OSX_TASK *p_alloc_osx_task(void) { int i; S_OSX_TASK *xt = NULL; // 맨 먼저 serial을 등록하는 task가 owner가 된다. DHL_OS_TakeSemaphore(s_osx_mutex, DHL_TIMEOUT_FOREVER); for (i=0; s_osx_tasks[i].serial==0 && imagic = 0; xt->serial = 0; DHL_OS_GiveSemaphore(s_osx_mutex); } static void p_validate_osx_task(S_OSX_TASK *xt) { DHL_OS_TakeSemaphore(s_osx_mutex, DHL_TIMEOUT_FOREVER); xt->magic = OSX_TASK_MAGIC; DHL_OS_GiveSemaphore(s_osx_mutex); } static void p_invalidate_osx_task(S_OSX_TASK *xt) { DHL_OS_TakeSemaphore(s_osx_mutex, DHL_TIMEOUT_FOREVER); xt->magic = 0; DHL_OS_GiveSemaphore(s_osx_mutex); } #if COMMENT ______Func____(){} #endif static BOOL s_module_init; static void osx_module_init(void); static int p_list_all_osx_task(H_OSX_TASK *list) { int i; int n_task = 0; DHL_OS_TakeSemaphore(s_osx_mutex, DHL_TIMEOUT_FOREVER); for (i=0; i= OSX_MAX_TASK) { dprint(0, "!! invalid osx task handle 0x%x\n", handle); goto end; } xt = &s_osx_tasks[index]; if (xt->serial != SERIAL_FROM_HANDLE(handle) || xt->magic != OSX_TASK_MAGIC) { dprint(0, "!! wrong osx task info: handle %x, serial %x magic %x\n", handle, xt->serial, xt->magic); goto end; } if (xt->pti.tid == 0) { dprint(0, "!! task not initialized!\n"); goto end; } *pti = xt->pti; ret = pti; // return pointer of caller's pti copy, NOT &xt->pti. end: DHL_OS_GiveSemaphore(s_osx_mutex); return ret; } #if USE_STRICT_CHECK static void p_assert_in_task(S_OSX_TASK *xt, const char *fn) { DHL_OS_TASK_ID tid = DHL_OS_GetTaskID(); if (!xt || tid != xt->pti.tid) { dprint(0, "!! %s should be called inside task! xt %x, tid %x != xt's %x\n", fn, xt, tid, xt?xt->pti.tid:0); DHL_ASSERT(FALSE, ""); } } #endif #if COMMENT ______TaskMethod____(){} #endif /* add one scheduled command */ static DHL_RESULT p_add_scheduled_cmd(S_OSX_TASK *xt, S_OSX_TASK_CMD *cmd) { int i; int iSelected, iEmpty; #if USE_STRICT_CHECK p_assert_in_task(xt, __func__); #endif if (cmd->nDelayMs == 0) { // 에러. dprint(0, "!! task %s: schedule cmd with zero delay\n", xt->name); return DHL_FAIL_INVALID_PARAM; } if ((cmd->flags & eTASK_FLAG_Repeat) && (cmd->nDelayMs <= 2)) { dprint(0, "!! task %s: too short period %d\n", xt->name, cmd->nDelayMs); // 일단 그대로 진행. } // id를 검색하면서, 동시에 empty slot도 찾는다. // 해당 ID가 이미 사용중이라면 갱신모드.. iSelected = -1; iEmpty = -1; for (i=0; inMaxSlot; i++) { if (xt->sclist[i].used && xt->sclist[i].idCmd == cmd->idCmd) { // 이미 사용중이다.. // 새로운 parameter로 update하고 함수 종료.. if (s_osx_traced == xt) dprint(0, "!! cmd (id 0x%x) already scheduled. updated..\n", cmd->idCmd); iSelected = i; break; } else if (xt->sclist[i].used == 0) { // 비어있는 slot을 찾는다.. if (iEmpty < 0) iEmpty = i; } } if (iSelected < 0) // 동일한 iSelected = iEmpty; if (iSelected >= 0) { S_OSX_CMD_SCHED *psc = &xt->sclist[iSelected]; if (psc->used == FALSE) { xt->nScheduledCmd++; } psc->idCmd = cmd->idCmd; psc->period = cmd->nDelayMs; psc->fn = cmd->func; for (i=0; ipti.nCmdParam; i++) psc->params[i] = cmd->params[i]; for (; iparams[i] = 0; psc->flags = cmd->flags; psc->start = DHL_OS_GetMsCount(); psc->used = TRUE; // maxActiveIndex를 알아두면 TimerTask에서 loop를 돌때 도움이 된다. if (xt->maxActiveIndex < iSelected) xt->maxActiveIndex = iSelected; if (s_osx_traced == xt) dprint(0, " add: cmd[%d] id 0x%x, total %d active\n", iSelected, cmd->idCmd, xt->nScheduledCmd); } else { //if (s_osx_traced == xt) dprint(0, "!! task %s: no more cmd slot for cmd 0x%x\n", xt->name, cmd->idCmd); // it may be available some time later because oneshot timer will die.. } return iSelected >= 0 ? DHL_OK : DHL_FAIL_NOT_AVAILABLE; } /* delete one timer entry. this function should be called in timer task. */ static DHL_RESULT p_del_scheduled_cmd(S_OSX_TASK *xt, T_OSX_TASK_CMD idCmd) { int i; DHL_RESULT dhr = DHL_FAIL_NOT_FOUND; int maxActiveIndex = -1; #if USE_STRICT_CHECK p_assert_in_task(xt, __func__); #endif if (idCmd == (T_OSX_TASK_CMD)-1) { // delete all.. if (s_osx_traced == xt) dprint(0, "delete all sch.cmd\n"); memset(&xt->sclist, 0, xt->nMaxSlot*sizeof(S_OSX_CMD_SCHED)); xt->nScheduledCmd = 0; xt->maxActiveIndex = -1; dhr = DHL_OK; } for (i=0;i<=xt->maxActiveIndex;i++) { if (xt->sclist[i].used == FALSE) continue; if (xt->sclist[i].idCmd == idCmd) { // delete 대상 command. memset(&xt->sclist[i], 0, sizeof(S_OSX_CMD_SCHED)); xt->nScheduledCmd--; if (s_osx_traced == xt) dprint(0, "delcmd: index: %d, ID: %d\n", i, idCmd); dhr = DHL_OK; } else { maxActiveIndex = i; } } xt->maxActiveIndex = maxActiveIndex; return dhr; } /* show timer sclist */ static void p_show_scheduled_cmd(S_OSX_TASK *xt, S_OSX_TASK_CMD *cmd) { DHL_RESULT dhlResult; int i, k; char buf[80]; #if USE_STRICT_CHECK p_assert_in_task(xt, __func__); #endif DHL_OS_Printf("----- Task %x, handle %x -----\n", xt, MAKE_OSX_HANDLE(xt->index, xt->serial)); DHL_OS_Printf(" '%s', prio %d, max slot %d\n", xt->name, xt->setting.priority, xt->nMaxSlot); for (i=0; i<=xt->maxActiveIndex; i++) { char *fname = NULL; if (!xt->sclist[i].used) continue; // dhl_dbg_find_sym_by_addr((UINT32)xt->sclist[i].fn, &fname); for (buf[0]=0, k=0; kpti.nCmdParam); k++) sprintf(buf+strlen(buf), "%x ", xt->sclist[i].params[k]); DHL_OS_Printf(" (%02d) ID %d, fn %x(%s) arg (%s), %d ms, f%x %s%s\n", i, xt->sclist[i].idCmd, xt->sclist[i].fn, fname ? fname : "?", buf, xt->sclist[i].period, //xt->sclist[i].period, xt->sclist[i].flags, xt->sclist[i].flags & eTASK_FLAG_Delayed ? "delayed " : "", xt->sclist[i].flags & eTASK_FLAG_Repeat ? "repeat " : ""); } DHL_OS_Printf("\n"); } /* 사용자 명령을 호출한다. 바로 수행 명령일 수도 있고, 예약 명령일 수도 있음. */ void p_callback_user_func(S_OSX_TASK *xt, T_OSX_TASK_CMD idCmd, UINT16 flags, F_OSX_TASK_PROC pFn, UINT32 *params) { // task callback이 불리는 동안에는 어떤 task id가 service 중인지 기록을 남겨두자. xt->curServicedCmdId = idCmd; if (s_osx_traced == xt) dprint(0, "\n---------- ExecBegin: %x, cmd 0x%x, fn 0x%x, param[0] 0x%x \n", xt, idCmd, pFn, params[0]); if (xt->pti.nCmdParam <= 2) pFn(idCmd, params[0], params[1]); else if (xt->pti.nCmdParam <= 4) pFn(idCmd, params[0], params[1], params[2], params[3]); else // OSX_MAX_USER_PARAMS 만큼 지원해야 한다. 이것은 programmatic 하게 구현 어려움. pFn(idCmd, params[0], params[1], params[2], params[3], params[4], params[5], params[6], params[7]); if (s_osx_traced == xt) dprint(0, "---------- ExecEnd: %x, ID %d \n\n", xt, idCmd); xt->curServicedCmdId = 0; // idCmd 0은 여기서 처럼 특별한 의미로 사용하므로, 일반 command ID로는 reserve 해야 한다. } void p_shutdown_task(S_OSX_TASK *xt) { #if USE_STRICT_CHECK p_assert_in_task(xt, __func__); #endif dprint(2, "task stop requested..\n"); // 더 이상 새로운 task 명령이 전달되지 않도록 선 조치. invalidate. //xt->magic = 0; p_validate_osx_task(xt); DHL_OS_DeleteSemaphore(xt->pti.semAck); xt->pti.semAck = 0; DHL_OS_DeleteSemaphore(xt->pti.mutexAck); xt->pti.mutexAck = 0; DHL_OS_DeleteMessageQueue(xt->pti.msgQue); xt->pti.msgQue = 0; dprint(2, "task about to shutdown..\n"); xt->pti.tid = 0; // osx task 구조체를 empty 하여 다른 task에 할당될 수 있도록 조치. p_free_osx_task(xt); DHL_OS_SelfDeleteTask(); } #if COMMENT ____Task____() {} #endif /* task main. */ static void p_task_main(S_OSX_TASK *xt) { int i; DHL_RESULT result; S_OSX_TASK_CMD cmd; int nMinRemainingMs; // 가장 먼저 실행 될 예약 명령어 까지의 시간. UINT32 uNow; while(xt->pti.tid == 0) // wait until creator returns DHL_OS_CreateTask api. DHL_OS_Delay(10); dprint(1, "osx task start, xt %x, s# %x, name '%s', handle %x\n", xt, xt->serial, xt->name, MAKE_OSX_HANDLE(xt->index, xt->serial)); while (TRUE) { nMinRemainingMs = 0x7fffffff; // signed INT32 value의 최대값.. //--------- timer expiration timeout 체크 ------------ // 현재 가장 가까운 시간 내에 expire 될 timer를 찾는다.. uNow = DHL_OS_GetMsCount(); for (i=0; i<=xt->maxActiveIndex; i++) { int nRemainMs; if (xt->sclist[i].used == 0) continue; nRemainMs = (int) (xt->sclist[i].start + xt->sclist[i].period - uNow); // 이미 expire 된 timer라면 remain은 negative 값을 가질 것임.. if (nMinRemainingMs > nRemainMs) { nMinRemainingMs = nRemainMs; } } //--------- wait message with/without timeout ------------ /* nMinRemainingMs가 0이라면 바로 실행해야 할 예약 명령이 있다는 의미이다. 이 값은 <0 일 수도 있다. (이미 실행해야 할 시간이 경과한 경우) 설령 이미 expire 된 entry가 있다고 하더라도 task의 실행 부하가 많아서 command를 아예 못받는 상황이 되지 않도록, msgque 는 반드시 한번은 체크를 수행하고 나서 예약 명령 처리해 준다. 이 경우 ReceiveMessage는 No-wait 모드로 실행된다. */ // it can be negative. so adjust required. if (nMinRemainingMs < 0) nMinRemainingMs = 0; // 아직 남은 시간이 많기 때문에 Sleep을 한다. if (nMinRemainingMs < 0x7fffffff) { if (s_osx_traced == xt) dprint(2, "task enter sleep for %d ms..\n", nMinRemainingMs); result = DHL_OS_ReceiveMessage(xt->pti.msgQue, &cmd, nMinRemainingMs); } else { // 처리해야 할 남은 timer가 없다면 active 될때까지 무한정 기다리기만 하면 된다. // if (s_osx_traced == xt) dprint(2, "task wait msg..\n"); result = DHL_OS_ReceiveMessage(xt->pti.msgQue, &cmd, DHL_TIMEOUT_FOREVER); } //--------- process message if we got new one ------------ if (result == DHL_OK) // we got command { // check task serial number. if (cmd.snTask != xt->serial) { dprint(0, "!! cmd %x (sn %x) is not for our task (sn %x)\n", cmd.idCmd, cmd.snTask, xt->serial); // shutdown 되기 전에 send 된 command가 이제서야 처리되는 것일 수 있음. // 이 명령은 그냥 조용히 ignore 한다. } // add / delete / query / shutdown else if (cmd.idCmd < eTASK_CMD_BEGIN) { // 내부 명령이 아니면 실행 명령임. // delay가 아니라면 바로 실행. if (!(cmd.flags & eTASK_FLAG_Delayed)) { // 해당 case: // eTASK_FLAG_Normal, eTASK_FLAG_NowAndRepeat p_callback_user_func(xt, cmd.idCmd, cmd.flags, cmd.func, cmd.params); } // delay 또는 repeat 옵션인 경우 list에 등록해야 한다. // 단 이 경우에는 nDelayMs가 0이 아니어야 함. if ((cmd.flags & eTASK_FLAG_Repeat) || (cmd.flags & eTASK_FLAG_Delayed)) { // 해당 case: // eTASK_FLAG_Delayed, eTASK_FLAG_WaitAndRepeat, eTASK_FLAG_NowAndRepeat result = p_add_scheduled_cmd(xt, &cmd); if (s_osx_traced == xt) OSX_TaskShow(MAKE_OSX_HANDLE(xt->index, xt->serial)); } } else if (cmd.idCmd == eTASK_CMD_DELETE) { // delete 인 경우는 삭제할 cmd id가 params[0]을 통해 전달 된다. result = p_del_scheduled_cmd(xt, (T_OSX_TASK_CMD)cmd.params[0]); } else if (cmd.idCmd == eTASK_CMD_DELETE_ALL) { result = p_del_scheduled_cmd(xt, (T_OSX_TASK_CMD)eTASK_CMD_DELETE_ALL); } else if (cmd.idCmd == eTASK_CMD_SYNC) { ; // 특별히 처리할 것 없음. 그냥 아래에서 ack만 주면 됨. } else if (cmd.idCmd == eTASK_CMD_SHOW) { p_show_scheduled_cmd(xt, &cmd); } else if (cmd.idCmd == eTASK_CMD_QUERY) { // not yet.. } else if (cmd.idCmd == eTASK_CMD_SHUTDOWN) { break; } if (cmd.idCmd == eTASK_CMD_SYNC) { DHL_OS_GiveSemaphore(xt->pti.semAck); } } else if (result == DHL_FAIL_TIMEOUT) { // 이것은 에러가 아니다. 예약 명령 중 하나를 실행할 때가 되었음을 나타낸다. } else { dprint(0, "!! task rx msg result 0x%x\a\n", result); } //-------- scheduled cmd list 처리 --------------- /* 예약 명령 리스트를 모두 체크하여 시간 경과 된 명령들을 모두 처리해 준다. */ for (i=0; i<=xt->maxActiveIndex; i++) { S_OSX_CMD_SCHED *psc = &xt->sclist[i]; if (psc->used == FALSE) continue; // 지정 시간이 경과되었는지 체크. Timeout 되었으면 Timer함수 수행. // if (DHL_OS_GetMsCount() - psc->start > psc->period) // Timer expired.. { S_OSX_CMD_SCHED schcmd = *psc; BOOL bOneShot = (schcmd.flags & eTASK_FLAG_Repeat) ? 0 : 1; if (bOneShot) { // 1회 실행 명령. 이 entry를 삭제 한다. memset(psc, 0, sizeof(S_OSX_CMD_SCHED)); xt->nScheduledCmd--; } else { // 반복 실행 명령. timer counter를 리셋시킨다. psc->start = DHL_OS_GetMsCount(); } p_callback_user_func(xt, schcmd.idCmd, schcmd.flags, schcmd.fn, schcmd.params); if (bOneShot) if (s_osx_traced == xt) dprint(0, "oneshot cmd %x serviced\n", schcmd.idCmd); } } // end for (sch cmd list) } p_shutdown_task(xt); } #if COMMENT ____API____(){} #endif DHL_RESULT OSX_TaskRegisterCmdV(H_OSX_TASK handle, T_OSX_TASK_CMD nIdCmd, UINT32 nDelayMs, UINT16 flags, F_OSX_TASK_PROC func, va_list param) { DHL_RESULT dhr; S_OSX_TASK_PUBLIC pti0, *pti; S_OSX_TASK_CMD cmd; DHL_OS_TASK_ID tid = DHL_OS_GetTaskID(); va_list arg; int i; pti = p_get_osx_task(handle, &pti0); // get public task info if (pti == NULL) return DHL_FAIL_INVALID_HANDLE; if (func == NULL) { dprint(0, "!! func is null [cmd %x]!\n", nIdCmd); return DHL_FAIL_INVALID_PARAM; } if (nIdCmd >= eTASK_CMD_BEGIN || nIdCmd == 0) { dprint(0, "!! cmd id 0x%x is in reserved range.\n", nIdCmd); DHL_ASSERT(FALSE, ""); return DHL_FAIL_INVALID_PARAM; } if (nDelayMs == 0 && (flags & eTASK_FLAG_Repeat)) { dprint(0, "!! interval timer should have period.\n"); DHL_ASSERT(FALSE, ""); return DHL_FAIL_INVALID_PARAM; } dprint(2, "%s: (cmd 0x%x, period %d, flags 0x%x)\n", __func__, nIdCmd, nDelayMs, flags); memset(&cmd, 0, sizeof(S_OSX_TASK_CMD)); cmd.idCmd = nIdCmd; cmd.snTask = SERIAL_FROM_HANDLE(handle); cmd.nDelayMs = nDelayMs; cmd.func = func; cmd.flags = flags; for (i=0; inCmdParam; i++) cmd.params[i] = va_arg(param, UINT32); if (tid != pti->tid) { // cmd 자체는 최대 갯수의 user param을 포함하고 있지만 // OSAL 내부에서 필요한 만큼만 복사를 해 갈 것이다. dhr = DHL_OS_SendMessage(pti->msgQue, &cmd, sizeof(cmd)); // error check.. if (dhr == DHL_FAIL_BUSY) { dprint(0, "!! %s queue full\a\n", __func__); // 0x18: DHL_FAIL_BUSY 는 queue full 나면 발생함. } else if (dhr) { dprint(0, "!! %s send cmd err %x\a\n", __func__, dhr); } } else { // current task is THE Task that we can add. // so, we can directly modify task variable. // dhr = p_add_scheduled_cmd(pti->xt, &cmd); } return dhr; } /* Task에 명령 예약. 반복 설정 가능. */ DHL_RESULT OSX_TaskScheduleCmd(H_OSX_TASK handle, T_OSX_TASK_CMD nIdCmd, UINT32 nDelayMs, UINT16 flags, F_OSX_TASK_PROC func, ...) { DHL_RESULT dhr; va_list ap; va_start(ap, func); dhr = OSX_TaskRegisterCmdV(handle, nIdCmd, nDelayMs, flags, func, ap); va_end(ap); return dhr; } /* Task에서 명령 실행. */ DHL_RESULT OSX_TaskRunCmd(H_OSX_TASK handle, T_OSX_TASK_CMD nIdCmd, UINT16 flags, F_OSX_TASK_PROC func, ...) { DHL_RESULT dhr; va_list ap; // 지연, 반복 옵션은 제거. flags &= ~(eTASK_FLAG_Delayed | eTASK_FLAG_Repeat); va_start(ap, func); dhr = OSX_TaskRegisterCmdV(handle, nIdCmd, 0/* no delay */, flags, func, ap); va_end(ap); return dhr; } /* 반복 설정 된 (또는 지연 실행 등록되고 아직 실행은 안된) 명령의 취소. */ DHL_RESULT OSX_TaskStopCmd(H_OSX_TASK handle, T_OSX_TASK_CMD nIdCmd) { DHL_RESULT dhr; S_OSX_TASK_PUBLIC pti0, *pti; S_OSX_TASK_CMD cmd; DHL_OS_TASK_ID tid = DHL_OS_GetTaskID(); pti = p_get_osx_task(handle, &pti0); if (pti == NULL) return DHL_FAIL_INVALID_HANDLE; if (nIdCmd == 0 || nIdCmd >= eTASK_CMD_BEGIN) { dprint(0, "!! invalid cmd %x\n", nIdCmd); return DHL_FAIL_INVALID_PARAM; } memset(&cmd, 0, sizeof(S_OSX_TASK_CMD)); cmd.idCmd = eTASK_CMD_DELETE; cmd.snTask = SERIAL_FROM_HANDLE(handle); cmd.params[0] = nIdCmd; if (tid != pti->tid) { dhr = DHL_OS_SendMessage(pti->msgQue, &cmd, sizeof(cmd)); if (dhr == DHL_FAIL_BUSY) { dprint(0, "!! %s queue full\a\n", __func__); // 0x18: DHL_FAIL_BUSY 는 queue full 나면 발생함. } else if (dhr) { dprint(0, "!! %s send cmd err %x\a\n", __func__, dhr); } } else { // current task is THE TIMER task that we can add. // so, we can directly modify timer variable. // dhr = p_del_scheduled_cmd(pti->xt, nIdCmd); } return dhr; } DHL_RESULT OSX_TaskSync(H_OSX_TASK handle) { DHL_RESULT dhr; S_OSX_TASK_PUBLIC pti0, *pti; S_OSX_TASK_CMD cmd; DHL_OS_TASK_ID tid = DHL_OS_GetTaskID(); pti = p_get_osx_task(handle, &pti0); if (pti == NULL) return DHL_FAIL_INVALID_HANDLE; memset(&cmd, 0, sizeof(S_OSX_TASK_CMD)); cmd.idCmd = eTASK_CMD_SYNC; cmd.snTask = SERIAL_FROM_HANDLE(handle); if (tid != pti->tid) { int wait_count; // need ack mechanism.. DHL_OS_TakeSemaphore(pti->mutexAck, DHL_TIMEOUT_FOREVER); // mutex wait 도중에 task가 shutdown 되었을 수 있다. pti = p_get_osx_task(handle, &pti0); if (pti == NULL) { dprint(0, "!! task stop while wait sync..\n"); dhr = DHL_FAIL; goto end_mutex; } DHL_OS_TakeSemaphore(pti->semAck, 0); // reset to none dhr = DHL_OS_SendMessage(pti->msgQue, &cmd, sizeof(cmd)); if (dhr == DHL_FAIL_BUSY) { dprint(0, "!! %s queue full\a\n", __func__); // 0x18: DHL_FAIL_BUSY 는 queue full 나면 발생함. goto end_mutex; } else if (dhr) { dprint(0, "!! %s send cmd err %x\a\n", __func__, dhr); // 에러가 발생했다면 wait 하는 것은 의미가 없게 된다. 에러 없는 경우에만 진행. goto end_mutex; } /* 이 sync 명령 보다 먼저 shutdown 명령이 있던 경우라면 ack 응답은 안 올 수 있음. */ for (wait_count=0 ; wait_count<5; wait_count++) { if (wait_count) dprint(0, "!! task (handle %x) not responding.. wait %d..\n", handle, wait_count); dhr = DHL_OS_TakeSemaphore(pti->semAck, 1000); if (dhr == DHL_OK) break; } end_mutex: DHL_OS_GiveSemaphore(pti->mutexAck); } else { dprint(0, "!! sync called inside task\n"); //DHL_ASSERT(FALSE, "invalid usage\n"); } return dhr; } /* task의 간단한 정보 및 예약 된 명령들 화면 출력. */ void OSX_TaskShow(H_OSX_TASK handle) { DHL_RESULT dhr; S_OSX_TASK_PUBLIC pti0, *pti; S_OSX_TASK_CMD cmd; DHL_OS_TASK_ID tid = DHL_OS_GetTaskID(); if (handle == 0) { // 현재 동작중인 모든 task list만 출력. H_OSX_TASK list[OSX_MAX_TASK]; int i, n_task; n_task = p_list_all_osx_task(list); for(i=0; itid) { // send command asynchronously.. dhr = DHL_OS_SendMessage(pti->msgQue, &cmd, sizeof(cmd)); if (dhr) { // error check.. dprint(0, "!! %s send cmd err %x\a\n", __func__, dhr); } } else { p_show_scheduled_cmd(pti->xt, &cmd); } if (handle) // show only specified task. break; if (tid != pti->tid) { //DHL_OS_Delay(100); // wait for timer tasks to print information } }while (0); } /* */ void OSX_TaskGetInfo(H_OSX_TASK handle, S_OSX_TASK_INFO *pinfo) { S_OSX_TASK_PUBLIC pti0, *pti; pti = p_get_osx_task(handle, &pti0); // get public task info if (pinfo) { pinfo->tid = pti ? pti->tid : 0; } } #if COMMENT ____API____(){} #endif void OSX_TaskGetDefaultInitSetting(S_OSX_TASK_INIT_SETTING *setting) { if (setting) { memset(setting, 0, sizeof(*setting)); setting->name = ""; setting->max_scheduled_cmd = 4; setting->priority = 32; setting->stack_size = 8192; //setting->num_cmd_param = 1; setting->msg_que_size = 2; } } /* */ DHL_RESULT OSX_TaskStart(S_OSX_TASK_INIT_SETTING *setting, H_OSX_TASK *pHandle) { DHL_RESULT dhlResult = DHL_OK; char buf[20]; S_OSX_TASK *xt; H_OSX_TASK handle = 0; DHL_OS_TASK_ID tid = 0; osx_module_init(); dprint(2, "%s: '%s', prio %d, stack %d, qsize %d, #param %d, max delayed cmd %d\n", __func__, setting->name, setting->priority, setting->stack_size, setting->msg_que_size, setting->num_cmd_param, setting->max_scheduled_cmd, 0); *pHandle = 0; // initialize first.. //------- check settings parameter if (setting->max_scheduled_cmd <= 0) { dprint(0, "!! max sched cmd %d invalid.\n", setting->max_scheduled_cmd); dhlResult = DHL_FAIL_INVALID_PARAM; //DHL_ASSERT(FALSE, ""); goto label_end; } if (setting->num_cmd_param < 0 || setting->num_cmd_param > OSX_MAX_CMD_PARAMS) { dprint(0, "!! num user param %d invalid.\n", setting->num_cmd_param); dhlResult = DHL_FAIL_INVALID_PARAM; //DHL_ASSERT(FALSE, ""); goto label_end; } if (setting->msg_que_size < 0) { dprint(0, "!! que size %d invalid.\n", setting->msg_que_size); dhlResult = DHL_FAIL_INVALID_PARAM; goto label_end; } //------- allocate osx task xt = p_alloc_osx_task(); if (!xt) { dprint(0, "!! no more available osx task\n"); dhlResult = DHL_FAIL_OUT_OF_RESOURCE; goto label_end; } //------- initialize task variables //memset(xt, 0, sizeof(*xt)); // done in alloc_osx_task(). // name of timers strncpy(xt->name, setting->name, OSX_MAX_TASK_NAME); xt->name[OSX_MAX_TASK_NAME] = 0; // max timer slots xt->nMaxSlot = setting->max_scheduled_cmd; // no active timer now. xt->maxActiveIndex = -1; xt->sclist = (S_OSX_CMD_SCHED *) DHL_OS_Malloc( setting->max_scheduled_cmd* sizeof(S_OSX_CMD_SCHED) + 4); // 4 is margin. if (xt->sclist == NULL) { dhlResult = DHL_FAIL_OUT_OF_MEMORY; goto label_end; } // message que size if (setting->msg_que_size == 0) xt->nMaxQueSize = OSX_DEFAULT_MSG_QUE_SIZE; // for backward compatibility else if (setting->msg_que_size > 0) xt->nMaxQueSize = setting->msg_que_size; //------ preprare public task info ------ // num user param if (setting->num_cmd_param <= 0) // 최소한 1개의 파라미터 공간은 필요하다. 내부 명령 중에 이 영역을 사용하는 것들이 있음. xt->pti.nCmdParam = 1; else xt->pti.nCmdParam = setting->num_cmd_param; // task는 맨 마지막에 생성하는 게 좋다. priority 관련하여 먼저 실행 가능성이 있으므로.. // memset(buf, 0, sizeof(buf)); strcpy(buf, "TS"); // task ack sem strncpy(buf+2, xt->name, 6); xt->pti.semAck = DHL_OS_CreateBinarySemaphore(buf, 0, 0); if (xt->pti.semAck == 0) { dprint(0, "!! Creating sem err\n"); dhlResult = DHL_FAIL_OUT_OF_RESOURCE; goto label_end; } memset(buf, 0, sizeof(buf)); strcpy(buf, "TM"); // task ack mutex strncpy(buf+2, xt->name, 6); xt->pti.mutexAck = DHL_OS_CreateMutexSemaphore(buf); if (xt->pti.mutexAck == 0) { dprint(0, "!! Creating mutex err\n"); dhlResult = DHL_FAIL_OUT_OF_RESOURCE; goto label_end; } memset(buf, 0, sizeof(buf)); strcpy(buf, "TQ"); // task cmd que strncpy(buf+2, xt->name, 6); xt->pti.msgQue = DHL_OS_CreateMessageQueue(buf, 0, xt->nMaxQueSize, OSX_COMMAND_SIZE(xt->pti.nCmdParam)); if (xt->pti.msgQue == 0) { dprint(0, "!! Creating msgq err\n"); dhlResult = DHL_FAIL_OUT_OF_RESOURCE; goto label_end; } xt->pti.xt = xt; // self. xt->setting = *setting; xt->setting.name = xt->name; //------- launch task handle = MAKE_OSX_HANDLE(xt->index, xt->serial); /* task priority가 높을 경우 이 함수가 종료되지 전에도 바로 task가 실행 될 수 있음에 유의할 것. */ tid = DHL_OS_CreateTask((DHL_OS_TASKFUNCTION) p_task_main, xt->name, setting->priority, setting->stack_size, (UINT32)xt); if (tid == (DHL_OS_TASK_ID) 0) { dprint(0, "!! osx task create err\n"); dhlResult = DHL_FAIL_OUT_OF_RESOURCE; goto label_end; } p_validate_osx_task(xt); // now, xt is "VALID" xt->pti.tid = tid; // now, task is running. if (pHandle) *pHandle = handle; xt = 0; label_end: if (xt) { // clean up! dprint(0, "!! err occurred in task init. clean up!\n"); if (xt->sclist) DHL_OS_Free((void **)&xt->sclist); if (xt->pti.semAck) DHL_OS_DeleteSemaphore(xt->pti.semAck); if (xt->pti.mutexAck) DHL_OS_DeleteSemaphore(xt->pti.mutexAck); if (xt->pti.msgQue) DHL_OS_DeleteMessageQueue(xt->pti.msgQue); p_free_osx_task(xt); } return dhlResult; } /** @todo Task 종료 OSAL API가 없다면 internal 용도의 function을 만들어서 OSAL_Priv.h 에 등록해 놓고 사용하면 될 것 같음. */ void OSX_TaskShutdown(H_OSX_TASK handle) { DHL_RESULT dhlResult; S_OSX_TASK_PUBLIC pti0, *pti; UINT32 i; S_OSX_TASK_CMD cmd; DHL_OS_TASK_ID tid = DHL_OS_GetTaskID(); osx_module_init(); // TimerTask가 자동으로 죽을때까지 기다릴 시간.. #define WAIT_TIME 1 // second. #define CHECK_PER_SECOND 10 // times. pti = p_get_osx_task(handle, &pti0); if (pti == NULL) { dprint(0, "!! invalid osx task handle %x\n", handle); return; } if (tid == pti->tid) { dprint(0, "!! %s: cannot shutdown timer in itself\n", __func__); return; } memset(&cmd, 0, sizeof(S_OSX_TASK_CMD)); cmd.idCmd = eTASK_CMD_SHUTDOWN; dhlResult = DHL_OS_SendMessage(pti->msgQue, &cmd, sizeof(cmd)); if (dhlResult) { // error check.. dprint(0, "!! %s send cmd err %x\n", __func__, dhlResult); } else { for (i = 0; i < WAIT_TIME*CHECK_PER_SECOND; ++i) { if (pti->tid == 0) { break; } DHL_OS_Delay(1000/CHECK_PER_SECOND); } // 충분히 기다렸건만, Self Delete가 되지 않았을 경우 에러 메시지. // if (pti->tid != 0) { dprint(0, "!! osx task shutdown timeout!\n"); } } pti->tid = 0; } #if COMMENT ____Symbol____(){} #endif #if DHL_REGISTER_DEUBG_SYMBOLS static DHL_SymbolTable _symbols[] = { //---- functions //DHL_FNC_SYM_ENTRY(xxx), //---- variables DHL_VAR_SYM_ENTRY(s_osx_traced), }; #endif // DHL_REGISTER_DEBUG_SYMBOL #if COMMENT ____Init____(){} #endif void osx_module_init(void) { if (s_module_init) return; s_osx_mutex = DHL_OS_CreateMutexSemaphore("OSX"); DHL_ASSERT(s_osx_mutex != 0, ""); #if DHL_REGISTER_DEUBG_SYMBOLS DHL_DBG_RegisterSymbols(_symbols, DHL_NUMSYMBOLS(_symbols)); #endif s_module_init = TRUE; } void osx_trace(UINT32 handle) { S_OSX_TASK_PUBLIC pti0, *pti; pti = p_get_osx_task(handle, &pti0); if (!pti) { dprint(0, "!! invalid handle %x\n", handle); return; } dprint(0, "trace osx task handle %x, task %x\n", handle, pti->xt); s_osx_traced = pti->xt; } #if COMMENT ____Test____(){} #endif #if 1 // test #define printf DHL_OS_Printf H_OSX_TASK s_osx_test_handle; void osx_test_init(void) { DHL_RESULT dhr; S_OSX_TASK_INIT_SETTING stg; if (s_osx_test_handle) { printf("already run\n"); return; } OSX_TaskGetDefaultInitSetting(&stg); stg.num_cmd_param = 2; dhr = OSX_TaskStart(&stg, &s_osx_test_handle); if (dhr) printf("!! task start err %x\n", dhr); else printf("task handle %x\n", s_osx_test_handle); } void osx_test_uninit(void) { if (s_osx_test_handle == 0) return; OSX_TaskShutdown(s_osx_test_handle); s_osx_test_handle = 0; } static void osx_cmd_1(int cmd, int arg1, int arg2) { printf("**** cmd %x, arg %x %x\n", cmd, arg1, arg2); } static void osx_cmd_4(int cmd, int arg1, int arg2) { printf("**** cmd %x, wait %d sec..\n", cmd, arg1); DHL_OS_Delay(arg1*1000); printf("---- cmd exec end\n"); } void osx_test_stop(int cmd) { OSX_TaskStopCmd(s_osx_test_handle, cmd); } void osx_test_run1(int arg1, int arg2) { OSX_TaskRunCmd (s_osx_test_handle, 1, 0, (F_OSX_TASK_PROC)osx_cmd_1, arg1, arg2); } void osx_test_run2(int wait) // delayed { OSX_TaskScheduleCmd(s_osx_test_handle, 2, wait*1000, eTASK_FLAG_Delayed, (F_OSX_TASK_PROC)osx_cmd_1, 0, 0); } void osx_test_run3(int period) // repeat { OSX_TaskScheduleCmd(s_osx_test_handle, 3, period*1000, eTASK_FLAG_Repeat, (F_OSX_TASK_PROC)osx_cmd_1, 0, 0); } void osx_test_run4(int arg1, int arg2) // { OSX_TaskRunCmd (s_osx_test_handle, 4, 0, (F_OSX_TASK_PROC)osx_cmd_4, arg1, arg2); } /* sml osx 3 osx_test_init osx_trace 0x10001 OSX_TaskShow OSX_TaskShow 0x10001 // basic dpc test osx_test_run1 0x33 0x44 // delayed exec test osx_test_run2 1 osx_test_run2 2 osx_test_run2 5 osx_test_stop 2 // repeat exec test osx_test_run3 1 osx_test_stop 3 // queue full test osx_test_run4 5 osx_test_run1 osx_test_run1 osx_test_run1 !! OSX_TaskRegisterCmdV send cmd err 18 osx_test_run1 */ #endif // test /* end of file */