xbmc/threads/test/TestSharedSection.cpp

   1 /*
   2  *  Copyright (C) 2005-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "threads/Event.h"
  10 #include "threads/IRunnable.h"
  11 #include "threads/SharedSection.h"
  12 #include "threads/test/TestHelpers.h"
  13
  14 #include <mutex>
  15 #include <shared_mutex>
  16 #include <stdio.h>
  17
  18 using namespace std::chrono_literals;
  19
  20 //=============================================================================
  21 // Helper classes
  22 //=============================================================================
  23
  24 template<class L>
  25 class locker : public IRunnable
  26 {
  27   CSharedSection& sec;
  28   CEvent* wait;
  29
  30   std::atomic<long>* mutex;
  31 public:
  32   volatile bool haslock;
  33   volatile bool obtainedlock;
  34
  35   inline locker(CSharedSection& o, std::atomic<long>* mutex_ = NULL, CEvent* wait_ = NULL) :
  36     sec(o), wait(wait_), mutex(mutex_), haslock(false), obtainedlock(false) {}
  37
  38   inline locker(CSharedSection& o, CEvent* wait_ = NULL) :
  39     sec(o), wait(wait_), mutex(NULL), haslock(false), obtainedlock(false) {}
  40
  41   void Run() override
  42   {
  43     AtomicGuard g(mutex);
  44     L lock(sec);
  45     haslock = true;
  46     obtainedlock = true;
  47     if (wait)
  48       wait->Wait();
  49     haslock = false;
  50   }
  51 };
  52
  53 TEST(TestCritSection, General)
  54 {
  55   CCriticalSection sec;
  56
  57   std::unique_lock<CCriticalSection> l1(sec);
  58   std::unique_lock<CCriticalSection> l2(sec);
  59 }
  60
  61 TEST(TestSharedSection, General)
  62 {
  63   CSharedSection sec;
  64
  65   std::shared_lock<CSharedSection> l1(sec);
  66   std::shared_lock<CSharedSection> l2(sec);
  67 }
  68
  69 TEST(TestSharedSection, GetSharedLockWhileTryingExclusiveLock)
  70 {
  71   std::atomic<long> mutex(0L);
  72   CEvent event;
  73
  74   CSharedSection sec;
  75
  76   std::shared_lock<CSharedSection> l1(sec); // get a shared lock
  77
  78   locker<std::unique_lock<CSharedSection>> l2(sec, &mutex);
  79   thread waitThread1(l2); // try to get an exclusive lock
  80
  81   EXPECT_TRUE(waitForThread(mutex, 1, 10000ms));
  82   std::this_thread::sleep_for(10ms); // still need to give it a chance to move ahead
  83
  84   EXPECT_TRUE(!l2.haslock);  // this thread is waiting ...
  85   EXPECT_TRUE(!l2.obtainedlock);  // this thread is waiting ...
  86
  87   // now try and get a SharedLock
  88   locker<std::shared_lock<CSharedSection>> l3(sec, &mutex, &event);
  89   thread waitThread3(l3); // try to get a shared lock
  90   EXPECT_TRUE(waitForThread(mutex, 2, 10000ms));
  91   std::this_thread::sleep_for(10ms);
  92   EXPECT_TRUE(l3.haslock);
  93
  94   event.Set();
  95   EXPECT_TRUE(waitThread3.timed_join(10000ms));
  96
  97   // l3 should have released.
  98   EXPECT_TRUE(!l3.haslock);
  99
 100   // but the exclusive lock should still not have happened
 101   EXPECT_TRUE(!l2.haslock);  // this thread is waiting ...
 102   EXPECT_TRUE(!l2.obtainedlock);  // this thread is waiting ...
 103
 104   // let it go
 105   l1.unlock(); // the last shared lock leaves.
 106
 107   EXPECT_TRUE(waitThread1.timed_join(10000ms));
 108
 109   EXPECT_TRUE(l2.obtainedlock);  // the exclusive lock was captured
 110   EXPECT_TRUE(!l2.haslock);  // ... but it doesn't have it anymore
 111 }
 112
 113 TEST(TestSharedSection, TwoCase)
 114 {
 115   CSharedSection sec;
 116
 117   CEvent event;
 118   std::atomic<long> mutex(0L);
 119
 120   locker<std::shared_lock<CSharedSection>> l1(sec, &mutex, &event);
 121
 122   {
 123     std::shared_lock<CSharedSection> lock(sec);
 124     thread waitThread1(l1);
 125
 126     EXPECT_TRUE(waitForWaiters(event, 1, 10000ms));
 127     EXPECT_TRUE(l1.haslock);
 128
 129     event.Set();
 130
 131     EXPECT_TRUE(waitThread1.timed_join(10000ms));
 132   }
 133
 134   locker<std::shared_lock<CSharedSection>> l2(sec, &mutex, &event);
 135   {
 136     std::unique_lock<CSharedSection> lock(sec); // get exclusive lock
 137     thread waitThread2(l2); // thread should block
 138
 139     EXPECT_TRUE(waitForThread(mutex, 1, 10000ms));
 140     std::this_thread::sleep_for(10ms);
 141
 142     EXPECT_TRUE(!l2.haslock);
 143
 144     lock.unlock();
 145
 146     EXPECT_TRUE(waitForWaiters(event, 1, 10000ms));
 147     std::this_thread::sleep_for(10ms);
 148     EXPECT_TRUE(l2.haslock);
 149
 150     event.Set();
 151
 152     EXPECT_TRUE(waitThread2.timed_join(10000ms));
 153   }
 154 }
 155
 156 TEST(TestMultipleSharedSection, General)
 157 {
 158   CSharedSection sec;
 159
 160   CEvent event;
 161   std::atomic<long> mutex(0L);
 162
 163   locker<std::shared_lock<CSharedSection>> l1(sec, &mutex, &event);
 164
 165   {
 166     std::shared_lock<CSharedSection> lock(sec);
 167     thread waitThread1(l1);
 168
 169     EXPECT_TRUE(waitForThread(mutex, 1, 10000ms));
 170     std::this_thread::sleep_for(10ms);
 171
 172     EXPECT_TRUE(l1.haslock);
 173
 174     event.Set();
 175
 176     EXPECT_TRUE(waitThread1.timed_join(10000ms));
 177   }
 178
 179   locker<std::shared_lock<CSharedSection>> l2(sec, &mutex, &event);
 180   locker<std::shared_lock<CSharedSection>> l3(sec, &mutex, &event);
 181   locker<std::shared_lock<CSharedSection>> l4(sec, &mutex, &event);
 182   locker<std::shared_lock<CSharedSection>> l5(sec, &mutex, &event);
 183   {
 184     std::unique_lock<CSharedSection> lock(sec);
 185     thread waitThread1(l2);
 186     thread waitThread2(l3);
 187     thread waitThread3(l4);
 188     thread waitThread4(l5);
 189
 190     EXPECT_TRUE(waitForThread(mutex, 4, 10000ms));
 191     std::this_thread::sleep_for(10ms);
 192
 193     EXPECT_TRUE(!l2.haslock);
 194     EXPECT_TRUE(!l3.haslock);
 195     EXPECT_TRUE(!l4.haslock);
 196     EXPECT_TRUE(!l5.haslock);
 197
 198     lock.unlock();
 199
 200     EXPECT_TRUE(waitForWaiters(event, 4, 10000ms));
 201
 202     EXPECT_TRUE(l2.haslock);
 203     EXPECT_TRUE(l3.haslock);
 204     EXPECT_TRUE(l4.haslock);
 205     EXPECT_TRUE(l5.haslock);
 206
 207     event.Set();
 208
 209     EXPECT_TRUE(waitThread1.timed_join(10000ms));
 210     EXPECT_TRUE(waitThread2.timed_join(10000ms));
 211     EXPECT_TRUE(waitThread3.timed_join(10000ms));
 212     EXPECT_TRUE(waitThread4.timed_join(10000ms));
 213   }
 214 }
 215