Les Sémaphores POSIX sur Mac OS X: sem_timedwait alternative

Avez-vous envisagé d'utiliser apache portable runtime? Il est pré-installé sur tous les Mac OS X Box et beaucoup de distributions Linux et il est livré avec une plate-forme neutre wrapper autour de fil de simultanéité, qui fonctionne même sur MS Windows:

http://apr.apache.org/docs/apr/1.3/group__apr__thread__cond.html

OriginalL'auteur flitzwald

Pourrait vous essayez d'imiter la fonctionnalité de la sem_timedwait() appel en commençant par un timer dans un autre thread qui appelle sem_post() après l'expiration de la minuterie si il n'a pas été appelé par le thread principal qui est censé appeler sem_post()?

OriginalL'auteur stinkymatt

J'ai l'habitude d'utiliser les sémaphores nommés sur OSX, mais maintenant sem_timedwait n'est pas disponible et sem_init et les amis sont obsolètes. J'ai mis en place à l'aide de sémaphores pthread mutex et conditions ci-dessous qui travail pour moi (OSX 10.13.1). Vous pourriez avoir à faire une poignée vs structure de la table pour regarder la sem_t type si il ne peut pas tenir un ptr (c'est à dire les pointeurs sont 64bits et sem_t est de 32?)

#ifdef __APPLE__

typedef struct
{
    pthread_mutex_t count_lock;
    pthread_cond_t  count_bump;
    unsigned count;
}
bosal_sem_t;

int sem_init(sem_t *psem, int flags, unsigned count)
{
    bosal_sem_t *pnewsem;
    int result;

    pnewsem = (bosal_sem_t *)malloc(sizeof(bosal_sem_t));
    if (! pnewsem)
    {
        return -1;
    }
    result = pthread_mutex_init(&pnewsem->count_lock, NULL);
    if (result)
    {
        free(pnewsem);
        return result;
    }
    result = pthread_cond_init(&pnewsem->count_bump, NULL);
    if (result)
    {
        pthread_mutex_destroy(&pnewsem->count_lock);
        free(pnewsem);
        return result;
    }
    pnewsem->count = count;
    *psem = (sem_t)pnewsem;
    return 0;
}

int sem_destroy(sem_t *psem)
{
    bosal_sem_t *poldsem;

    if (! psem)
    {
        return EINVAL;
    }
    poldsem = (bosal_sem_t *)*psem;

    pthread_mutex_destroy(&poldsem->count_lock);
    pthread_cond_destroy(&poldsem->count_bump);
    free(poldsem);
    return 0;
}

int sem_post(sem_t *psem)
{
     bosal_sem_t *pxsem;
    int result, xresult;

    if (! psem)
    {
        return EINVAL;
    }
    pxsem = (bosal_sem_t *)*psem;

    result = pthread_mutex_lock(&pxsem->count_lock);
    if (result)
    {
        return result;
    }
    pxsem->count = pxsem->count + 1;

    xresult = pthread_cond_signal(&pxsem->count_bump);

    result = pthread_mutex_unlock(&pxsem->count_lock);
    if (result)
    {
        return result;
    }
    if (xresult)
    {
        errno = xresult;
        return -1;
    }
}

int sem_trywait(sem_t *psem)
{
    bosal_sem_t *pxsem;
    int result, xresult;

    if (! psem)
    {
        return EINVAL;
    }
    pxsem = (bosal_sem_t *)*psem;

    result = pthread_mutex_lock(&pxsem->count_lock);
    if (result)
    {
        return result;
    }
    xresult = 0;

    if (pxsem->count > 0)
    {
        pxsem->count--;
    }
    else
    {
        xresult = EAGAIN;
    }
    result = pthread_mutex_unlock(&pxsem->count_lock);
    if (result)
    {
        return result;
    }
    if (xresult)
    {
        errno = xresult;
        return -1;
    }
    return 0;
}

int sem_wait(sem_t *psem)
{
    bosal_sem_t *pxsem;
    int result, xresult;

    if (! psem)
    {
        return EINVAL;
    }
    pxsem = (bosal_sem_t *)*psem;

    result = pthread_mutex_lock(&pxsem->count_lock);
    if (result)
    {
        return result;
    }
    xresult = 0;

    if (pxsem->count == 0)
    {
        xresult = pthread_cond_wait(&pxsem->count_bump, &pxsem->count_lock);
    }
    if (! xresult)
    {
        if (pxsem->count > 0)
        {
            pxsem->count--;
        }
    }
    result = pthread_mutex_unlock(&pxsem->count_lock);
    if (result)
    {
        return result;
    }
    if (xresult)
    {
        errno = xresult;
        return -1;
    }
    return 0;
}

int sem_timedwait(sem_t *psem, const struct timespec *abstim)
{
    bosal_sem_t *pxsem;
    int result, xresult;

    if (! psem)
    {
        return EINVAL;
    }
    pxsem = (bosal_sem_t *)*psem;

    result = pthread_mutex_lock(&pxsem->count_lock);
    if (result)
    {
        return result;
    }
    xresult = 0;

    if (pxsem->count == 0)
    {
        xresult = pthread_cond_timedwait(&pxsem->count_bump, &pxsem->count_lock, abstim);
    }
    if (! xresult)
    {
        if (pxsem->count > 0)
        {
            pxsem->count--;
        }
    }
    result = pthread_mutex_unlock(&pxsem->count_lock);
    if (result)
    {
        return result;
    }
    if (xresult)
    {
        errno = xresult;
        return -1;
    }
    return 0;
}

#endif

OriginalL'auteur Brian

Je comptais sur l'aide de la fonction suivante comme un remplacement, mais j'ai ensuite découvert que sem_getvalue() a été également obsolète et non-fonctionnelles sur OSX. Vous êtes libre de les utiliser légèrement le code non testé sous un MIT ou licence LGPL (de votre choix).

#ifdef __APPLE__
struct CSGX__sem_timedwait_Info
{
    pthread_mutex_t MxMutex;
    pthread_cond_t MxCondition;
    pthread_t MxParent;
    struct timespec MxTimeout;
    bool MxSignaled;
};

void *CSGX__sem_timedwait_Child(void *MainPtr)
{
    CSGX__sem_timedwait_Info *TempInfo = (CSGX__sem_timedwait_Info *)MainPtr;

    pthread_mutex_lock(&TempInfo->MxMutex);

    //Wait until the timeout or the condition is signaled, whichever comes first.
    int Result;
    do
    {
        Result = pthread_cond_timedwait(&TempInfo->MxCondition, &TempInfo->MxMutex, &TempInfo->MxTimeout);
        if (!Result)  break;
    } while (1);
    if (errno == ETIMEDOUT && !TempInfo->MxSignaled)
    {
        TempInfo->MxSignaled = true;
        pthread_kill(TempInfo->MxParent, SIGALRM);
    }

    pthread_mutex_unlock(&TempInfo->MxMutex);

    return NULL;
}

int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout)
{
    //Quick test to see if a lock can be immediately obtained.
    int Result;

    do
    {
        Result = sem_trywait(sem);
        if (!Result)  return 0;
    } while (Result < 0 && errno == EINTR);

    //Since it couldn't be obtained immediately, it is time to shuttle the request off to a thread.
    //Depending on the timeout, this could take longer than the timeout.
    CSGX__sem_timedwait_Info TempInfo;

    pthread_mutex_init(&TempInfo.MxMutex, NULL);
    pthread_cond_init(&TempInfo.MxCondition, NULL);
    TempInfo.MxParent = pthread_self();
    TempInfo.MxTimeout.tv_sec = abs_timeout->tv_sec;
    TempInfo.MxTimeout.tv_nsec = abs_timeout->tv_nsec;
    TempInfo.MxSignaled = false;

    sighandler_t OldSigHandler = signal(SIGALRM, SIG_DFL);

    pthread_t ChildThread;
    pthread_create(&ChildThread, NULL, CSGX__sem_timedwait_Child, &TempInfo);

    //Wait for the semaphore, the timeout to expire, or an unexpected error condition.
    do
    {
        Result = sem_wait(sem);
        if (Result == 0 || TempInfo.MxSignaled || (Result < 0 && errno != EINTR))  break;
    } while (1);

    //Terminate the thread (if it is still running).
    TempInfo.MxSignaled = true;
    int LastError = errno;

    pthread_mutex_lock(&TempInfo.MxMutex);
    pthread_cond_signal(&TempInfo.MxCondition);
    pthread_mutex_unlock(&TempInfo.MxMutex);
    pthread_join(ChildThread, NULL);
    pthread_cond_destroy(&TempInfo.MxCondition);
    pthread_mutex_destroy(&TempInfo.MxMutex);

    //Restore previous signal handler.
    signal(SIGALRM, OldSigHandler);

    errno = LastError;

    return Result;
}
#endif

