C++のCountDownLatchでブーストミューテックスと条件を使用する

Question

ブーストミューテックスと条件変数を使用してCountDownLatchを実装しようとしました。以下はコードであり、他に何かを追加する必要があるかどうかを知りたいと思っています。

このコードをユニットテストするにはどうすればよいですか？

template< class TypeVal > 
    class AtomicCounter 
    { 
    public: 
     AtomicCounter(TypeVal val) : m_typeVal(val) 
     { 
     } 

     AtomicCounter() : m_typeVal(0) 
     { 
     } 

     AtomicCounter(const AtomicCounter& cpy) : m_typeVal(cpy.m_typeVal) 
     { 
      boost::mutex::scoped_lock scoped_lock(cpy.m_atomicMutex); 
      m_typeVal = cpy.m_typeVal; 
     } 

     const AtomicCounter& operator=(const AtomicCounter& other) 
     { 
      if (this == &other) 
       return *this; 
      boost::mutex::scoped_lock lock1(&m_atomicMutex < &other.m_atomicMutex ? m_atomicMutex : other.m_atomicMutex); 
      boost::mutex::scoped_lock lock2(&m_atomicMutex > &other.m_atomicMutex ? m_atomicMutex : other.m_atomicMutex); 
      m_typeVal = other.m_typeVal; 
      return *this; 
     } 

     virtual ~AtomicCounter() 
     { 
     } 

     const TypeVal& getCount() const 
     { 
      boost::mutex::scoped_lock lock(m_atomicMutex); 
      return m_typeVal; 
     } 

     const TypeVal& setCount(const TypeVal &val) 
     { 
      boost::mutex::scoped_lock lock(m_atomicMutex); 
      m_typeVal = val; 
      return m_typeVal; 
     } 

     const TypeVal& increment() 
     { 
      boost::mutex::scoped_lock lock(m_atomicMutex); 
      m_typeVal++ ; 
      return m_typeVal; 
     } 

     const TypeVal& decrement() 
     { 
      boost::mutex::scoped_lock lock(m_atomicMutex); 
      m_typeVal-- ; 
      return m_typeVal; 
     } 

     const TypeVal& increment(const TypeVal& t) 
     { 
      boost::mutex::scoped_lock lock(m_atomicMutex); 
      m_typeVal+=t ; 
      return m_typeVal; 
     } 

     const TypeVal& decrement(const TypeVal& t) 
     { 
      boost::mutex::scoped_lock lock(m_atomicMutex); 
      m_typeVal-=t ; 
      return m_typeVal; 
     } 


    private: 
     mutable boost::mutex m_atomicMutex; 
     TypeVal m_typeVal; 
    }; 

      class CountDownLatch 
    { 
    public: 
     CountDownLatch(int count): m_cdlCount(count) 
     { 
     } 

     CountDownLatch(const CountDownLatch& cpy) 
     { 
      boost::unique_lock<boost::mutex>::unique_lock(const_cast<boost::mutex&>(cpy.m_cdlMutex)); 
      m_cdlCount = cpy.m_cdlCount; 
     } 

     const CountDownLatch& operator=(const CountDownLatch& other) 
     { 
      if (this == &other) 
       return *this; 
      boost::mutex::scoped_lock lock1(const_cast<boost::mutex&>(&m_cdlMutex < &other.m_cdlMutex ? m_cdlMutex : other.m_cdlMutex)); 
      boost::mutex::scoped_lock lock2(const_cast<boost::mutex&>(&m_cdlMutex > &other.m_cdlMutex ? m_cdlMutex : other.m_cdlMutex)); 
      m_cdlCount = other.m_cdlCount; 
      return *this; 
     } 

     virtual ~CountDownLatch() 
     { 
     } 
     void wait() 
     { 
      boost::mutex::scoped_lock lock(m_cdlMutex); 
      if(m_cdlCount.getCount() > 0) 
      { 
       m_cdlCondition.wait(lock); 
      } 
     } 
     void wait(uint64_t timeoutMicros) 
     { 
      boost::mutex::scoped_lock lock(m_cdlMutex); 
      if(m_cdlCount.getCount() > 0) 
      { 
       boost::posix_time::time_duration td = boost::posix_time::milliseconds(timeoutMicros); 
       m_cdlCondition.timed_wait(lock, td); 
      } 
     } 
     void countDown() 
     { 
      boost::mutex::scoped_lock lock(m_cdlMutex); 
      if(m_cdlCount.decrement() == 0) 
      { 
       m_cdlCondition.notify_all(); 
      } 
     } 

     int getCount() 
     { 
      return m_cdlCount.getCount(); 
     } 


    private: 
     boost::mutex m_cdlMutex; 
     boost::condition_variable m_cdlCondition; 
     AtomicCounter<int> m_cdlCount;   
    }; 

Answer 1

ユニットテストでは、ストレステストを試すことができます。たとえば、CountDownLatchの場合、CountDownLatch::countDown()を同時に呼び出す25個のテストスレッド、同時にCountDownLatch::getCount()を呼び出す25個の他のスレッド、およびCountDownLatch::wait()を呼び出す25個のスレッドを作成します。物事をより同時にするには、バリアを使用するか、同じ絶対時間までスリープ状態にします。すべてのスレッドがすべて正常に終了する（デッドロックなし）ことを確認してください。 CountDownLatch::m_cdlCountがゼロになることを確認してください。

同じテストを何回も実行します（妥当な時間）。

AtomicCounterについても同じ基本的な考え方を使用できます。

マルチヘッドコードをテストするための他のテクニックがありますが、これは私がよく知っているものです。