Beispiel #1
0
int main()
{
    {
    typedef std::shared_timed_mutex M;
	M m0;
	M m1;
    std::shared_lock<M> lk0(m0);
    std::shared_lock<M> lk1(m1);
    lk1 = std::move(lk0);
    assert(lk1.mutex() == std::addressof(m0));
    assert(lk1.owns_lock() == true);
    assert(lk0.mutex() == nullptr);
    assert(lk0.owns_lock() == false);
    }
    {
    typedef nasty_mutex M;
	M m0;
	M m1;
    std::shared_lock<M> lk0(m0);
    std::shared_lock<M> lk1(m1);
    lk1 = std::move(lk0);
    assert(lk1.mutex() == std::addressof(m0));
    assert(lk1.owns_lock() == true);
    assert(lk0.mutex() == nullptr);
    assert(lk0.owns_lock() == false);
    }
}
Beispiel #2
0
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    {
    typedef std::mutex M;
	M m0;
	M m1;
    std::unique_lock<M> lk0(m0);
    std::unique_lock<M> lk1(m1);
    lk1 = std::move(lk0);
    assert(lk1.mutex() == std::addressof(m0));
    assert(lk1.owns_lock() == true);
    assert(lk0.mutex() == nullptr);
    assert(lk0.owns_lock() == false);
    }
    {
    typedef nasty_mutex M;
	M m0;
	M m1;
    std::unique_lock<M> lk0(m0);
    std::unique_lock<M> lk1(m1);
    lk1 = std::move(lk0);
    assert(lk1.mutex() == std::addressof(m0));
    assert(lk1.owns_lock() == true);
    assert(lk0.mutex() == nullptr);
    assert(lk0.owns_lock() == false);
    }