SIGALRM plus de sens que SIGUSR2 comme un autre exemple ici utilise apparemment (je n'ai pas la peine de le regarder). SIGALRM est surtout réservé pour l'alarme() appelle, qui sont pratiquement inutile quand vous le souhaitez sous-deuxième résolution.

Ce code tente d'abord d'acquérir le sémaphore avec sem_trywait(). Si qui succède immédiatement, puis il écope. Sinon, il démarre un thread qui est l'endroit où le chronomètre est mis en œuvre par pthread_cond_timedwait(). Le MxSignaled booléen est utilisé pour déterminer le délai d'expiration de l'etat.

Vous pouvez également trouver cette fonction utile pour appeler le ci-dessus sem_timedwait() mise en œuvre (encore une fois, MIT ou LGPL, de votre choix):

int CSGX__ClockGetTimeRealtime(struct timespec *ts)
{
#ifdef __APPLE__
    clock_serv_t cclock;
    mach_timespec_t mts;

    if (host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock) != KERN_SUCCESS)  return -1;
    if (clock_get_time(cclock, &mts) != KERN_SUCCESS)  return -1;
    if (mach_port_deallocate(mach_task_self(), cclock) != KERN_SUCCESS)  return -1;

    ts->tv_sec = mts.tv_sec;
    ts->tv_nsec = mts.tv_nsec;

    return 0;
#else
    return clock_gettime(CLOCK_REALTIME, ts);
#endif
}

Permet de remplir une structure timespec avec la chose la plus proche de ce que clock_gettime() peut fournir. Il y a divers commentaires qui appel host_get_clock_service() à plusieurs reprises est cher. Mais à partir un thread qui est également coûteux.

La vraie solution est pour Apple de mettre en œuvre l'ensemble de la spécification POSIX, et pas seulement les parties obligatoires. Œuvre de l'obligatoire bits de la norme POSIX et puis à réclamer POSIX conformité, laisse tout le monde avec une demi-cassé des OS et des tonnes de solutions de contournement comme ci-dessus, qui ont peut-être moins-que-idéales de performance.

Ci-dessus dit, je suis d'abandonner sur les sémaphores (les deux Sys V et POSIX), Mac OSX et Linux. Elles sont divisées en tout un peu plutôt malheureux façons. Tout le monde doit abandonner sur eux trop. (Je ne suis pas céder sur les sémaphores sur les Systèmes d'exploitation, juste le natif de mise en œuvre.) En tout cas, maintenant tout le monde a un sem_timedwait() de la mise en œuvre sans restrictions commerciales que d'autres peuvent copier-pâtes au contenu de leur coeur.

OriginalL'auteur CubicleSoft