SDL_systhread.c File Reference

#include "../../SDL_internal.h"
#include "SDL_system.h"
#include "SDL_hints.h"
#include <pthread.h>
#include <signal.h>
#include "SDL_platform.h"
#include "SDL_thread.h"
#include "../SDL_thread_c.h"
#include "../SDL_systhread.h"

Include dependency graph for SDL_systhread.c:

Go to the source code of this file.

Functions
static void *	RunThread (void *data)
int	SDL_SYS_CreateThread (SDL_Thread *thread)
void	SDL_SYS_SetupThread (const char *name)
SDL_threadID	SDL_ThreadID (void)
int	SDL_SYS_SetThreadPriority (SDL_ThreadPriority priority)
void	SDL_SYS_WaitThread (SDL_Thread *thread)
void	SDL_SYS_DetachThread (SDL_Thread *thread)

Variables
static const int	sig_list []

Function Documentation

RunThread()

static void* RunThread ( void *  data )

static

Definition at line 73 of file SDL_systhread.c.

{
#ifdef __ANDROID__
    Android_JNI_SetupThread();
#endif
    SDL_RunThread((SDL_Thread *) data);
    return NULL;
}

References Android_JNI_SetupThread(), NULL, and SDL_RunThread().

Referenced by SDL_SYS_CreateThread().

SDL_SYS_CreateThread()

int SDL_SYS_CreateThread

(

SDL_Thread *

thread

)

Definition at line 90 of file SDL_systhread.c.

{
    pthread_attr_t type;
 
    /* do this here before any threads exist, so there's no race condition. */
    #if defined(__MACOSX__) || defined(__IPHONEOS__) || defined(__LINUX__)
    if (!checked_setname) {
        void *fn = dlsym(RTLD_DEFAULT, "pthread_setname_np");
        #if defined(__MACOSX__) || defined(__IPHONEOS__)
        ppthread_setname_np = (int(*)(const char*)) fn;
        #elif defined(__LINUX__)
        ppthread_setname_np = (int(*)(pthread_t, const char*)) fn;
        #endif
        checked_setname = SDL_TRUE;
    }
    #endif
 
    /* Set the thread attributes */
    if (pthread_attr_init(&type) != 0) {
        return SDL_SetError("Couldn't initialize pthread attributes");
    }
    pthread_attr_setdetachstate(&type, PTHREAD_CREATE_JOINABLE);
    
    /* Set caller-requested stack size. Otherwise: use the system default. */
    if (thread->stacksize) {
        pthread_attr_setstacksize(&type, thread->stacksize);
    }
 
    /* Create the thread and go! */
    if (pthread_create(&thread->handle, &type, RunThread, thread) != 0) {
        return SDL_SetError("Not enough resources to create thread");
    }
 
    return 0;
}

References SDL_Thread::handle, int(), RunThread(), SDL_SetError, SDL_TRUE, and SDL_Thread::stacksize.

SDL_SYS_DetachThread()

void SDL_SYS_DetachThread

(

SDL_Thread *

thread

)

Definition at line 305 of file SDL_systhread.c.

{
    pthread_detach(thread->handle);
}

References SDL_Thread::handle.

SDL_SYS_SetThreadPriority()

int SDL_SYS_SetThreadPriority

(

SDL_ThreadPriority

priority

)

Definition at line 199 of file SDL_systhread.c.

{
#if __NACL__ || __RISCOS__
    /* FIXME: Setting thread priority does not seem to be supported in NACL */
    return 0;
#else
    struct sched_param sched;
    int policy;
    int pri_policy;
    pthread_t thread = pthread_self();
    const char *policyhint = SDL_GetHint(SDL_HINT_THREAD_PRIORITY_POLICY);
    const SDL_bool timecritical_realtime_hint = SDL_GetHintBoolean(SDL_HINT_THREAD_FORCE_REALTIME_TIME_CRITICAL, SDL_FALSE);
 
    if (pthread_getschedparam(thread, &policy, &sched) != 0) {
        return SDL_SetError("pthread_getschedparam() failed");
    }
 
    /* Higher priority levels may require changing the pthread scheduler policy
     * for the thread.  SDL will make such changes by default but there is
     * also a hint allowing that behavior to be overridden. */
    switch (priority) {
    case SDL_THREAD_PRIORITY_LOW:
    case SDL_THREAD_PRIORITY_NORMAL:
        pri_policy = SCHED_OTHER;
        break;
    case SDL_THREAD_PRIORITY_HIGH:
    case SDL_THREAD_PRIORITY_TIME_CRITICAL:
#if defined(__MACOSX__) || defined(__IPHONEOS__) || defined(__TVOS__)
        /* Apple requires SCHED_RR for high priority threads */
        pri_policy = SCHED_RR;
        break;
#else
        pri_policy = SCHED_OTHER;
        break;
#endif
    default:
        pri_policy = policy;
        break;
    }
 
    if (timecritical_realtime_hint && priority == SDL_THREAD_PRIORITY_TIME_CRITICAL) {
        pri_policy = SCHED_RR;
    }
 
    if (policyhint) {
        if (SDL_strcmp(policyhint, "current") == 0) {
            /* Leave current thread scheduler policy unchanged */
        } else if (SDL_strcmp(policyhint, "other") == 0) {
            policy = SCHED_OTHER;
        } else if (SDL_strcmp(policyhint, "rr") == 0) {
            policy = SCHED_RR;
        } else if (SDL_strcmp(policyhint, "fifo") == 0) {
            policy = SCHED_FIFO;
        } else {
            policy = pri_policy;
        }
    } else {
        policy = pri_policy;
    }
 
#if __LINUX__
    {
        pid_t linuxTid = syscall(SYS_gettid);
        return SDL_LinuxSetThreadPriorityAndPolicy(linuxTid, priority, policy);
    }
#else
    if (priority == SDL_THREAD_PRIORITY_LOW) {
        sched.sched_priority = sched_get_priority_min(policy);
    } else if (priority == SDL_THREAD_PRIORITY_TIME_CRITICAL) {
        sched.sched_priority = sched_get_priority_max(policy);
    } else {
        int min_priority = sched_get_priority_min(policy);
        int max_priority = sched_get_priority_max(policy);
 
#if defined(__MACOSX__) || defined(__IPHONEOS__) || defined(__TVOS__)
        if (min_priority == 15 && max_priority == 47) {
            /* Apple has a specific set of thread priorities */
            if (priority == SDL_THREAD_PRIORITY_HIGH) {
                sched.sched_priority = 45;
            } else {
                sched.sched_priority = 37;
            }
        } else
#endif /* __MACOSX__ || __IPHONEOS__ || __TVOS__ */
        {
            sched.sched_priority = (min_priority + (max_priority - min_priority) / 2);
            if (priority == SDL_THREAD_PRIORITY_HIGH) {
                sched.sched_priority += ((max_priority - min_priority) / 4);
            }
        }
    }
    if (pthread_setschedparam(thread, policy, &sched) != 0) {
        return SDL_SetError("pthread_setschedparam() failed");
    }
    return 0;
#endif /* linux */
#endif /* #if __NACL__ || __RISCOS__ */
}

