public override void ReleaseShared(ResourceType resourceType, params long[] resourceIds) { _stateHolder.incrementActiveClients(this); try { MutableLongIntMap sharedLocks = _sharedLockCounts[resourceType.TypeId()]; MutableLongIntMap exclusiveLocks = _exclusiveLockCounts[resourceType.TypeId()]; ConcurrentMap <long, ForsetiLockManager.Lock> resourceTypeLocks = _lockMaps[resourceType.TypeId()]; foreach (long resourceId in resourceIds) { if (ReleaseLocalLock(resourceType, resourceId, sharedLocks)) { continue; } // Only release if we were not holding an exclusive lock as well if (!exclusiveLocks.containsKey(resourceId)) { ReleaseGlobalLock(resourceTypeLocks, resourceId); } } } finally { _stateHolder.decrementActiveClients(); } }
public override bool ReEnterShared(ResourceType resourceType, long resourceId) { _stateHolder.incrementActiveClients(this); try { MutableLongIntMap heldShareLocks = _sharedLockCounts[resourceType.TypeId()]; MutableLongIntMap heldExclusiveLocks = _exclusiveLockCounts[resourceType.TypeId()]; int heldCount = heldShareLocks.getIfAbsent(resourceId, -1); if (heldCount != -1) { // We already have a lock on this, just increment our local reference counter. heldShareLocks.put(resourceId, Math.incrementExact(heldCount)); return(true); } if (heldExclusiveLocks.containsKey(resourceId)) { // We already have an exclusive lock, so just leave that in place. When the exclusive lock is released, // it will be automatically downgraded to a shared lock, since we bumped the share lock reference count. heldShareLocks.put(resourceId, 1); return(true); } // We didn't hold a lock already, so we cannot re-enter. return(false); } finally { _stateHolder.decrementActiveClients(); } }
private void ReleaseAllClientLocks() { // Force the release of all locks held. for (int i = 0; i < _exclusiveLockCounts.Length; i++) { MutableLongIntMap exclusiveLocks = _exclusiveLockCounts[i]; MutableLongIntMap sharedLocks = _sharedLockCounts[i]; // Begin releasing exclusive locks, as we may hold both exclusive and shared locks on the same resource, // and so releasing exclusive locks means we can "throw away" our shared lock (which would normally have // been re-instated after releasing the exclusive lock). if (exclusiveLocks != null) { int size = exclusiveLocks.size(); exclusiveLocks.forEachKey(_releaseExclusiveAndClearSharedVisitor.initialize(sharedLocks, _lockMaps[i])); if (size <= 32) { // If the map is small, its fast and nice to GC to clear it. However, if its large, it is // 1) Faster to simply allocate a new one and // 2) Safer, because we guard against clients getting giant maps over time if (size > 0) { exclusiveLocks.clear(); } } else { _exclusiveLockCounts[i] = new LongIntHashMap(); } } // Then release all remaining shared locks if (sharedLocks != null) { int size = sharedLocks.size(); sharedLocks.forEachKey(_releaseSharedDontCheckExclusiveVisitor.initialize(_lockMaps[i])); if (size <= 32) { // If the map is small, its fast and nice to GC to clear it. However, if its large, it is // 1) Faster to simply allocate a new one and // 2) Safer, because we guard against clients getting giant maps over time if (size > 0) { sharedLocks.clear(); } } else { _sharedLockCounts[i] = new LongIntHashMap(); } } } }
public override void ReleaseExclusive(ResourceType resourceType, params long[] resourceIds) { _stateHolder.incrementActiveClients(this); try { ConcurrentMap <long, ForsetiLockManager.Lock> resourceTypeLocks = _lockMaps[resourceType.TypeId()]; MutableLongIntMap exclusiveLocks = _exclusiveLockCounts[resourceType.TypeId()]; MutableLongIntMap sharedLocks = _sharedLockCounts[resourceType.TypeId()]; foreach (long resourceId in resourceIds) { if (ReleaseLocalLock(resourceType, resourceId, exclusiveLocks)) { continue; } if (sharedLocks.containsKey(resourceId)) { // We are still holding a shared lock, so we will release it to be reused ForsetiLockManager.Lock @lock = resourceTypeLocks.get(resourceId); if (@lock is SharedLock) { SharedLock sharedLock = ( SharedLock )@lock; if (sharedLock.UpdateLock) { sharedLock.ReleaseUpdateLock(); } else { throw new System.InvalidOperationException("Incorrect state of exclusive lock. Lock should be updated " + "to exclusive before attempt to release it. Lock: " + this); } } else { // in case if current lock is exclusive we swap it to new shared lock SharedLock sharedLock = new SharedLock(this); resourceTypeLocks.put(resourceId, sharedLock); } } else { // we do not hold shared lock so we just releasing it ReleaseGlobalLock(resourceTypeLocks, resourceId); } } } finally { _stateHolder.decrementActiveClients(); } }
public override bool TryExclusiveLock(ResourceType resourceType, long resourceId) { _hasLocks = true; _stateHolder.incrementActiveClients(this); try { ConcurrentMap <long, ForsetiLockManager.Lock> lockMap = _lockMaps[resourceType.TypeId()]; MutableLongIntMap heldLocks = _exclusiveLockCounts[resourceType.TypeId()]; int heldCount = heldLocks.getIfAbsent(resourceId, -1); if (heldCount != -1) { // We already have a lock on this, just increment our local reference counter. heldLocks.put(resourceId, Math.incrementExact(heldCount)); return(true); } // Grab the global lock ForsetiLockManager.Lock @lock; if ((@lock = lockMap.putIfAbsent(resourceId, _myExclusiveLock)) != null) { if (@lock is SharedLock && _sharedLockCounts[resourceType.TypeId()].containsKey(resourceId)) { SharedLock sharedLock = ( SharedLock )@lock; if (sharedLock.TryAcquireUpdateLock(this)) { if (sharedLock.NumberOfHolders() == 1) { heldLocks.put(resourceId, 1); return(true); } else { sharedLock.ReleaseUpdateLock(); return(false); } } } return(false); } heldLocks.put(resourceId, 1); return(true); } finally { _stateHolder.decrementActiveClients(); } }
/// <summary> /// Release a lock locally, and return true if we still hold more references to that lock. </summary> private bool ReleaseLocalLock(ResourceType type, long resourceId, MutableLongIntMap localLocks) { int lockCount = localLocks.removeKeyIfAbsent(resourceId, -1); if (lockCount == -1) { throw new System.InvalidOperationException(this + " cannot release lock that it does not hold: " + type + "[" + resourceId + "]."); } if (lockCount > 1) { localLocks.put(resourceId, lockCount - 1); return(true); } return(false); }
public override bool ReEnterExclusive(ResourceType resourceType, long resourceId) { _stateHolder.incrementActiveClients(this); try { MutableLongIntMap heldLocks = _exclusiveLockCounts[resourceType.TypeId()]; int heldCount = heldLocks.getIfAbsent(resourceId, -1); if (heldCount != -1) { // We already have a lock on this, just increment our local reference counter. heldLocks.put(resourceId, Math.incrementExact(heldCount)); return(true); } // We didn't hold a lock already, so we cannot re-enter. return(false); } finally { _stateHolder.decrementActiveClients(); } }
public override bool TrySharedLock(ResourceType resourceType, long resourceId) { _hasLocks = true; _stateHolder.incrementActiveClients(this); try { ConcurrentMap <long, ForsetiLockManager.Lock> lockMap = _lockMaps[resourceType.TypeId()]; MutableLongIntMap heldShareLocks = _sharedLockCounts[resourceType.TypeId()]; MutableLongIntMap heldExclusiveLocks = _exclusiveLockCounts[resourceType.TypeId()]; int heldCount = heldShareLocks.getIfAbsent(resourceId, -1); if (heldCount != -1) { // We already have a lock on this, just increment our local reference counter. heldShareLocks.put(resourceId, Math.incrementExact(heldCount)); return(true); } if (heldExclusiveLocks.containsKey(resourceId)) { // We already have an exclusive lock, so just leave that in place. When the exclusive lock is released, // it will be automatically downgraded to a shared lock, since we bumped the share lock reference count. heldShareLocks.put(resourceId, 1); return(true); } long waitStartMillis = _clock.millis(); while (true) { AssertValid(waitStartMillis, resourceType, resourceId); ForsetiLockManager.Lock existingLock = lockMap.get(resourceId); if (existingLock == null) { // Try to create a new shared lock if (lockMap.putIfAbsent(resourceId, new SharedLock(this)) == null) { // Success! break; } } else if (existingLock is SharedLock) { // Note that there is a "safe" race here where someone may be releasing the last reference to a lock // and thus removing that lock instance (making it unacquirable). In this case, we allow retrying, // even though this is a try-lock call. if ((( SharedLock )existingLock).Acquire(this)) { // Success! break; } else if ((( SharedLock )existingLock).UpdateLock) { return(false); } } else if (existingLock is ExclusiveLock) { return(false); } else { throw new System.NotSupportedException("Unknown lock type: " + existingLock); } } heldShareLocks.put(resourceId, 1); return(true); } finally { _stateHolder.decrementActiveClients(); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public void acquireExclusive(org.neo4j.storageengine.api.lock.LockTracer tracer, org.neo4j.storageengine.api.lock.ResourceType resourceType, long... resourceIds) throws org.neo4j.storageengine.api.lock.AcquireLockTimeoutException public override void AcquireExclusive(LockTracer tracer, ResourceType resourceType, params long[] resourceIds) { _hasLocks = true; _stateHolder.incrementActiveClients(this); LockWaitEvent waitEvent = null; try { ConcurrentMap <long, ForsetiLockManager.Lock> lockMap = _lockMaps[resourceType.TypeId()]; MutableLongIntMap heldLocks = _exclusiveLockCounts[resourceType.TypeId()]; foreach (long resourceId in resourceIds) { int heldCount = heldLocks.getIfAbsent(resourceId, -1); if (heldCount != -1) { // We already have a lock on this, just increment our local reference counter. heldLocks.put(resourceId, Math.incrementExact(heldCount)); continue; } // Grab the global lock ForsetiLockManager.Lock existingLock; int tries = 0; long waitStartMillis = _clock.millis(); while ((existingLock = lockMap.putIfAbsent(resourceId, _myExclusiveLock)) != null) { AssertValid(waitStartMillis, resourceType, resourceId); // If this is a shared lock: // Given a grace period of tries (to try and not starve readers), grab an update lock and wait // for it to convert to an exclusive lock. if (tries > 50 && existingLock is SharedLock) { // Then we should upgrade that lock SharedLock sharedLock = ( SharedLock )existingLock; if (TryUpgradeSharedToExclusive(tracer, waitEvent, resourceType, lockMap, resourceId, sharedLock, waitStartMillis)) { break; } } if (waitEvent == null) { waitEvent = tracer.WaitForLock(true, resourceType, resourceId); } WaitFor(existingLock, resourceType, resourceId, true, tries++); } heldLocks.put(resourceId, 1); } } finally { if (waitEvent != null) { waitEvent.Close(); } ClearWaitList(); _waitingForLock = null; _stateHolder.decrementActiveClients(); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public void acquireShared(org.neo4j.storageengine.api.lock.LockTracer tracer, org.neo4j.storageengine.api.lock.ResourceType resourceType, long... resourceIds) throws org.neo4j.storageengine.api.lock.AcquireLockTimeoutException public override void AcquireShared(LockTracer tracer, ResourceType resourceType, params long[] resourceIds) { _hasLocks = true; _stateHolder.incrementActiveClients(this); LockWaitEvent waitEvent = null; try { // Grab the global lock map we will be using ConcurrentMap <long, ForsetiLockManager.Lock> lockMap = _lockMaps[resourceType.TypeId()]; // And grab our local lock maps MutableLongIntMap heldShareLocks = _sharedLockCounts[resourceType.TypeId()]; MutableLongIntMap heldExclusiveLocks = _exclusiveLockCounts[resourceType.TypeId()]; foreach (long resourceId in resourceIds) { // First, check if we already hold this as a shared lock int heldCount = heldShareLocks.getIfAbsent(resourceId, -1); if (heldCount != -1) { // We already have a lock on this, just increment our local reference counter. heldShareLocks.put(resourceId, Math.incrementExact(heldCount)); continue; } // Second, check if we hold it as an exclusive lock if (heldExclusiveLocks.containsKey(resourceId)) { // We already have an exclusive lock, so just leave that in place. // When the exclusive lock is released, it will be automatically downgraded to a shared lock, // since we bumped the share lock reference count. heldShareLocks.put(resourceId, 1); continue; } // We don't hold the lock, so we need to grab it via the global lock map int tries = 0; SharedLock mySharedLock = null; long waitStartMillis = _clock.millis(); // Retry loop while (true) { AssertValid(waitStartMillis, resourceType, resourceId); // Check if there is a lock for this entity in the map ForsetiLockManager.Lock existingLock = lockMap.get(resourceId); // No lock if (existingLock == null) { // Try to create a new shared lock if (mySharedLock == null) { mySharedLock = new SharedLock(this); } if (lockMap.putIfAbsent(resourceId, mySharedLock) == null) { // Success, we now hold the shared lock. break; } else { continue; } } // Someone holds shared lock on this entity, try and get in on that action else if (existingLock is SharedLock) { if ((( SharedLock )existingLock).Acquire(this)) { // Success! break; } } // Someone holds an exclusive lock on this entity else if (existingLock is ExclusiveLock) { // We need to wait, just let the loop run. } else { throw new System.NotSupportedException("Unknown lock type: " + existingLock); } if (waitEvent == null) { waitEvent = tracer.WaitForLock(false, resourceType, resourceId); } // And take note of who we are waiting for. This is used for deadlock detection. WaitFor(existingLock, resourceType, resourceId, false, tries++); } // Make a local note about the fact that we now hold this lock heldShareLocks.put(resourceId, 1); } } finally { if (waitEvent != null) { waitEvent.Close(); } ClearWaitList(); _waitingForLock = null; _stateHolder.decrementActiveClients(); } }
internal virtual LongProcedure Initialize(MutableLongIntMap sharedLockCounts, ConcurrentMap <long, ForsetiLockManager.Lock> lockMap) { this.SharedLockCounts = sharedLockCounts; this.LockMap = lockMap; return(this); }