boost/thread/win32/shared_mutex.hpp

   1 #ifndef BOOST_THREAD_WIN32_SHARED_MUTEX_HPP
   2 #define BOOST_THREAD_WIN32_SHARED_MUTEX_HPP
   3
   4 //  (C) Copyright 2006-8 Anthony Williams
   5 //
   6 //  Distributed under the Boost Software License, Version 1.0. (See
   7 //  accompanying file LICENSE_1_0.txt or copy at
   8 //  http://www.boost.org/LICENSE_1_0.txt)
   9
  10 #include <boost/assert.hpp>
  11 #include <boost/detail/interlocked.hpp>
  12 #include <boost/thread/win32/thread_primitives.hpp>
  13 #include <boost/static_assert.hpp>
  14 #include <limits.h>
  15 #include <boost/utility.hpp>
  16 #include <boost/thread/thread_time.hpp>
  17
  18 #include <boost/config/abi_prefix.hpp>
  19
  20 namespace boost
  21 {
  22     class shared_mutex:
  23         private boost::noncopyable
  24     {
  25     private:
  26         struct state_data
  27         {
  28             unsigned shared_count:11,
  29                 shared_waiting:11,
  30                 exclusive:1,
  31                 upgrade:1,
  32                 exclusive_waiting:7,
  33                 exclusive_waiting_blocked:1;
  34
  35             friend bool operator==(state_data const& lhs,state_data const& rhs)
  36             {
  37                 return *reinterpret_cast<unsigned const*>(&lhs)==*reinterpret_cast<unsigned const*>(&rhs);
  38             }
  39         };
  40
  41
  42         template<typename T>
  43         T interlocked_compare_exchange(T* target,T new_value,T comparand)
  44         {
  45             BOOST_STATIC_ASSERT(sizeof(T)==sizeof(long));
  46             long const res=BOOST_INTERLOCKED_COMPARE_EXCHANGE(reinterpret_cast<long*>(target),
  47                                                               *reinterpret_cast<long*>(&new_value),
  48                                                               *reinterpret_cast<long*>(&comparand));
  49             return *reinterpret_cast<T const*>(&res);
  50         }
  51
  52         state_data state;
  53         detail::win32::handle semaphores[2];
  54         detail::win32::handle &unlock_sem;
  55         detail::win32::handle &exclusive_sem;
  56         detail::win32::handle upgrade_sem;
  57
  58         void release_waiters(state_data old_state)
  59         {
  60             if(old_state.exclusive_waiting)
  61             {
  62                 BOOST_VERIFY(detail::win32::ReleaseSemaphore(exclusive_sem,1,0)!=0);
  63             }
  64
  65             if(old_state.shared_waiting || old_state.exclusive_waiting)
  66             {
  67                 BOOST_VERIFY(detail::win32::ReleaseSemaphore(unlock_sem,old_state.shared_waiting + (old_state.exclusive_waiting?1:0),0)!=0);
  68             }
  69         }
  70
  71
  72     public:
  73         shared_mutex():
  74             unlock_sem(semaphores[0]),
  75             exclusive_sem(semaphores[1])
  76         {
  77             unlock_sem=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
  78             exclusive_sem=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
  79             upgrade_sem=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
  80             state_data state_={0};
  81             state=state_;
  82         }
  83
  84         ~shared_mutex()
  85         {
  86             detail::win32::CloseHandle(upgrade_sem);
  87             detail::win32::CloseHandle(unlock_sem);
  88             detail::win32::CloseHandle(exclusive_sem);
  89         }
  90
  91         bool try_lock_shared()
  92         {
  93             state_data old_state=state;
  94             for(;;)
  95             {
  96                 state_data new_state=old_state;
  97                 if(!new_state.exclusive && !new_state.exclusive_waiting_blocked)
  98                 {
  99                     ++new_state.shared_count;
 100                 }
 101
 102                 state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
 103                 if(current_state==old_state)
 104                 {
 105                     break;
 106                 }
 107                 old_state=current_state;
 108             }
 109             return !(old_state.exclusive| old_state.exclusive_waiting_blocked);
 110         }
 111
 112         void lock_shared()
 113         {
 114             BOOST_VERIFY(timed_lock_shared(::boost::detail::get_system_time_sentinel()));
 115         }
 116
 117         template<typename TimeDuration>
 118         bool timed_lock_shared(TimeDuration const & relative_time)
 119         {
 120             return timed_lock_shared(get_system_time()+relative_time);
 121         }
 122
 123         bool timed_lock_shared(boost::system_time const& wait_until)
 124         {
 125             for(;;)
 126             {
 127                 state_data old_state=state;
 128                 for(;;)
 129                 {
 130                     state_data new_state=old_state;
 131                     if(new_state.exclusive || new_state.exclusive_waiting_blocked)
 132                     {
 133                         ++new_state.shared_waiting;
 134                     }
 135                     else
 136                     {
 137                         ++new_state.shared_count;
 138                     }
 139
 140                     state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
 141                     if(current_state==old_state)
 142                     {
 143                         break;
 144                     }
 145                     old_state=current_state;
 146                 }
 147
 148                 if(!(old_state.exclusive| old_state.exclusive_waiting_blocked))
 149                 {
 150                     return true;
 151                 }
 152
 153                 unsigned long const res=detail::win32::WaitForSingleObject(unlock_sem,::boost::detail::get_milliseconds_until(wait_until));
 154                 if(res==detail::win32::timeout)
 155                 {
 156                     for(;;)
 157                     {
 158                         state_data new_state=old_state;
 159                         if(new_state.exclusive || new_state.exclusive_waiting_blocked)
 160                         {
 161                             if(new_state.shared_waiting)
 162                             {
 163                                 --new_state.shared_waiting;
 164                             }
 165                         }
 166                         else
 167                         {
 168                             ++new_state.shared_count;
 169                         }
 170
 171                         state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
 172                         if(current_state==old_state)
 173                         {
 174                             break;
 175                         }
 176                         old_state=current_state;
 177                     }
 178
 179                     if(!(old_state.exclusive| old_state.exclusive_waiting_blocked))
 180                     {
 181                         return true;
 182                     }
 183                     return false;
 184                 }
 185
 186                 BOOST_ASSERT(res==0);
 187             }
 188         }
 189
 190         void unlock_shared()
 191         {
 192             state_data old_state=state;
 193             for(;;)
 194             {
 195                 state_data new_state=old_state;
 196                 bool const last_reader=!--new_state.shared_count;
 197
 198                 if(last_reader)
 199                 {
 200                     if(new_state.upgrade)
 201                     {
 202                         new_state.upgrade=false;
 203                         new_state.exclusive=true;
 204                     }
 205                     else
 206                     {
 207                         if(new_state.exclusive_waiting)
 208                         {
 209                             --new_state.exclusive_waiting;
 210                             new_state.exclusive_waiting_blocked=false;
 211                         }
 212                         new_state.shared_waiting=0;
 213                     }
 214                 }
 215
 216                 state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
 217                 if(current_state==old_state)
 218                 {
 219                     if(last_reader)
 220                     {
 221                         if(old_state.upgrade)
 222                         {
 223                             BOOST_VERIFY(detail::win32::ReleaseSemaphore(upgrade_sem,1,0)!=0);
 224                         }
 225                         else
 226                         {
 227                             release_waiters(old_state);
 228                         }
 229                     }
 230                     break;
 231                 }
 232                 old_state=current_state;
 233             }
 234         }
 235
 236         void lock()
 237         {
 238             BOOST_VERIFY(timed_lock(::boost::detail::get_system_time_sentinel()));
 239         }
 240
 241         template<typename TimeDuration>
 242         bool timed_lock(TimeDuration const & relative_time)
 243         {
 244             return timed_lock(get_system_time()+relative_time);
 245         }
 246
 247         bool try_lock()
 248         {
 249             state_data old_state=state;
 250             for(;;)
 251             {
 252                 state_data new_state=old_state;
 253                 if(new_state.shared_count || new_state.exclusive)
 254                 {
 255                     return false;
 256                 }
 257                 else
 258                 {
 259                     new_state.exclusive=true;
 260                 }
 261
 262                 state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
 263                 if(current_state==old_state)
 264                 {
 265                     break;
 266                 }
 267                 old_state=current_state;
 268             }
 269             return true;
 270         }
 271
 272
 273         bool timed_lock(boost::system_time const& wait_until)
 274         {
 275             for(;;)
 276             {
 277                 state_data old_state=state;
 278
 279                 for(;;)
 280                 {
 281                     state_data new_state=old_state;
 282                     if(new_state.shared_count || new_state.exclusive)
 283                     {
 284                         ++new_state.exclusive_waiting;
 285                         new_state.exclusive_waiting_blocked=true;
 286                     }
 287                     else
 288                     {
 289                         new_state.exclusive=true;
 290                     }
 291
 292                     state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
 293                     if(current_state==old_state)
 294                     {
 295                         break;
 296                     }
 297                     old_state=current_state;
 298                 }
 299
 300                 if(!old_state.shared_count && !old_state.exclusive)
 301                 {
 302                     return true;
 303                 }
 304                 unsigned long const wait_res=detail::win32::WaitForMultipleObjects(2,semaphores,true,::boost::detail::get_milliseconds_until(wait_until));
 305                 if(wait_res==detail::win32::timeout)
 306                 {
 307                     for(;;)
 308                     {
 309                         state_data new_state=old_state;
 310                         if(new_state.shared_count || new_state.exclusive)
 311                         {
 312                             if(new_state.exclusive_waiting)
 313                             {
 314                                 if(!--new_state.exclusive_waiting)
 315                                 {
 316                                     new_state.exclusive_waiting_blocked=false;
 317                                 }
 318                             }
 319                         }
 320                         else
 321                         {
 322                             new_state.exclusive=true;
 323                         }
 324
 325                         state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
 326                         if(current_state==old_state)
 327                         {
 328                             break;
 329                         }
 330                         old_state=current_state;
 331                     }
 332                     if(!old_state.shared_count && !old_state.exclusive)
 333                     {
 334                         return true;
 335                     }
 336                     return false;
 337                 }
 338                 BOOST_ASSERT(wait_res<2);
 339             }
 340         }
 341
 342         void unlock()
 343         {
 344             state_data old_state=state;
 345             for(;;)
 346             {
 347                 state_data new_state=old_state;
 348                 new_state.exclusive=false;
 349                 if(new_state.exclusive_waiting)
 350                 {
 351                     --new_state.exclusive_waiting;
 352                     new_state.exclusive_waiting_blocked=false;
 353                 }
 354                 new_state.shared_waiting=0;
 355
 356                 state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
 357                 if(current_state==old_state)
 358                 {
 359                     break;
 360                 }
 361                 old_state=current_state;
 362             }
 363             release_waiters(old_state);
 364         }
 365
 366         void lock_upgrade()
 367         {
 368             for(;;)
 369             {
 370                 state_data old_state=state;
 371                 for(;;)
 372                 {
 373                     state_data new_state=old_state;
 374                     if(new_state.exclusive || new_state.exclusive_waiting_blocked || new_state.upgrade)
 375                     {
 376                         ++new_state.shared_waiting;
 377                     }
 378                     else
 379                     {
 380                         ++new_state.shared_count;
 381                         new_state.upgrade=true;
 382                     }
 383
 384                     state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
 385                     if(current_state==old_state)
 386                     {
 387                         break;
 388                     }
 389                     old_state=current_state;
 390                 }
 391
 392                 if(!(old_state.exclusive|| old_state.exclusive_waiting_blocked|| old_state.upgrade))
 393                 {
 394                     return;
 395                 }
 396
 397                 BOOST_VERIFY(!detail::win32::WaitForSingleObject(unlock_sem,detail::win32::infinite));
 398             }
 399         }
 400
 401         bool try_lock_upgrade()
 402         {
 403             state_data old_state=state;
 404             for(;;)
 405             {
 406                 state_data new_state=old_state;
 407                 if(new_state.exclusive || new_state.exclusive_waiting_blocked || new_state.upgrade)
 408                 {
 409                     return false;
 410                 }
 411                 else
 412                 {
 413                     ++new_state.shared_count;
 414                     new_state.upgrade=true;
 415                 }
 416
 417                 state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
 418                 if(current_state==old_state)
 419                 {
 420                     break;
 421                 }
 422                 old_state=current_state;
 423             }
 424             return true;
 425         }
 426
 427         void unlock_upgrade()
 428         {
 429             state_data old_state=state;
 430             for(;;)
 431             {
 432                 state_data new_state=old_state;
 433                 new_state.upgrade=false;
 434                 bool const last_reader=!--new_state.shared_count;
 435
 436                 if(last_reader)
 437                 {
 438                     if(new_state.exclusive_waiting)
 439                     {
 440                         --new_state.exclusive_waiting;
 441                         new_state.exclusive_waiting_blocked=false;
 442                     }
 443                     new_state.shared_waiting=0;
 444                 }
 445
 446                 state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
 447                 if(current_state==old_state)
 448                 {
 449                     if(last_reader)
 450                     {
 451                         release_waiters(old_state);
 452                     }
 453                     break;
 454                 }
 455                 old_state=current_state;
 456             }
 457         }
 458
 459         void unlock_upgrade_and_lock()
 460         {
 461             state_data old_state=state;
 462             for(;;)
 463             {
 464                 state_data new_state=old_state;
 465                 bool const last_reader=!--new_state.shared_count;
 466
 467                 if(last_reader)
 468                 {
 469                     new_state.upgrade=false;
 470                     new_state.exclusive=true;
 471                 }
 472
 473                 state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
 474                 if(current_state==old_state)
 475                 {
 476                     if(!last_reader)
 477                     {
 478                         BOOST_VERIFY(!detail::win32::WaitForSingleObject(upgrade_sem,detail::win32::infinite));
 479                     }
 480                     break;
 481                 }
 482                 old_state=current_state;
 483             }
 484         }
 485
 486         void unlock_and_lock_upgrade()
 487         {
 488             state_data old_state=state;
 489             for(;;)
 490             {
 491                 state_data new_state=old_state;
 492                 new_state.exclusive=false;
 493                 new_state.upgrade=true;
 494                 ++new_state.shared_count;
 495                 if(new_state.exclusive_waiting)
 496                 {
 497                     --new_state.exclusive_waiting;
 498                     new_state.exclusive_waiting_blocked=false;
 499                 }
 500                 new_state.shared_waiting=0;
 501
 502                 state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
 503                 if(current_state==old_state)
 504                 {
 505                     break;
 506                 }
 507                 old_state=current_state;
 508             }
 509             release_waiters(old_state);
 510         }
 511
 512         void unlock_and_lock_shared()
 513         {
 514             state_data old_state=state;
 515             for(;;)
 516             {
 517                 state_data new_state=old_state;
 518                 new_state.exclusive=false;
 519                 ++new_state.shared_count;
 520                 if(new_state.exclusive_waiting)
 521                 {
 522                     --new_state.exclusive_waiting;
 523                     new_state.exclusive_waiting_blocked=false;
 524                 }
 525                 new_state.shared_waiting=0;
 526
 527                 state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
 528                 if(current_state==old_state)
 529                 {
 530                     break;
 531                 }
 532                 old_state=current_state;
 533             }
 534             release_waiters(old_state);
 535         }
 536
 537         void unlock_upgrade_and_lock_shared()
 538         {
 539             state_data old_state=state;
 540             for(;;)
 541             {
 542                 state_data new_state=old_state;
 543                 new_state.upgrade=false;
 544                 if(new_state.exclusive_waiting)
 545                 {
 546                     --new_state.exclusive_waiting;
 547                     new_state.exclusive_waiting_blocked=false;
 548                 }
 549                 new_state.shared_waiting=0;
 550
 551                 state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
 552                 if(current_state==old_state)
 553                 {
 554                     break;
 555                 }
 556                 old_state=current_state;
 557             }
 558             release_waiters(old_state);
 559         }
 560
 561     };
 562 }
 563
 564 #include <boost/config/abi_suffix.hpp>
 565
 566 #endif