#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}
Beispiel #3
0
int main()
{
  {
    boost::shared_lock<boost::shared_mutex> lk0(m0);
    boost::shared_lock<boost::shared_mutex> lk1(m1);
    lk1 = boost::move(lk0);
    BOOST_TEST(lk1.mutex() == &m0);
    BOOST_TEST(lk1.owns_lock() == true);
    BOOST_TEST(lk0.mutex() == 0);
    BOOST_TEST(lk0.owns_lock() == false);
  }
  {

    boost::shared_lock<boost::shared_mutex> lk1;
    lk1 = BOOST_THREAD_MAKE_RV_REF(boost::shared_lock<boost::shared_mutex>(m0));
    BOOST_TEST(lk1.mutex() == &m0);
    BOOST_TEST(lk1.owns_lock() == true);
  }
  {
    boost::unique_lock<boost::shared_mutex> lk0(m0);
    boost::shared_lock<boost::shared_mutex> lk1(m1);
    lk1 = BOOST_THREAD_MAKE_RV_REF(boost::shared_lock<boost::shared_mutex>(boost::move(lk0)));
    BOOST_TEST(lk1.mutex() == &m0);
    BOOST_TEST(lk1.owns_lock() == true);
    BOOST_TEST(lk0.mutex() == 0);
    BOOST_TEST(lk0.owns_lock() == false);
  }
  {

    boost::shared_lock<boost::shared_mutex> lk1;
    lk1 = BOOST_THREAD_MAKE_RV_REF(boost::shared_lock<boost::shared_mutex>(boost::unique_lock<boost::shared_mutex>(m0)));
    BOOST_TEST(lk1.mutex() == &m0);
    BOOST_TEST(lk1.owns_lock() == true);
  }
  {
    boost::upgrade_lock<boost::shared_mutex> lk0(m0);
    boost::shared_lock<boost::shared_mutex> lk1(m1);
    lk1 = BOOST_THREAD_MAKE_RV_REF(boost::shared_lock<boost::shared_mutex>(boost::move(lk0)));
    BOOST_TEST(lk1.mutex() == &m0);
    BOOST_TEST(lk1.owns_lock() == true);
    BOOST_TEST(lk0.mutex() == 0);
    BOOST_TEST(lk0.owns_lock() == false);
  }
  {

    boost::shared_lock<boost::shared_mutex> lk1;
    lk1 = BOOST_THREAD_MAKE_RV_REF(boost::shared_lock<boost::shared_mutex>(boost::upgrade_lock<boost::shared_mutex>(m0)));
    BOOST_TEST(lk1.mutex() == &m0);
    BOOST_TEST(lk1.owns_lock() == true);
  }
  return boost::report_errors();

}
void WSCoreBoundTaskQueue::executeTask() {

  //infinite thread loop
  while (1) {
    std::shared_ptr<Task> task;

    //block protected by _threadStatusMutex
    {
      std::lock_guard<std::mutex> lk1(_threadStatusMutex);
      if (_status == TO_STOP)
        break;
    }
    // lock queue to get task
    std::unique_lock<std::mutex> ul(_queueMutex);
    // get task and execute
    if (_runQueue.size() > 0) {
      // get first task
      task = _runQueue.front();
      _runQueue.pop_front();
      ul.unlock();
      if (task) {
        //LOG4CXX_DEBUG(logger, "Started executing task" << std::hex << &task << std::dec << " on core " << _core);
        // run task
        (*task)();
        //std::cout << "Executed task " << task->vname() << "; hex " << std::hex << &task << std::dec << " on core " << _core<< std::endl;
        LOG4CXX_DEBUG(logger, "Executed task " << std::hex << &task << std::dec << " on core " << _core);
        // notify done observers that task is done
        task->notifyDoneObservers();
      }
      // no task in runQueue -> try to steal task from other queue, otherwise sleep and wait for new tasks
    } else {
      // try to steal work
      ul.unlock();
      if (stealTasks() != NULL)
        continue;
      ul.lock();
      //if queue still empty go to sleep and wait until new tasks have been arrived
      if (_runQueue.size() < 1) {
        {
          //check if queue was suspended
          {
            std::lock_guard<std::mutex> lk1(_threadStatusMutex);
            if (_status != RUN)
              continue;
          }
          //std::cout << "queue " << _core << " sleeping " << std::endl;
          _condition.wait(ul);
        }
      }
    }
  }
}
Beispiel #5
0
 void rollbackTransactionFromOplog(BSONObj entry, bool purgeEntry) {
     bool transactionAlreadyApplied = entry["a"].Bool();
     Client::Transaction transaction(DB_SERIALIZABLE);
     if (transactionAlreadyApplied) {
         if (entry.hasElement("ref")) {
             rollbackRefOp(entry);
         } else if (entry.hasElement("ops")) {
             rollbackOps(entry["ops"].Array());
         } else {
             verify(0);
         }
     }
     {
         LOCK_REASON(lockReason, "repl: purging entry from oplog");
         Lock::DBRead lk1("local", lockReason);
         if (purgeEntry) {
             purgeEntryFromOplog(entry);
         }
         else {
             // set the applied bool to false, to let the oplog know that
             // this entry has not been applied to collections
             BSONElementManipulator(entry["a"]).setBool(false);
             writeEntryToOplog(entry, false);
         }
     }
     transaction.commit(DB_TXN_NOSYNC);
 }
Beispiel #6
0
 // takes an entry that was written _logTransactionOps
 // and applies them to collections
 //
 // TODO: possibly improve performance of this. We create and destroy a
 // context for each operation. Find a way to amortize it out if necessary
 //
 void applyTransactionFromOplog(BSONObj entry) {
     bool transactionAlreadyApplied = entry["a"].Bool();
     if (!transactionAlreadyApplied) {
         Client::Transaction transaction(DB_SERIALIZABLE);
         if (entry.hasElement("ref")) {
             applyRefOp(entry);
         } else if (entry.hasElement("ops")) {
             applyOps(entry["ops"].Array());
         } else {
             verify(0);
         }
         // set the applied bool to true, to let the oplog know that
         // this entry has been applied to collections
         BSONElementManipulator(entry["a"]).setBool(true);
         {
             LOCK_REASON(lockReason, "repl: setting oplog entry's applied bit");
             Lock::DBRead lk1("local", lockReason);
             writeEntryToOplog(entry, false);
         }
         // If this code fails, it is impossible to recover from
         // because we don't know if the transaction successfully committed
         // so we might as well crash
         // There is currently no known way this code can throw an exception
         try {
             // we are operating as a secondary. We don't have to fsync
             transaction.commit(DB_TXN_NOSYNC);
         }
         catch (std::exception &e) {
             log() << "exception during commit of applyTransactionFromOplog, aborting system: " << e.what() << endl;
             printStackTrace();
             logflush();
             ::abort();
         }
     }
 }
