EmbeddedPkg: Extend NvVarStoreFormattedLib LIBRARY_CLASS

[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.2 / Python / thread_pth.h

\r
/* GNU pth threads interface\r
   http://www.gnu.org/software/pth\r
   2000-05-03 Andy Dustman <andy@dustman.net>\r
\r
   Adapted from Posix threads interface\r
   12 May 1997 -- david arnold <davida@pobox.com>\r
 */\r
\r
#include <stdlib.h>\r
#include <string.h>\r
#include <pth.h>\r
\r
/* A pth mutex isn't sufficient to model the Python lock type\r
 * because pth mutexes can be acquired multiple times by the\r
 * same thread.\r
 *\r
 * The pth_lock struct implements a Python lock as a "locked?" bit\r
 * and a <condition, mutex> pair.  In general, if the bit can be acquired\r
 * instantly, it is, else the pair is used to block the thread until the\r
 * bit is cleared.\r
 */\r
\r
typedef struct {\r
    char             locked; /* 0=unlocked, 1=locked */\r
    /* a <cond, mutex> pair to handle an acquire of a locked lock */\r
    pth_cond_t   lock_released;\r
    pth_mutex_t  mut;\r
} pth_lock;\r
\r
#define CHECK_STATUS(name)  if (status == -1) { printf("%d ", status); perror(name); error = 1; }\r
\r
pth_attr_t PyThread_attr;\r
\r
/*\r
 * Initialization.\r
 */\r
\r
static void PyThread__init_thread(void)\r
{\r
    pth_init();\r
    PyThread_attr = pth_attr_new();\r
    pth_attr_set(PyThread_attr, PTH_ATTR_STACK_SIZE, 1<<18);\r
    pth_attr_set(PyThread_attr, PTH_ATTR_JOINABLE, FALSE);\r
}\r
\r
/*\r
 * Thread support.\r
 */\r
\r
\r
long PyThread_start_new_thread(void (*func)(void *), void *arg)\r
{\r
    pth_t th;\r
    dprintf(("PyThread_start_new_thread called\n"));\r
    if (!initialized)\r
        PyThread_init_thread();\r
\r
    th = pth_spawn(PyThread_attr,\r
                             (void* (*)(void *))func,\r
                             (void *)arg\r
                             );\r
\r
    return th;\r
}\r
\r
long PyThread_get_thread_ident(void)\r
{\r
    volatile pth_t threadid;\r
    if (!initialized)\r
        PyThread_init_thread();\r
    /* Jump through some hoops for Alpha OSF/1 */\r
    threadid = pth_self();\r
    return (long) *(long *) &threadid;\r
}\r
\r
void PyThread_exit_thread(void)\r
{\r
    dprintf(("PyThread_exit_thread called\n"));\r
    if (!initialized) {\r
        exit(0);\r
    }\r
}\r
\r
/*\r
 * Lock support.\r
 */\r
PyThread_type_lock PyThread_allocate_lock(void)\r
{\r
    pth_lock *lock;\r
    int status, error = 0;\r
\r
    dprintf(("PyThread_allocate_lock called\n"));\r
    if (!initialized)\r
        PyThread_init_thread();\r
\r
    lock = (pth_lock *) malloc(sizeof(pth_lock));\r
    memset((void *)lock, '\0', sizeof(pth_lock));\r
    if (lock) {\r
        lock->locked = 0;\r
        status = pth_mutex_init(&lock->mut);\r
        CHECK_STATUS("pth_mutex_init");\r
        status = pth_cond_init(&lock->lock_released);\r
        CHECK_STATUS("pth_cond_init");\r
        if (error) {\r
            free((void *)lock);\r
            lock = NULL;\r
        }\r
    }\r
    dprintf(("PyThread_allocate_lock() -> %p\n", lock));\r
    return (PyThread_type_lock) lock;\r
}\r
\r
void PyThread_free_lock(PyThread_type_lock lock)\r
{\r
    pth_lock *thelock = (pth_lock *)lock;\r
\r
    dprintf(("PyThread_free_lock(%p) called\n", lock));\r
\r
    free((void *)thelock);\r
}\r
\r
int PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)\r
{\r
    int success;\r
    pth_lock *thelock = (pth_lock *)lock;\r
    int status, error = 0;\r
\r
    dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));\r
\r
    status = pth_mutex_acquire(&thelock->mut, !waitflag, NULL);\r
    CHECK_STATUS("pth_mutex_acquire[1]");\r
    success = thelock->locked == 0;\r
    if (success) thelock->locked = 1;\r
    status = pth_mutex_release( &thelock->mut );\r
    CHECK_STATUS("pth_mutex_release[1]");\r
\r
    if ( !success && waitflag ) {\r
        /* continue trying until we get the lock */\r
\r
        /* mut must be locked by me -- part of the condition\r
         * protocol */\r
        status = pth_mutex_acquire( &thelock->mut, !waitflag, NULL );\r
        CHECK_STATUS("pth_mutex_acquire[2]");\r
        while ( thelock->locked ) {\r
            status = pth_cond_await(&thelock->lock_released,\r
                                    &thelock->mut, NULL);\r
            CHECK_STATUS("pth_cond_await");\r
        }\r
        thelock->locked = 1;\r
        status = pth_mutex_release( &thelock->mut );\r
        CHECK_STATUS("pth_mutex_release[2]");\r
        success = 1;\r
    }\r
    if (error) success = 0;\r
    dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));\r
    return success;\r
}\r
\r
void PyThread_release_lock(PyThread_type_lock lock)\r
{\r
    pth_lock *thelock = (pth_lock *)lock;\r
    int status, error = 0;\r
\r
    dprintf(("PyThread_release_lock(%p) called\n", lock));\r
\r
    status = pth_mutex_acquire( &thelock->mut, 0, NULL );\r
    CHECK_STATUS("pth_mutex_acquire[3]");\r
\r
    thelock->locked = 0;\r
\r
    status = pth_mutex_release( &thelock->mut );\r
    CHECK_STATUS("pth_mutex_release[3]");\r
\r
    /* wake up someone (anyone, if any) waiting on the lock */\r
    status = pth_cond_notify( &thelock->lock_released, 0 );\r
    CHECK_STATUS("pth_cond_notify");\r
}\r