FcLibs/FcThread/src/FcThread_PTHREAD_Definition.h - master - vTech/FcApps

FcLibs/FcThread/src/FcThread_PTHREAD_Definition.h
326 строк9 KB
vTech
alpha_00
03 дек 2025, 17:45
03 дек 2025, 17:45ab8382d
#if defined(__linux__)
#ifndef FCTHREAD_PTHREAD_DEFINITION_H
#define FCTHREAD_PTHREAD_DEFINITION_H

#include "FcThread_PTHREAD.h"


static FcThread_Error_t FcThread_Error(FcThread_Error_t m_error) {
  FcThread_Error_t l_error;
  switch (m_error) {
  case 0:
    l_error = FCTHREAD_ERROR_NOERROR;
    break;
  case EINVAL:
    l_error = FCTHREAD_ERROR_INCORRECT_VALUE;
    break;
  case EAGAIN:
    l_error =
        FCTHREAD_ERROR_MAXIMUM_NUMBER_OF_THREADS_FOR_THIS_JOB_HAS_BEEN_REACHED;
    break;
  case EBUSY:
    l_error =
        FCTHREAD_ERROR_SYSTEM_CANNOT_ALLOW_THREAD_CREATION_IN_THIS_PROCESS_AT_THIS_TIME;
    break;
  case ESRCH:
    l_error = FCTHREAD_ERROR_THE_THREAD_SPECIFIED_COULD_NOT_BE_FOUND;
    break;
  case ETIMEDOUT:
    l_error = FCTHREAD_ERROR_THE_CALL_TIMES_OUT_BEFORE_THREAD_TERMINATED;
    break;
  default:
    l_error = FCTHREAD_ERROR_UNKNOWN_ERROR;
    break;
  }
  return l_error;
}

FCTHREADDEF FcThread_Error_t FcThread(FcThread_t *pThread,
                                      const FcThread_settings_t *pSetting) {
  FcThread_Error_t l_error =
      pthread_create(pThread, NULL, pSetting->f, pSetting->arg);
  return FcThread_Error(l_error);
}

FCTHREADDEF FcThread_Error_t FcThread_join(const FcThread_t *pThread) {
  FcThread_Error_t l_error = pthread_join(*pThread, NULL);
  return FcThread_Error(l_error);
}


//FCTHREADDEF BOOL FcThread_running(const FcThread_t *pThread) {
//  FcThread_Error_t l_error = pthread_tryjoin_np(*pThread, NULL);
//  return (l_error == EBUSY);
//}

FCTHREADDEF size_t FcThread_getId(const FcThread_t *pThread) {
  return (size_t)*pThread;
}

FCTHREADDEF size_t FcThread_getCurrentId() {
  pthread_t mThread = pthread_self();
  return (size_t)mThread;
}

static FcThread_Error_t FcMutex_Error(FcThread_Error_t m_error) {
  FcThread_Error_t l_error;
  switch (m_error) {
  case 0:
    l_error = FCTHREAD_ERROR_NOERROR;
    break;
  case EINVAL:
    l_error = FCTHREAD_ERROR_MUTEX_INCORRECT_VALUE;
    break;
  case ENOMEM:
    l_error = FCTHREAD_ERROR_MUTEX_NO_MEMORY;
    break;
  case EOWNERTERM:
    l_error =
        FCTHREAD_ERROR_MUTEX_OBJECT_NO_LONGER_EXISTS_BECAUSE_THE_OWNER_IS_NOT_LONGER_RUNNING;
    break;
  case EDESTROYED:
    l_error = FCTHREAD_ERROR_MUTEX_OBJECT_WAS_DESTROYED_NO_LONGER_EXISTS;
    break;
  case EDEADLK:
    l_error = FCTHREAD_ERROR_MUTEX_RESOURCE_DEADLOCK_AVOIDED;
    break;
  case ERECURSE:
    l_error = FCTHREAD_ERROR_MUTEX_RECURSIVE_ATTEMPT_REJECTED;
    break;
  case EPERM:
    l_error = FCTHREAD_ERROR_MUTEX_IS_NOT_CURRENTLY_HELD_BY_THE_CALLER;
    break;
  case EBUSY:
    l_error = FCTHREAD_ERROR_MUTEX_CURRENTLY_OWNED_BY_ANOTHER_THREAD;
    break;
  default:
    l_error = FCTHREAD_ERROR_UNKNOWN_ERROR;
    break;
  }
  return l_error;
}

