Boost_1_39_0/boost/thread/pthread/once.hpp

   1 #ifndef BOOST_THREAD_PTHREAD_ONCE_HPP
   2 #define BOOST_THREAD_PTHREAD_ONCE_HPP
   3
   4 //  once.hpp
   5 //
   6 //  (C) Copyright 2007-8 Anthony Williams
   7 //
   8 //  Distributed under the Boost Software License, Version 1.0. (See
   9 //  accompanying file LICENSE_1_0.txt or copy at
  10 //  http://www.boost.org/LICENSE_1_0.txt)
  11
  12 #include <boost/thread/detail/config.hpp>
  13
  14 #include <pthread.h>
  15 #include <boost/assert.hpp>
  16 #include "pthread_mutex_scoped_lock.hpp"
  17 #include <boost/thread/pthread/pthread_mutex_scoped_lock.hpp>
  18 #include <boost/cstdint.hpp>
  19
  20 #include <boost/config/abi_prefix.hpp>
  21
  22 namespace boost
  23 {
  24
  25     struct once_flag
  26     {
  27         boost::uintmax_t epoch;
  28     };
  29
  30     namespace detail
  31     {
  32         BOOST_THREAD_DECL boost::uintmax_t& get_once_per_thread_epoch();
  33         BOOST_THREAD_DECL extern boost::uintmax_t once_global_epoch;
  34         BOOST_THREAD_DECL extern pthread_mutex_t once_epoch_mutex;
  35         BOOST_THREAD_DECL extern pthread_cond_t once_epoch_cv;
  36     }
  37
  38 #define BOOST_ONCE_INITIAL_FLAG_VALUE 0
  39 #define BOOST_ONCE_INIT {BOOST_ONCE_INITIAL_FLAG_VALUE}
  40
  41
  42     // Based on Mike Burrows fast_pthread_once algorithm as described in
  43     // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2444.html
  44     template<typename Function>
  45     void call_once(once_flag& flag,Function f)
  46     {
  47         static boost::uintmax_t const uninitialized_flag=BOOST_ONCE_INITIAL_FLAG_VALUE;
  48         static boost::uintmax_t const being_initialized=uninitialized_flag+1;
  49         boost::uintmax_t const epoch=flag.epoch;
  50         boost::uintmax_t& this_thread_epoch=detail::get_once_per_thread_epoch();
  51
  52         if(epoch<this_thread_epoch)
  53         {
  54             pthread::pthread_mutex_scoped_lock lk(&detail::once_epoch_mutex);
  55
  56             while(flag.epoch<=being_initialized)
  57             {
  58                 if(flag.epoch==uninitialized_flag)
  59                 {
  60                     flag.epoch=being_initialized;
  61                     try
  62                     {
  63                         pthread::pthread_mutex_scoped_unlock relocker(&detail::once_epoch_mutex);
  64                         f();
  65                     }
  66                     catch(...)
  67                     {
  68                         flag.epoch=uninitialized_flag;
  69                         BOOST_VERIFY(!pthread_cond_broadcast(&detail::once_epoch_cv));
  70                         throw;
  71                     }
  72                     flag.epoch=--detail::once_global_epoch;
  73                     BOOST_VERIFY(!pthread_cond_broadcast(&detail::once_epoch_cv));
  74                 }
  75                 else
  76                 {
  77                     while(flag.epoch==being_initialized)
  78                     {
  79                         BOOST_VERIFY(!pthread_cond_wait(&detail::once_epoch_cv,&detail::once_epoch_mutex));
  80                     }
  81                 }
  82             }
  83             this_thread_epoch=detail::once_global_epoch;
  84         }
  85     }
  86 }
  87
  88 #include <boost/config/abi_suffix.hpp>
  89
  90 #endif