vpx_once.h 3.99 KB
Newer Older
1
/*
2
 *  Copyright (c) 2015 The WebM project authors. All Rights Reserved.
3 4 5 6 7 8 9
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */
10

11 12
#ifndef VPX_PORTS_VPX_ONCE_H_
#define VPX_PORTS_VPX_ONCE_H_
13

14 15
#include "vpx_config.h"

16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39
/* Implement a function wrapper to guarantee initialization
 * thread-safety for library singletons.
 *
 * NOTE: These functions use static locks, and can only be
 * used with one common argument per compilation unit. So
 *
 * file1.c:
 *   vpx_once(foo);
 *   ...
 *   vpx_once(foo);
 *
 *   file2.c:
 *     vpx_once(bar);
 *
 * will ensure foo() and bar() are each called only once, but in
 *
 * file1.c:
 *   vpx_once(foo);
 *   vpx_once(bar):
 *
 * bar() will never be called because the lock is used up
 * by the call to foo().
 */

40 41 42
#if CONFIG_MULTITHREAD && defined(_WIN32)
#include <windows.h>
#include <stdlib.h>
43 44 45 46 47 48 49 50
/* Declare a per-compilation-unit state variable to track the progress
 * of calling func() only once. This must be at global scope because
 * local initializers are not thread-safe in MSVC prior to Visual
 * Studio 2015.
 *
 * As a static, once_state will be zero-initialized as program start.
 */
static LONG once_state;
51 52
static void once(void (*func)(void))
{
53 54
    /* Try to advance once_state from its initial value of 0 to 1.
     * Only one thread can succeed in doing so.
55
     */
56 57 58 59 60 61
    if (InterlockedCompareExchange(&once_state, 1, 0) == 0) {
        /* We're the winning thread, having set once_state to 1.
         * Call our function. */
        func();
        /* Now advance once_state to 2, unblocking any other threads. */
        InterlockedIncrement(&once_state);
62 63 64
        return;
    }

65 66 67 68 69 70
    /* We weren't the winning thread, but we want to block on
     * the state variable so we don't return before func()
     * has finished executing elsewhere.
     *
     * Try to advance once_state from 2 to 2, which is only possible
     * after the winning thead advances it from 1 to 2.
71
     */
72 73 74 75 76 77 78 79 80 81 82 83
    while (InterlockedCompareExchange(&once_state, 2, 2) != 2) {
        /* State isn't yet 2. Try again.
         *
         * We are used for singleton initialization functions,
         * which should complete quickly. Contention will likewise
         * be rare, so it's worthwhile to use a simple but cpu-
         * intensive busy-wait instead of successive backoff,
         * waiting on a kernel object, or another heavier-weight scheme.
         *
         * We can at least yield our timeslice.
         */
        Sleep(0);
84 85
    }

86 87 88 89 90
    /* We've seen once_state advance to 2, so we know func()
     * has been called. And we've left once_state as we found it,
     * so other threads will have the same experience.
     *
     * It's safe to return now.
91
     */
92
    return;
93 94 95
}


96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122
#elif CONFIG_MULTITHREAD && defined(__OS2__)
#define INCL_DOS
#include <os2.h>
static void once(void (*func)(void))
{
    static int done;

    /* If the initialization is complete, return early. */
    if(done)
        return;

    /* Causes all other threads in the process to block themselves
     * and give up their time slice.
     */
    DosEnterCritSec();

    if (!done)
    {
        func();
        done = 1;
    }

    /* Restores normal thread dispatching for the current process. */
    DosExitCritSec();
}


123 124 125 126 127 128 129 130 131 132
#elif CONFIG_MULTITHREAD && HAVE_PTHREAD_H
#include <pthread.h>
static void once(void (*func)(void))
{
    static pthread_once_t lock = PTHREAD_ONCE_INIT;
    pthread_once(&lock, func);
}


#else
133
/* No-op version that performs no synchronization. *_rtcd() is idempotent,
134 135 136 137 138 139 140 141 142 143 144 145 146 147 148
 * so as long as your platform provides atomic loads/stores of pointers
 * no synchronization is strictly necessary.
 */

static void once(void (*func)(void))
{
    static int done;

    if(!done)
    {
        func();
        done = 1;
    }
}
#endif
149

150
#endif  // VPX_PORTS_VPX_ONCE_H_