FCTHREADDEF FcThread_Error_t FcMutex(FcMutex_t *pMutex) {
  FcThread_Error_t l_error = pthread_mutex_init(pMutex, NULL);
  return FcMutex_Error(l_error);
}

FCTHREADDEF FcThread_Error_t FcMutex_Lock(FcMutex_t *pMutex) {
  FcThread_Error_t l_error = pthread_mutex_lock(pMutex);
  return FcMutex_Error(l_error);
}

FCTHREADDEF FcThread_Error_t FcMutex_Unlock(FcMutex_t *pMutex) {
  FcThread_Error_t l_error = pthread_mutex_unlock(pMutex);
  return FcMutex_Error(l_error);
}

FCTHREADDEF FcThread_Error_t FcMutex_Free(FcMutex_t *pMutex) {
  FcThread_Error_t l_error = pthread_mutex_destroy(pMutex);
  return FcMutex_Error(l_error);
}

static FcThread_Error_t FcSemaphore_Error(FcThread_Error_t m_error) {
  FcThread_Error_t l_error;
  switch (m_error) {
  case 0:
    l_error = FCTHREAD_ERROR_NOERROR;
    break;
  case EACCES:
    l_error = FCTHREAD_ERROR_SEMAPHORE_ACCESS_DENIED;
    break;
  case EEXIST:
    l_error = FCTHREAD_ERROR_SEMAPHORE_EXIST;
    break;
  case EINVAL:
    l_error = FCTHREAD_ERROR_SEMAPHORE_INCORRECT_VALUE;
    break;
  case ENAMETOOLONG:
    l_error = FCTHREAD_ERROR_SEMAPHORE_NAME_TO_LONG;
    break;
  case ENOENT:
    l_error = FCTHREAD_ERROR_SEMAPHORE_NO_SUCH_PATH_OR_DIRECTORY;
    break;
  case ENOSPC:
    l_error = FCTHREAD_ERROR_SEMAPHORE_NO_SPACE_AVAILABLE;
    break;
  case EINTR:
    l_error = FCTHREAD_ERROR_SEMAPHORE_INTERRUPTED_FUNCTION_CALL;
    break;
  case EBUSY:
    l_error = FCTHREAD_ERROR_SEMAPHORE_RESOURCE_BUSY;
    break;
  default:
    l_error = FCTHREAD_ERROR_UNKNOWN_ERROR;
    break;
  }
  return l_error;
}

FCTHREADDEF FcThread_Error_t FcSemaphore(FcSemaphore_t *semaphore,
                                         unsigned int initCounter) {
  FcThread_Error_t l_error = FCTHREAD_ERROR_NOERROR;
  errno = 0;
  if (sem_init(semaphore, 0, initCounter) == -1)
    l_error = FcSemaphore_Error(errno);
  return l_error;
}

FCTHREADDEF FcThread_Error_t FcSemaphore_Dec(FcSemaphore_t *semaphore) {
  FcThread_Error_t l_error = FCTHREAD_ERROR_NOERROR;
  errno = 0;
  if (sem_wait(semaphore) == -1)
    l_error = FcSemaphore_Error(errno);
  return l_error;
}

FCTHREADDEF FcThread_Error_t FcSemaphore_Count(FcSemaphore_t *semaphore, int* count){
  FcThread_Error_t l_error = FCTHREAD_ERROR_NOERROR;
  if (sem_getvalue(semaphore, count) == -1)
    l_error = FcSemaphore_Error(errno);
  return l_error;
}

FCTHREADDEF FcThread_Error_t FcSemaphore_Inc(FcSemaphore_t *semaphore) {
  FcThread_Error_t l_error = FCTHREAD_ERROR_NOERROR;
  errno = 0;
  if (sem_post(semaphore) == -1)
    l_error = FcSemaphore_Error(errno);
  return l_error;
}

FCTHREADDEF FcThread_Error_t FcSemaphore_Free(FcSemaphore_t *semaphore) {
  FcThread_Error_t l_error = FCTHREAD_ERROR_NOERROR;
  errno = 0;
  if (sem_destroy(semaphore) == -1)
    l_error = FcSemaphore_Error(errno);
  return l_error;
}

FCTHREADDEF FcThread_Error_t FcSemaphoreN(FcSemaphore_t *pSemaphore,
                                          const TCHAR *name,
                                          unsigned int initCounter) {
  FcThread_Error_t l_error = FCTHREAD_ERROR_NOERROR;
  errno = 0;
  if ((pSemaphore = sem_open(name, O_CREAT | O_EXCL, initCounter)) == SEM_FAILED)
    l_error = FcSemaphore_Error(errno);
  return l_error;
}

