1 // Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Cross platform threading support library

    15 

    16 #include "hostthreadadapter.h"

    17 

    18 #ifdef WIN32

    19 #include <windows.h>

    20 #include <WinBase.h>

    21 #else

    22 #include <unistd.h>

    23 #include <time.h>

    24 #include <signal.h>

    25 #endif

    26 

    27 #include <stdio.h>

    28 

    29 #ifdef WIN32

    30 #ifdef __GNUG__

    31 static void CALLBACK default_interrupt_handler(ULONG_PTR)

    32 #else // MSVC

    33 static VOID CALLBACK default_interrupt_handler(__in  ULONG_PTR)

    34 #endif

    35 #else // LINUX

    36 static void default_interrupt_handler(int)

    37 #endif

    38 {

    39     // does nothing

    40     ;

    41 }

    42 

    43 namespace Psu

    44 {

    45 

    46 #ifndef WIN32

    47     const int MicrosecsInMillisec = 1000;

    48 #endif

    49 

    50 

    51     int platform_create_simple_thread(PLATFORM_THREAD_T * pThreadHandle,

    52                                       PLATFORM_THREADFUNC pFunc,

    53                                       void * param)

    54     {

    55         int

    56             rv = 0;

    57 

    58 #ifdef WIN32

    59         DWORD

    60             threadId,

    61             stackSize = 0,

    62             creationFlags = 0;

    63 

    64         PLATFORM_THREAD_T

    65             tmp =  CreateThread(NULL,

    66                                 stackSize,

    67                                 pFunc,

    68                                 param,

    69                                 creationFlags,

    70                                 &threadId);

    71         if (tmp == NULL)

    72             {

    73                 rv = GetLastError();

    74             }

    75         else

    76             {

    77                 *pThreadHandle = tmp;

    78             }

    79 #else

    80         rv = pthread_create(pThreadHandle,

    81                             0,

    82                             pFunc,

    83                             param);

    84 #endif

    85 

    86         return rv;

    87     }

    88 

    89 

    90     void platform_release_thread(PLATFORM_THREAD_T threadHandle)

    91     {

    92 #ifdef WIN32

    93         CloseHandle(threadHandle);

    94 #else

    95         pthread_detach(threadHandle);

    96 #endif

    97     }

    98 

    99 

   100     STATUS_T platform_join_thread(PLATFORM_THREAD_T threadHandle)

   101     {

   102 		STATUS_T retVal;

   103 #ifdef WIN32

   104 

   105         retVal = WaitForSingleObject(threadHandle,INFINITE);

   106 #else

   107         retVal = pthread_join(threadHandle, NULL);

   108 #endif

   109 		return retVal;

   110     }

   111 

   112 

   113     void platform_mutex_init(PLATFORM_MUTEX_T * pMutex)

   114     {

   115 #ifdef WIN32

   116         InitializeCriticalSection(pMutex);

   117 #else

   118         pthread_mutex_init(pMutex,

   119                            0);

   120 #endif

   121     }

   122 

   123 

   124     void platform_mutex_destroy(PLATFORM_MUTEX_T * pMutex)

   125     {

   126 #ifdef WIN32

   127         DeleteCriticalSection(pMutex);

   128 #else

   129         pthread_mutex_destroy(pMutex);

   130 #endif

   131     }

   132 

   133 

   134     void platform_mutex_lock(PLATFORM_MUTEX_T * pMutex)

   135     {

   136 #ifdef WIN32

   137         EnterCriticalSection(pMutex);

   138 #else

   139         pthread_mutex_lock(pMutex);

   140 #endif

   141     }

   142 

   143 

   144     void platform_mutex_unlock(PLATFORM_MUTEX_T * pMutex)

   145     {

   146 #ifdef WIN32

   147         LeaveCriticalSection(pMutex);

   148 #else

   149         pthread_mutex_unlock(pMutex);

   150 #endif

   151     }

   152 

   153 

   154     void platform_sleep(int millisecs)

   155     {

   156 #ifdef WIN32

   157         Sleep(millisecs);

   158 #else

   159         usleep(millisecs * MicrosecsInMillisec);

   160 #endif

   161     }

   162 

   163 

   164     STATUS_T platform_create_semaphore(PLATFORM_SEMAPHORE_T& semHandle,

   165     					int initialCount,int maximumCount)

   166     {

   167 

   168  		STATUS_T rv =0;

   169 #ifdef WIN32

   170 

   171         PLATFORM_SEMAPHORE_T

   172             tmp =  CreateSemaphore(NULL,

   173                                 initialCount,

   174                                 maximumCount,

   175                                 NULL);

   176         if (tmp == NULL)

   177             {

   178                 rv = GetLastError();

   179             }

   180         else

   181             {

   182                 semHandle = tmp;

   183             }

   184 #else

   185         rv = sem_init(&semHandle,

   186                             0,

   187                             initialCount);

   188 #endif

   189 

   190         return rv;

   191     }

   192 

   193 

   194     STATUS_T platform_wait_for_signal(PLATFORM_SEMAPHORE_T& semHandle)

   195     {

   196 		STATUS_T retVal;

   197 #ifdef WIN32

   198 

   199         retVal = WaitForSingleObject(semHandle,	INFINITE);

   200 #else

   201         retVal = sem_wait(&semHandle);

   202 #endif

   203 		return retVal;

   204     }

   205 

   206 

   207     void platform_signal_semaphore(PLATFORM_SEMAPHORE_T& semHandle)

   208     {

   209 #ifdef WIN32

   210         ReleaseSemaphore(semHandle, 1, NULL);

   211 #else

   212         sem_post(&semHandle);

   213 #endif

   214     }

   215 

   216     void platform_release_semaphore(PLATFORM_SEMAPHORE_T& semHandle)

   217     {

   218 #ifdef WIN32

   219 

   220         CloseHandle(semHandle);

   221 #else

   222 

   223         sem_destroy(&semHandle);

   224 #endif

   225     }

   226 

   227     int32_t platform_interruptable_sleep(int64_t length)

   228     {

   229 #ifdef WIN32

   230         return SleepEx(static_cast<DWORD>(length), TRUE);

   231 #else

   232         struct timespec req = {0};

   233         time_t sec = (int)(length/1000);

   234         length = length - (sec*1000);

   235         req.tv_sec = sec;

   236         req.tv_nsec = length*1000000L;

   237 

   238         int ret = nanosleep(&req, NULL);

   239 

   240         return ret;

   241 #endif

   242     }

   243 

   244     bool platform_interrupt_sleep(PLATFORM_THREAD_T handle)

   245     {

   246 #ifdef WIN32

   247         int32_t result = QueueUserAPC(default_interrupt_handler, handle, 0);

   248 

   249         return (result!=0);

   250 #else

   251         return (0 == pthread_kill(handle, SIGUSR1));

   252 #endif

   253     }

   254 

   255 #ifndef WIN32

   256     SignalUSR1Handler SignalUSR1Handler::instance;

   257 

   258     SignalUSR1Handler::SignalUSR1Handler()

   259     {

   260         //sa = {0}, old = {0};

   261         sa.sa_handler = &default_interrupt_handler;

   262         sigaction(SIGUSR1, &sa, &old);

   263     }

   264 

   265     SignalUSR1Handler::~SignalUSR1Handler()

   266     {

   267         sigaction(SIGUSR1, &old, NULL);

   268     }

   269 #endif

   270 

   271 }