Exemple #1
0
void SharedLock::ReleaseLock(Lock* plock)
{
    OVR_UNUSED(plock);
    OVR_ASSERT(plock == toLock());

    int oldUseCount;

    do {
        oldUseCount = UseCount;
        OVR_ASSERT(oldUseCount != LockInitMarker);

        if (oldUseCount == 1)
        {
            // Initialize marker
            if (AtomicOps<int>::CompareAndSet_Sync(&UseCount, 1, LockInitMarker))
            {
                Destruct<Lock>(toLock());

                do { }
                while (!AtomicOps<int>::CompareAndSet_Sync(&UseCount, LockInitMarker, 0));

                return;
            }
            continue;
        }

    } while (!AtomicOps<int>::CompareAndSet_NoSync(&UseCount, oldUseCount, oldUseCount - 1));
}
Lock* SharedLock::GetLockAddRef()
{
    int oldUseCount, oldUseCount_tmp;

    do {
        oldUseCount = UseCount;
        if (oldUseCount == (int)LockInitMarker)
            continue;

        if (oldUseCount == 0)
        {
            // Initialize marker
            int tmp_zero = 0;
            int tmp_LockInitMarker = LockInitMarker;
            if (UseCount.compare_exchange_strong(tmp_zero, LockInitMarker))
            {
                Construct<Lock>(Buffer);
                do { }
                while (UseCount.compare_exchange_weak(tmp_LockInitMarker, 1));
                return toLock();
            }
            continue;
        }
        oldUseCount_tmp = oldUseCount;
    } while (!UseCount.compare_exchange_weak(oldUseCount_tmp, oldUseCount + 1,
        std::memory_order_relaxed));

    return toLock();
}
Exemple #3
0
Lock* SharedLock::GetLockAddRef()
{
    int oldUseCount;

    do {
        oldUseCount = UseCount;
        if (oldUseCount == LockInitMarker)
            continue;

        if (oldUseCount == 0)
        {
            // Initialize marker
            if (AtomicOps<int>::CompareAndSet_Sync(&UseCount, 0, LockInitMarker))
            {
                Construct<Lock>(Buffer);
                do { }
                while (!AtomicOps<int>::CompareAndSet_Sync(&UseCount, LockInitMarker, 1));
                return toLock();
            }
            continue;
        }

    } while (!AtomicOps<int>::CompareAndSet_NoSync(&UseCount, oldUseCount, oldUseCount + 1));

    return toLock();
}
void SharedLock::ReleaseLock(Lock* plock)
{
    OVR_UNUSED(plock);
    OVR_ASSERT(plock == toLock());

    int oldUseCount, oldUseCount_tmp;

    do {
        oldUseCount = UseCount;
        OVR_ASSERT(oldUseCount != (int)LockInitMarker);

        if (oldUseCount == 1)
        {
            // Initialize marker
            int tmp_one = 1;
            int tmp_LockInitMarker = LockInitMarker;
            if (UseCount.compare_exchange_strong(tmp_one, LockInitMarker))
            {
                Destruct<Lock>(toLock());

                do { }
                while (!UseCount.compare_exchange_weak(tmp_LockInitMarker, 0));

                return;
            }
            continue;
        }

        oldUseCount_tmp = oldUseCount;
    } while (!UseCount.compare_exchange_weak(oldUseCount_tmp, oldUseCount - 1,
        std::memory_order_relaxed));
}