FCTHREADDEF FcThread_Error_t FcSemaphoreN_Free(FcSemaphore_t *semaphore) {
  FcThread_Error_t l_error = FCTHREAD_ERROR_NOERROR;
  errno = 0;
  if (sem_close(semaphore) == -1)
    l_error = FcSemaphore_Error(errno);
  return l_error;
}

static FcThread_Error_t FcEvent_Error(FcThread_Error_t m_error) {
  FcThread_Error_t l_error;
  switch (m_error) {
  case 0:
    l_error = FCTHREAD_ERROR_NOERROR;
    break;
  case EACCES:
    l_error = FCTHREAD_ERROR_EVENT_ACCESS_DENIED;
    break;
  case EEXIST:
    l_error = FCTHREAD_ERROR_EVENT_EXIST;
    break;
  case EINVAL:
    l_error = FCTHREAD_ERROR_EVENT_INCORRECT_VALUE;
    break;
  case ENAMETOOLONG:
    l_error = FCTHREAD_ERROR_EVENT_NAME_TO_LONG;
    break;
  case ENOENT:
    l_error = FCTHREAD_ERROR_EVENT_NO_SUCH_PATH_OR_DIRECTORY;
    break;
  case ENOSPC:
    l_error = FCTHREAD_ERROR_EVENT_NO_SPACE_AVAILABLE;
    break;
  case EINTR:
    l_error = FCTHREAD_ERROR_EVENT_INTERRUPTED_FUNCTION_CALL;
    break;
  case EBUSY:
    l_error = FCTHREAD_ERROR_EVENT_RESOURCE_BUSY;
    break;
  default:
    l_error = FCTHREAD_ERROR_UNKNOWN_ERROR;
    break;
  }
  return l_error;
}

FCTHREADDEF FcThread_Error_t    FcEvent(FcEvent_t* pEvent, const TCHAR* pName){
  FcThread_Error_t l_error = FCTHREAD_ERROR_NOERROR;
  
  l_error = pthread_mutex_init(&pEvent->mMutex, NULL);
  if (l_error){
    l_error = FcEvent_Error(l_error);
    goto gError;
  }
    
  l_error = pthread_cond_init(&pEvent->mEvent, NULL);
  if (l_error){
    l_error = FcEvent_Error(l_error);
    goto gError;
  }
    
  pEvent->mFlag = false;
gError:
  return l_error;
}

FCTHREADDEF BOOL                FcEvent_Signal(FcEvent_t* pEvent){
  bool mResult;
  struct timespec mTime;
  mTime.tv_nsec = 0;
  mTime.tv_sec = 0;
  pthread_mutex_lock(&pEvent->mMutex);
  mResult = pEvent->mFlag;
  pthread_cond_timedwait(&pEvent->mEvent, &pEvent->mMutex, &mTime);
  pthread_mutex_unlock(&pEvent->mMutex);

  return mResult;
}

FCTHREADDEF BOOL                FcEvent_Signal_wait(FcEvent_t* pEvent){
  bool mResult;
  pthread_mutex_lock(&pEvent->mMutex);
  pthread_cond_wait(&pEvent->mEvent, &pEvent->mMutex);
  mResult = pEvent->mFlag;
  pthread_mutex_unlock(&pEvent->mMutex);
  return mResult;
}

FCTHREADDEF FcThread_Error_t    FcEvent_SetEvent(FcEvent_t* pEvent){
  FcThread_Error_t l_error = pthread_mutex_lock(&pEvent->mMutex);
  if (l_error){
    l_error = FcEvent_Error(l_error);
    goto gError;
  }
  if (!pEvent->mFlag) {
    pEvent->mFlag = true;
    l_error = pthread_cond_signal(&pEvent->mEvent); 
    if (l_error){
      l_error = FcEvent_Error(l_error);
      goto gError;
    }
  }
  l_error = pthread_mutex_unlock(&pEvent->mMutex);
  if (l_error){
    l_error = FcEvent_Error(l_error);
    goto gError;
  }
gError:
  return l_error;
}

FCTHREADDEF FcThread_Error_t    FcEvent_Free(FcEvent_t* pEvent){
  FcThread_Error_t l_error = pthread_cond_destroy(&pEvent->mEvent);
  return FcEvent_Error(l_error);
}

#endif // FCTHREAD_PTHREAD_DEFINITION_H
#endif