int main()
{
  boost::strict_lock<boost::mutex> lk0(m0);
  boost::strict_lock<boost::mutex> lk1(m1);
  lk1 = lk0;

}
Beispiel #8
0
int main()
{
  boost::shared_lock_guard<boost::shared_mutex> lk0(m0);
  boost::shared_lock_guard<boost::shared_mutex> lk1(m1);
  lk1 = lk0;

}
int main()
{
  boost::lock_guard<boost::mutex> lk0(m0);
  boost::lock_guard<boost::mutex> lk1(m1);
  lk1 = lk0;

}
void CoreBoundTaskQueue::executeTask() {

  //infinite thread loop
  while (1) {
    //block protected by _threadStatusMutex
    {
      std::lock_guard<std::mutex> lk1(_threadStatusMutex);
      if (_status == TO_STOP)
        break;
    }
    // lock queue to get task
    std::unique_lock<std::mutex> ul(_queueMutex);
    // get task and execute
    if (_runQueue.size() > 0) {
      std::shared_ptr<Task> task = _runQueue.front();
      // get first task
      _runQueue.pop();
      ul.unlock();
      if (task) {
        // set queue to _blocked as we run task; this is a simple mechanism to avoid that further tasks are pushed to this queue if a long running task is executed; check WSSimpleTaskScheduler for task stealing queue
        _blocked = true;
        //LOG4CXX_DEBUG(logger, "Started executing task" << std::hex << &task << std::dec << " on core " << _core);
        // run task
        //std::cout << "Executed task " << task->vname() << "; hex " << std::hex << &task << std::dec << " on core " << _core<< std::endl;
        (*task)();
        LOG4CXX_DEBUG(logger, "Executed task " << task->vname() << "; hex " << std::hex << &task << std::dec << " on core " << _core);
        // notify done observers that task is done
        task->notifyDoneObservers();
        _blocked = false;
      }
    }
    // no task in runQueue -> sleep and wait for new tasks
    else {
      //if queue still empty go to sleep and wait until new tasks have been arrived
      if (_runQueue.size() < 1) {
        // if thread is about to stop, break execution loop
        {
          std::lock_guard<std::mutex> lk1(_threadStatusMutex);
          if (_status != RUN)
            continue;
        }
        //std::cout << "queue " << _core << " sleeping " << std::endl;
        _condition.wait(ul);
      }
    }
  }
}
int main(int, char**)
{
    std::shared_lock<std::shared_timed_mutex> lk0(m0);
    std::shared_lock<std::shared_timed_mutex> lk1(m1);
    lk1 = lk0;

  return 0;
}
Beispiel #12
0
int main()
{
  boost::upgrade_lock<boost::shared_mutex> lk0(m0);
  boost::upgrade_lock<boost::shared_mutex> lk1(lk0);
  BOOST_TEST(lk1.mutex() == &m1);
  BOOST_TEST(lk1.owns_lock() == true);
  BOOST_TEST(lk0.mutex() == 0);
  BOOST_TEST(lk0.owns_lock() == false);
}
Beispiel #13
0
int main()
{
    std::unique_lock<std::mutex> lk0;
    assert(lk0.mutex() == nullptr);
    std::unique_lock<std::mutex> lk1(m);
    assert(lk1.mutex() == &m);
    lk1.unlock();
    assert(lk1.mutex() == &m);
}
Beispiel #14
0
TEST(unique_lock, swap) {
  lockable_mock m1, m2;
  ASSERT_FALSE(m1.locked());
  ASSERT_FALSE(m2.locked());

  {
    unique_lock lk1(m1);
    ASSERT_TRUE(lk1.locked());
    ASSERT_TRUE(m1.locked());

    {
      unique_lock lk2;
      ASSERT_FALSE(lk2.locked());
      swap(lk1, lk2);  // NOLINT
      EXPECT_FALSE(lk1.locked());
      EXPECT_TRUE(lk2.locked());
      EXPECT_TRUE(m1.locked());
    }

    EXPECT_FALSE(lk1.locked());
    EXPECT_FALSE(m1.locked());
  }

  {
    unique_lock lk1(m1);
    ASSERT_TRUE(lk1.locked());
    ASSERT_TRUE(m1.locked());

    {
      unique_lock lk2(m2);
      ASSERT_TRUE(lk2.locked());
      swap(lk1, lk2);  // NOLINT
      EXPECT_TRUE(lk1.locked());
      EXPECT_TRUE(lk2.locked());
      EXPECT_TRUE(m1.locked());
      EXPECT_TRUE(m2.locked());
    }

    EXPECT_TRUE(lk1.locked());
    EXPECT_FALSE(m1.locked());
    EXPECT_TRUE(m2.locked());
  }
}
Beispiel #15
0
 void logTransactionOpsRef(GTID gtid, uint64_t timestamp, uint64_t hash, OID& oid) {
     Lock::DBRead lk1("local");
     BSONObjBuilder b;
     addGTIDToBSON("_id", gtid, b);
     b.appendDate("ts", timestamp);
     b.append("h", (long long)hash);
     b.append("a", true);
     b.append("ref", oid);
     BSONObj bb = b.done();
     writeEntryToOplog(bb, true);
 }
