TEST(Deadlock, Simple) {
const ResourceId resIdA(RESOURCE_DATABASE, std::string("A"));
const ResourceId resIdB(RESOURCE_DATABASE, std::string("B"));
LockerForTests locker1(MODE_IX);
LockerForTests locker2(MODE_IX);
ASSERT_EQUALS(LOCK_OK, locker1.lockBegin(nullptr, resIdA, MODE_X));
ASSERT_EQUALS(LOCK_OK, locker2.lockBegin(nullptr, resIdB, MODE_X));
// 1 -> 2
ASSERT_EQUALS(LOCK_WAITING, locker1.lockBegin(nullptr, resIdB, MODE_X));
// 2 -> 1
ASSERT_EQUALS(LOCK_WAITING, locker2.lockBegin(nullptr, resIdA, MODE_X));
DeadlockDetector wfg1(*getGlobalLockManager(), &locker1);
ASSERT(wfg1.check().hasCycle());
DeadlockDetector wfg2(*getGlobalLockManager(), &locker2);
ASSERT(wfg2.check().hasCycle());
// Cleanup, so that LockerImpl doesn't complain about leaked locks
locker1.unlock(resIdB);
locker2.unlock(resIdA);
}
TEST(Deadlock, Indirect) {
const ResourceId resIdA(RESOURCE_DATABASE, std::string("A"));
const ResourceId resIdB(RESOURCE_DATABASE, std::string("B"));
LockerForTests locker1(MODE_IX);
LockerForTests locker2(MODE_IX);
LockerForTests lockerIndirect(MODE_IX);
ASSERT_EQUALS(LOCK_OK, locker1.lockBegin(nullptr, resIdA, MODE_X));
ASSERT_EQUALS(LOCK_OK, locker2.lockBegin(nullptr, resIdB, MODE_X));
// 1 -> 2
ASSERT_EQUALS(LOCK_WAITING, locker1.lockBegin(nullptr, resIdB, MODE_X));
// 2 -> 1
ASSERT_EQUALS(LOCK_WAITING, locker2.lockBegin(nullptr, resIdA, MODE_X));
// 3 -> 2
ASSERT_EQUALS(LOCK_WAITING, lockerIndirect.lockBegin(nullptr, resIdA, MODE_X));
DeadlockDetector wfg1(*getGlobalLockManager(), &locker1);
ASSERT(wfg1.check().hasCycle());
DeadlockDetector wfg2(*getGlobalLockManager(), &locker2);
ASSERT(wfg2.check().hasCycle());
// Indirect locker should not report the cycle since it does not participate in it
DeadlockDetector wfgIndirect(*getGlobalLockManager(), &lockerIndirect);
ASSERT(!wfgIndirect.check().hasCycle());
// Cleanup, so that LockerImpl doesn't complain about leaked locks
locker1.unlock(resIdB);
locker2.unlock(resIdA);
}
TEST(Deadlock, IndirectWithUpgrade) {
const ResourceId resIdFlush(RESOURCE_MMAPV1_FLUSH, 1);
const ResourceId resIdDb(RESOURCE_DATABASE, 2);
LockerForTests flush(MODE_IX);
LockerForTests reader(MODE_IS);
LockerForTests writer(MODE_IX);
// This sequence simulates the deadlock which occurs during flush
ASSERT_EQUALS(LOCK_OK, writer.lockBegin(nullptr, resIdFlush, MODE_IX));
ASSERT_EQUALS(LOCK_OK, writer.lockBegin(nullptr, resIdDb, MODE_X));
ASSERT_EQUALS(LOCK_OK, reader.lockBegin(nullptr, resIdFlush, MODE_IS));
// R -> W
ASSERT_EQUALS(LOCK_WAITING, reader.lockBegin(nullptr, resIdDb, MODE_S));
// R -> W
// F -> W
ASSERT_EQUALS(LOCK_WAITING, flush.lockBegin(nullptr, resIdFlush, MODE_S));
// W yields its flush lock, so now f is granted in mode S
//
// R -> W
writer.unlock(resIdFlush);
// Flush thread upgrades S -> X in order to do the remap
//
// R -> W
// F -> R
ASSERT_EQUALS(LOCK_WAITING, flush.lockBegin(nullptr, resIdFlush, MODE_X));
// W comes back from the commit and tries to re-acquire the flush lock
//
// R -> W
// F -> R
// W -> F
ASSERT_EQUALS(LOCK_WAITING, writer.lockBegin(nullptr, resIdFlush, MODE_IX));
// Run deadlock detection from the point of view of each of the involved lockers
DeadlockDetector wfgF(*getGlobalLockManager(), &flush);
ASSERT(wfgF.check().hasCycle());
DeadlockDetector wfgR(*getGlobalLockManager(), &reader);
ASSERT(wfgR.check().hasCycle());
DeadlockDetector wfgW(*getGlobalLockManager(), &writer);
ASSERT(wfgW.check().hasCycle());
// Cleanup, so that LockerImpl doesn't complain about leaked locks
flush.unlock(resIdFlush);
writer.unlock(resIdFlush);
}
TEST(Deadlock, NoDeadlock) {
const ResourceId resId(RESOURCE_DATABASE, std::string("A"));
LockerForTests locker1(MODE_IS);
LockerForTests locker2(MODE_IS);
ASSERT_EQUALS(LOCK_OK, locker1.lockBegin(nullptr, resId, MODE_S));
ASSERT_EQUALS(LOCK_OK, locker2.lockBegin(nullptr, resId, MODE_S));
DeadlockDetector wfg1(*getGlobalLockManager(), &locker1);
ASSERT(!wfg1.check().hasCycle());
DeadlockDetector wfg2(*getGlobalLockManager(), &locker2);
ASSERT(!wfg2.check().hasCycle());
}
TEST(Deadlock, SimpleUpgrade) {
const ResourceId resId(RESOURCE_DATABASE, std::string("A"));
LockerForTests locker1(MODE_IX);
LockerForTests locker2(MODE_IX);
// Both acquire lock in intent mode
ASSERT_EQUALS(LOCK_OK, locker1.lockBegin(nullptr, resId, MODE_IX));
ASSERT_EQUALS(LOCK_OK, locker2.lockBegin(nullptr, resId, MODE_IX));
// Both try to upgrade
ASSERT_EQUALS(LOCK_WAITING, locker1.lockBegin(nullptr, resId, MODE_X));
ASSERT_EQUALS(LOCK_WAITING, locker2.lockBegin(nullptr, resId, MODE_X));
DeadlockDetector wfg1(*getGlobalLockManager(), &locker1);
ASSERT(wfg1.check().hasCycle());
DeadlockDetector wfg2(*getGlobalLockManager(), &locker2);
ASSERT(wfg2.check().hasCycle());
// Cleanup, so that LockerImpl doesn't complain about leaked locks
locker1.unlock(resId);
locker2.unlock(resId);
}
virtual void run(){
int minutesRunning = 0;
std::string lastRunningTestName, currentTestName;
{
boost::lock_guard<boost::mutex> lk( globalCurrentTestNameMutex );
lastRunningTestName = globalCurrentTestName;
}
while (true) {
sleepsecs(60);
minutesRunning++;
{
boost::lock_guard<boost::mutex> lk( globalCurrentTestNameMutex );
currentTestName = globalCurrentTestName;
}
if (currentTestName != lastRunningTestName) {
minutesRunning = 0;
lastRunningTestName = currentTestName;
}
if (minutesRunning > 30){
log() << currentTestName << " has been running for more than 30 minutes. aborting." << endl;
::abort();
}
else if (minutesRunning > 1){
warning() << currentTestName << " has been running for more than " << minutesRunning-1 << " minutes." << endl;
// See what is stuck
getGlobalLockManager()->dump();
}
}
}
