osal/Exynos_OSAL_Thread.c

   1 /*
   2  *
   3  * Copyright 2012 Samsung Electronics S.LSI Co. LTD
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 /*
  19  * @file        Exynos_OSAL_Thread.c
  20  * @brief
  21  * @author      SeungBeom Kim (sbcrux.kim@samsung.com)
  22  * @version     2.0.0
  23  * @history
  24  *   2012.02.20 : Create
  25  */
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <pthread.h>
  31 #include <semaphore.h>
  32 #include <errno.h>
  33 #include <time.h>
  34 #include <unistd.h>
  35
  36 #include "Exynos_OSAL_Memory.h"
  37 #include "Exynos_OSAL_Thread.h"
  38
  39 #undef EXYNOS_LOG_TAG
  40 #define EXYNOS_LOG_TAG    "EXYNOS_LOG_THREAD"
  41 //#define EXYNOS_LOG_OFF
  42 #include "Exynos_OSAL_Log.h"
  43
  44
  45 typedef struct _EXYNOS_THREAD_HANDLE_TYPE
  46 {
  47     pthread_t          pthread;
  48     pthread_attr_t     attr;
  49     struct sched_param schedparam;
  50     int                stack_size;
  51 } EXYNOS_THREAD_HANDLE_TYPE;
  52
  53
  54 OMX_ERRORTYPE Exynos_OSAL_ThreadCreate(OMX_HANDLETYPE *threadHandle, OMX_PTR function_name, OMX_PTR argument)
  55 {
  56     FunctionIn();
  57
  58     int result = 0;
  59     int detach_ret = 0;
  60     EXYNOS_THREAD_HANDLE_TYPE *thread;
  61     OMX_ERRORTYPE ret = OMX_ErrorNone;
  62
  63     thread = Exynos_OSAL_Malloc(sizeof(EXYNOS_THREAD_HANDLE_TYPE));
  64     Exynos_OSAL_Memset(thread, 0, sizeof(EXYNOS_THREAD_HANDLE_TYPE));
  65
  66     pthread_attr_init(&thread->attr);
  67     if (thread->stack_size != 0)
  68         pthread_attr_setstacksize(&thread->attr, thread->stack_size);
  69
  70     /* set priority */
  71     if (thread->schedparam.sched_priority != 0)
  72         pthread_attr_setschedparam(&thread->attr, &thread->schedparam);
  73
  74     detach_ret = pthread_attr_setdetachstate(&thread->attr, PTHREAD_CREATE_JOINABLE);
  75     if (detach_ret != 0) {
  76         Exynos_OSAL_Free(thread);
  77         *threadHandle = NULL;
  78         ret = OMX_ErrorUndefined;
  79         goto EXIT;
  80     }
  81
  82     result = pthread_create(&thread->pthread, &thread->attr, function_name, (void *)argument);
  83     /* pthread_setschedparam(thread->pthread, SCHED_RR, &thread->schedparam); */
  84
  85     switch (result) {
  86     case 0:
  87         *threadHandle = (OMX_HANDLETYPE)thread;
  88         ret = OMX_ErrorNone;
  89         break;
  90     case EAGAIN:
  91         Exynos_OSAL_Free(thread);
  92         *threadHandle = NULL;
  93         ret = OMX_ErrorInsufficientResources;
  94         break;
  95     default:
  96         Exynos_OSAL_Free(thread);
  97         *threadHandle = NULL;
  98         ret = OMX_ErrorUndefined;
  99         break;
 100     }
 101
 102 EXIT:
 103     FunctionOut();
 104
 105     return ret;
 106 }
 107
 108 OMX_ERRORTYPE Exynos_OSAL_ThreadTerminate(OMX_HANDLETYPE threadHandle)
 109 {
 110     FunctionIn();
 111
 112     OMX_ERRORTYPE ret = OMX_ErrorNone;
 113     EXYNOS_THREAD_HANDLE_TYPE *thread = (EXYNOS_THREAD_HANDLE_TYPE *)threadHandle;
 114
 115     if (!thread) {
 116         ret = OMX_ErrorBadParameter;
 117         goto EXIT;
 118     }
 119     if (pthread_join(thread->pthread, NULL) != 0) {
 120         ret = OMX_ErrorUndefined;
 121         goto EXIT;
 122     }
 123
 124     Exynos_OSAL_Free(thread);
 125     ret = OMX_ErrorNone;
 126
 127 EXIT:
 128     FunctionOut();
 129
 130     return ret;
 131 }
 132
 133 OMX_ERRORTYPE Exynos_OSAL_ThreadCancel(OMX_HANDLETYPE threadHandle)
 134 {
 135     EXYNOS_THREAD_HANDLE_TYPE *thread = (EXYNOS_THREAD_HANDLE_TYPE *)threadHandle;
 136
 137     if (!thread)
 138         return OMX_ErrorBadParameter;
 139
 140     /* thread_cancel(thread->pthread); */
 141     pthread_exit(&thread->pthread);
 142     pthread_join(thread->pthread, NULL);
 143
 144     Exynos_OSAL_Free(thread);
 145     return OMX_ErrorNone;
 146 }
 147
 148 void Exynos_OSAL_ThreadExit(void *value_ptr)
 149 {
 150     pthread_exit(value_ptr);
 151     return;
 152 }
 153
 154 void Exynos_OSAL_SleepMillisec(OMX_U32 ms)
 155 {
 156     if (ms == 0) {
 157         sched_yield();
 158     } else {
 159         struct timespec time;
 160         time.tv_sec  = (time_t)(ms / 1000);
 161         time.tv_nsec = (long)(ms % 1000) * 1000000;
 162         nanosleep(&time, NULL);
 163     }
 164     return;
 165 }