Beispiel #16
0
int main()
{
  boost::unique_lock<boost::mutex> lk0(m0);
  boost::unique_lock<boost::mutex> lk1(m1);
  lk1 = lk0;
  BOOST_TEST(lk1.mutex() == &m0);
  BOOST_TEST(lk1.owns_lock() == true);
  BOOST_TEST(lk0.mutex() == 0);
  BOOST_TEST(lk0.owns_lock() == false);

}
Beispiel #17
0
int main(int, char**)
{
    std::unique_lock<std::mutex> lk0;
    assert(static_cast<bool>(lk0) == false);
    std::unique_lock<std::mutex> lk1(m);
    assert(static_cast<bool>(lk1) == true);
    lk1.unlock();
    assert(static_cast<bool>(lk1) == false);

  return 0;
}
Beispiel #18
0
int tc_libcxx_thread_thread_lock_unique_obs_op_bool(void)
{
    std::unique_lock<std::mutex> lk0;
    TC_ASSERT_EXPR(static_cast<bool>(lk0) == false);
    std::unique_lock<std::mutex> lk1(m);
    TC_ASSERT_EXPR(static_cast<bool>(lk1) == true);
    lk1.unlock();
    TC_ASSERT_EXPR(static_cast<bool>(lk1) == false);
    TC_SUCCESS_RESULT();
    return 0;
}
Beispiel #19
0
int main()
{
  boost::shared_lock < boost::shared_mutex > lk0;
  BOOST_TEST(bool(lk0) == false);
  boost::shared_lock < boost::shared_mutex > lk1(m);
  BOOST_TEST(bool(lk1) == true);
  lk1.unlock();
  BOOST_TEST(bool(lk1) == false);

  return boost::report_errors();
}
int main()
{
  boost::upgrade_lock<boost::shared_mutex> lk0;
  BOOST_TEST(lk0.mutex() == 0);
  boost::upgrade_lock<boost::shared_mutex> lk1(m);
  BOOST_TEST(lk1.mutex() == &m);
  lk1.unlock();
  BOOST_TEST(lk1.mutex() == &m);

  return boost::report_errors();
}
Beispiel #21
0
int main()
{
#if _LIBCPP_STD_VER > 11
    std::shared_lock<std::shared_timed_mutex> lk0;
    assert(lk0.owns_lock() == false);
    std::shared_lock<std::shared_timed_mutex> lk1(m);
    assert(lk1.owns_lock() == true);
    lk1.unlock();
    assert(lk1.owns_lock() == false);
    static_assert(noexcept(lk0.owns_lock()), "owns_lock must be noexcept");
#endif  // _LIBCPP_STD_VER > 11
}
Beispiel #22
0
int main()
{
  boost::shared_lock<shared_mutex> lk1(m);
  boost::shared_lock<shared_mutex> lk2;
  lk1.swap(lk2);
  BOOST_TEST(lk1.mutex() == 0);
  BOOST_TEST(lk1.owns_lock() == false);
  BOOST_TEST(lk2.mutex() == &m);
  BOOST_TEST(lk2.owns_lock() == true);

  return boost::report_errors();
}
int main()
{
  boost::unique_lock<boost::mutex> lk0;
  BOOST_TEST(lk0.owns_lock() == false);
  boost::unique_lock<boost::mutex> lk1(m);
  BOOST_TEST(lk1.owns_lock() == true);
  lk1.unlock();
  BOOST_TEST(lk1.owns_lock() == false);


  return boost::report_errors();
}
Beispiel #24
0
int main(int, char**)
{
    std::shared_lock<std::shared_timed_mutex> lk0;
    assert(lk0.mutex() == nullptr);
    std::shared_lock<std::shared_timed_mutex> lk1(m);
    assert(lk1.mutex() == &m);
    lk1.unlock();
    assert(lk1.mutex() == &m);
    static_assert(noexcept(lk0.mutex()), "mutex() must be noexcept");

  return 0;
}
Beispiel #25
0
int main()
{
#if _LIBCPP_STD_VER > 11
    std::shared_lock<std::shared_mutex> lk0(m0);
    std::shared_lock<std::shared_mutex> lk1(m1);
    lk1 = std::move(lk0);
    assert(lk1.mutex() == &m0);
    assert(lk1.owns_lock() == true);
    assert(lk0.mutex() == nullptr);
    assert(lk0.owns_lock() == false);
#endif  // _LIBCPP_STD_VER > 11
}
int main()
{
  {
    boost::unique_lock<boost::mutex> lk0;
    BOOST_TEST(bool(lk0) == false);
    boost::unique_lock<boost::mutex> lk1(m);
    BOOST_TEST(bool(lk1) == true);
    lk1.unlock();
    BOOST_TEST(bool(lk1) == false);
  }

  {
    boost::unique_lock<boost::mutex> lk0;
    if (lk0) BOOST_TEST(false);
    boost::unique_lock<boost::mutex> lk1(m);
    if (!lk1) BOOST_TEST(false);
    lk1.unlock();
    if (lk1) BOOST_TEST(false);
  }
  return boost::report_errors();
}
Beispiel #27
0
int main()
{
  boost::mutex m0;
  boost::mutex m1;
  boost::unique_lock<boost::mutex> lk0(m0);
  boost::unique_lock<boost::mutex> lk1(m1);
  {
    boost::reverse_lock<boost::unique_lock<boost::mutex> > lg0(lk0);
    boost::reverse_lock<boost::unique_lock<boost::mutex> > lg1(lk1);
    lg1 = lg0;
  }

}
Beispiel #28
0
void swap()
{
    boost::fibers::mutex mtx1, mtx2;

    boost::unique_lock< boost::fibers::mutex > lk1( mtx1), lk2( mtx2);

    BOOST_CHECK_EQUAL( lk1.mutex(), & mtx1);
    BOOST_CHECK_EQUAL( lk2.mutex(), & mtx2);

    lk1.swap( lk2);

    BOOST_CHECK_EQUAL( lk1.mutex(), & mtx2);
    BOOST_CHECK_EQUAL( lk2.mutex(), & mtx1);
}
Beispiel #29
0
    static void _logTransactionOps(GTID gtid, uint64_t timestamp, uint64_t hash, BSONArray& opInfo) {
        Lock::DBRead lk1("local");

        BSONObjBuilder b;
        addGTIDToBSON("_id", gtid, b);
        b.appendDate("ts", timestamp);
        b.append("h", (long long)hash);
        b.append("a", true);
        b.append("ops", opInfo);

        BSONObj bb = b.done();
        // write it to oplog
        LOG(3) << "writing " << bb.toString(false, true) << " to master " << endl;
        writeEntryToOplog(bb, true);
    }
Beispiel #30
0
void try_lock_concept()
{
    dummy_mutex mtx1, mtx2;
    mtx2.lock();

    boost::unique_lock< dummy_mutex > lk1( mtx1, boost::defer_lock),
        lk2( mtx2, boost::defer_lock);

    int res = boost::try_lock( lk1, lk2);
    
    BOOST_CHECK( res == 1);
    BOOST_CHECK( ! mtx1.is_locked);
    BOOST_CHECK( mtx2.is_locked);
    BOOST_CHECK( ! lk1.owns_lock() );
    BOOST_CHECK( ! lk2.owns_lock() );
}