/// <summary> /// Acquire the {@code ReadLock} in an <i>unfair</i> way, without waiting for queued up writers. /// <p/> /// The <seealso cref="ReentrantReadWriteLock.ReadLock.tryLock() tryLock"/>-method of the {@code ReadLock} implementation of /// {@code ReentrantReadWriteLock} implements a <i>barging</i> behaviour, where if an exclusive lock is not held, /// the shared lock will be acquired, even if there are other threads waiting for the lock. This behaviour is /// regardless of whether the lock is fair or not. /// <p/> /// This allows us to avoid deadlocks where readers would wait for writers that wait for readers in critical /// methods. /// <p/> /// The naive way to implement this method would be: /// <pre><code> /// if ( !lock.tryLock() ) // try to barge /// lock.lock(); // fall back to normal blocking lock call /// </code></pre> /// This would however not implement the appropriate barging behaviour in a scenario like the following: Say the /// exclusive lock is held, and there is a queue waiting containing first a reader and then a writer, in this case /// the {@code tryLock()} method will return false. If the writer then finishes between the naive implementation /// exiting {@code tryLock()} and before entering {@code lock()} the {@code barge(...)} method would now block in /// the exact way we don't want it to block, with a read lock held and a writer waiting.<br/> /// In order to get around this situation, the implementation of this method uses a /// <seealso cref="Lock.tryLock(long, TimeUnit) timed wait"/> in a retry-loop in order to ensure that we make another /// attempt to barge the lock at a later point. /// <p/> /// This method is written to be compatible with the signature of <seealso cref="Lock.lock()"/>, which is not interruptible, /// but implemented based on the interruptible <seealso cref="Lock.tryLock(long, TimeUnit)"/>, so the implementation needs to /// remember being interrupted, and reset the flag before exiting, so that later invocations of interruptible /// methods detect the interruption. /// </summary> /// <param name="lock"> a <seealso cref="java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock"/> </param> private static void Barge(ReentrantReadWriteLock.ReadLock @lock) { bool interrupted = false; // exponential retry back-off, no more than 1 second for (long timeout = 10; [email protected](); timeout = Math.Min(1000, timeout * 2)) { try { if (@lock.tryLock(timeout, TimeUnit.MILLISECONDS)) { return; } } // the barge()-method is uninterruptable, but implemented based on the interruptible tryLock()-method catch (InterruptedException) { Thread.interrupted(); // ensure the interrupt flag is cleared interrupted = true; // remember to set interrupt flag before we exit } } if (interrupted) { Thread.CurrentThread.Interrupt(); // reset the interrupt flag } }
public CommonNodeLabelsManager() : base(typeof(CommonNodeLabelsManager).FullName) { ReentrantReadWriteLock Lock = new ReentrantReadWriteLock(); readLock = Lock.ReadLock(); writeLock = Lock.WriteLock(); }
public QueueCapacities(bool isRoot) { ReentrantReadWriteLock Lock = new ReentrantReadWriteLock(); readLock = Lock.ReadLock(); writeLock = Lock.WriteLock(); capacitiesMap = new Dictionary <string, QueueCapacities.Capacities>(); this.isRoot = isRoot; }
public StatefulContainer(NMClientAsync client, ContainerId containerId) { this.nmClientAsync = client; this.containerId = containerId; stateMachine = stateMachineFactory.Make(this); ReentrantReadWriteLock Lock = new ReentrantReadWriteLock(); readLock = Lock.ReadLock(); writeLock = Lock.WriteLock(); }
public ResourceUsage() { // short for no-label :) ReentrantReadWriteLock Lock = new ReentrantReadWriteLock(); readLock = Lock.ReadLock(); writeLock = Lock.WriteLock(); usages = new Dictionary <string, ResourceUsage.UsageByLabel>(); usages[Nl] = new ResourceUsage.UsageByLabel(Nl); }
public RMAppAttemptMetrics(ApplicationAttemptId attemptId, RMContext rmContext) { // preemption info // application headroom //HM: Line below replaced by one above for issue wih array 2nd dim //new int[NodeType.values().length][NodeType.values().length]; this.attemptId = attemptId; ReentrantReadWriteLock Lock = new ReentrantReadWriteLock(); this.readLock = Lock.ReadLock(); this.writeLock = Lock.WriteLock(); this.rmContext = rmContext; }
/// <summary>Construct the service.</summary> /// <param name="name">service name</param> public AbstractYarnScheduler(string name) : base(name) { // Nodes in the cluster, indexed by NodeId // Whole capacity of the cluster /* * All schedulers which are inheriting AbstractYarnScheduler should use * concurrent version of 'applications' map. */ ReentrantReadWriteLock Lock = new ReentrantReadWriteLock(); this.maxAllocReadLock = Lock.ReadLock(); this.maxAllocWriteLock = Lock.WriteLock(); }
public ApplicationImpl(Dispatcher dispatcher, string user, ApplicationId appId, Credentials credentials, Context context) { this.dispatcher = dispatcher; this.user = user; this.appId = appId; this.credentials = credentials; this.aclsManager = context.GetApplicationACLsManager(); this.context = context; ReentrantReadWriteLock Lock = new ReentrantReadWriteLock(); readLock = Lock.ReadLock(); writeLock = Lock.WriteLock(); stateMachine = stateMachineFactory.Make(this); }
public RMContainerImpl(Container container, ApplicationAttemptId appAttemptId, NodeId nodeId, string user, RMContext rmContext, long creationTime) { // Transitions from NEW state // Transitions from RESERVED state // nothing to do // nothing to do // Transitions from ALLOCATED state // Transitions from ACQUIRED state // Transitions from RUNNING state // Transitions from COMPLETED state // Transitions from EXPIRED state // Transitions from RELEASED state // Transitions from KILLED state // create the topology tables this.stateMachine = stateMachineFactory.Make(this); this.containerId = container.GetId(); this.nodeId = nodeId; this.container = container; this.appAttemptId = appAttemptId; this.user = user; this.creationTime = creationTime; this.rmContext = rmContext; this.eventHandler = rmContext.GetDispatcher().GetEventHandler(); this.containerAllocationExpirer = rmContext.GetContainerAllocationExpirer(); this.isAMContainer = false; this.resourceRequests = null; ReentrantReadWriteLock Lock = new ReentrantReadWriteLock(); this.readLock = Lock.ReadLock(); this.writeLock = Lock.WriteLock(); saveNonAMContainerMetaInfo = rmContext.GetYarnConfiguration().GetBoolean(YarnConfiguration .ApplicationHistorySaveNonAmContainerMetaInfo, YarnConfiguration.DefaultApplicationHistorySaveNonAmContainerMetaInfo ); rmContext.GetRMApplicationHistoryWriter().ContainerStarted(this); // If saveNonAMContainerMetaInfo is true, store system metrics for all // containers. If false, and if this container is marked as the AM, metrics // will still be published for this container, but that calculation happens // later. if (saveNonAMContainerMetaInfo) { rmContext.GetSystemMetricsPublisher().ContainerCreated(this, this.creationTime); } }