References SDL_FALSE, SDL_GetHint, SDL_GetHintBoolean, SDL_HINT_THREAD_FORCE_REALTIME_TIME_CRITICAL, SDL_HINT_THREAD_PRIORITY_POLICY, SDL_SetError, SDL_strcmp, SDL_THREAD_PRIORITY_HIGH, SDL_THREAD_PRIORITY_LOW, SDL_THREAD_PRIORITY_NORMAL, and SDL_THREAD_PRIORITY_TIME_CRITICAL.

SDL_SYS_SetupThread()

void SDL_SYS_SetupThread

(

const char *

name

)

Definition at line 127 of file SDL_systhread.c.

{
#if !defined(__NACL__)
    int i;
    sigset_t mask;
#endif /* !__NACL__ */
 
    if (name != NULL) {
        #if defined(__MACOSX__) || defined(__IPHONEOS__) || defined(__LINUX__)
        SDL_assert(checked_setname);
        if (ppthread_setname_np != NULL) {
            #if defined(__MACOSX__) || defined(__IPHONEOS__)
            ppthread_setname_np(name);
            #elif defined(__LINUX__)
            ppthread_setname_np(pthread_self(), name);
            #endif
        }
        #elif HAVE_PTHREAD_SETNAME_NP
            #if defined(__NETBSD__)
            pthread_setname_np(pthread_self(), "%s", name);
            #else
            pthread_setname_np(pthread_self(), name);
            #endif
        #elif HAVE_PTHREAD_SET_NAME_NP
            pthread_set_name_np(pthread_self(), name);
        #elif defined(__HAIKU__)
            /* The docs say the thread name can't be longer than B_OS_NAME_LENGTH. */
            char namebuf[B_OS_NAME_LENGTH];
            SDL_snprintf(namebuf, sizeof (namebuf), "%s", name);
            namebuf[sizeof (namebuf) - 1] = '\0';
            rename_thread(find_thread(NULL), namebuf);
        #endif
    }
 
   /* NativeClient does not yet support signals.*/
#if !defined(__NACL__)
    /* Mask asynchronous signals for this thread */
    sigemptyset(&mask);
    for (i = 0; sig_list[i]; ++i) {
        sigaddset(&mask, sig_list[i]);
    }
    pthread_sigmask(SIG_BLOCK, &mask, 0);
#endif /* !__NACL__ */
 
 
#ifdef PTHREAD_CANCEL_ASYNCHRONOUS
    /* Allow ourselves to be asynchronously cancelled */
    {
        int oldstate;
        pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldstate);
    }
#endif
}

References i, NULL, SDL_assert, SDL_snprintf, and sig_list.

SDL_SYS_WaitThread()

void SDL_SYS_WaitThread

(

SDL_Thread *

thread

)

Definition at line 299 of file SDL_systhread.c.

{
    pthread_join(thread->handle, 0);
}

References SDL_Thread::handle.

SDL_ThreadID()

SDL_threadID SDL_ThreadID

(

void

)

Get the thread identifier for the current thread.

Definition at line 182 of file SDL_systhread.c.

{
    return ((SDL_threadID) pthread_self());
}

Variable Documentation

sig_list

const int sig_list[]

static

Initial value:

= {
    SIGHUP, SIGINT, SIGQUIT, SIGPIPE, SIGALRM, SIGTERM, SIGCHLD, SIGWINCH,
    SIGVTALRM, SIGPROF, 0
}

Definition at line 66 of file SDL_systhread.c.

Referenced by SDL_SYS_SetupThread().