public virtual void IncrementFileCountForLocalCacheDirectory(Path cacheDir) { if (useLocalCacheDirectoryManager) { Path cacheRoot = LocalCacheDirectoryManager.GetCacheDirectoryRoot(cacheDir); if (cacheRoot != null) { LocalCacheDirectoryManager dir = directoryManagers[cacheRoot]; if (dir == null) { dir = new LocalCacheDirectoryManager(conf); LocalCacheDirectoryManager otherDir = directoryManagers.PutIfAbsent(cacheRoot, dir ); if (otherDir != null) { dir = otherDir; } } if (cacheDir.Equals(cacheRoot)) { dir.IncrementFileCountForPath(string.Empty); } else { string dirStr = cacheDir.ToUri().GetRawPath(); string rootStr = cacheRoot.ToUri().GetRawPath(); dir.IncrementFileCountForPath(Sharpen.Runtime.Substring(dirStr, rootStr.Length + 1)); } } } }
/// <summary>Add a new metrics to the registry</summary> /// <param name="metricsName">- the name</param> /// <param name="theMetricsObj">- the metrics</param> /// <exception cref="System.ArgumentException">if a name is already registered</exception> public virtual void Add(string metricsName, MetricsBase theMetricsObj) { if (metricsList.PutIfAbsent(metricsName, theMetricsObj) != null) { throw new ArgumentException("Duplicate metricsName:" + metricsName); } }
internal static TestBlockScanner.TestScanResultHandler.Info GetInfo(FsVolumeSpi volume ) { TestBlockScanner.TestScanResultHandler.Info newInfo = new TestBlockScanner.TestScanResultHandler.Info (); TestBlockScanner.TestScanResultHandler.Info prevInfo = infos.PutIfAbsent(volume.GetStorageID (), newInfo); return(prevInfo == null ? newInfo : prevInfo); }
// Root and Intermediate /// <summary> /// Returns a /// <see cref="SchedulingPolicy"/> /// instance corresponding to the passed clazz /// </summary> public static SchedulingPolicy GetInstance(Type clazz) { SchedulingPolicy policy = ReflectionUtils.NewInstance(clazz, null); SchedulingPolicy policyRet = instances.PutIfAbsent(clazz, policy); if (policyRet != null) { return(policyRet); } return(policy); }
private MetricsInfo[] GetGcInfo(string gcName) { MetricsInfo[] gcInfo = gcInfoCache[gcName]; if (gcInfo == null) { gcInfo = new MetricsInfo[2]; gcInfo[0] = Interns.Info("GcCount" + gcName, "GC Count for " + gcName); gcInfo[1] = Interns.Info("GcTimeMillis" + gcName, "GC Time for " + gcName); MetricsInfo[] previousGcInfo = gcInfoCache.PutIfAbsent(gcName, gcInfo); if (previousGcInfo != null) { return(previousGcInfo); } } return(gcInfo); }
private T Get <T>() where T : TranslationBundle { System.Type type = typeof(T); TranslationBundle bundle = map.Get(type); if (bundle == null) { bundle = GlobalBundleCache.LookupBundle <T>(locale); // There is a small opportunity for a race, which we may // lose. Accept defeat and return the winner's instance. TranslationBundle old = map.PutIfAbsent(type, bundle); if (old != null) { bundle = old; } } return((T)bundle); }
/// <exception cref="System.IO.IOException"/> protected internal virtual FileSystem CreateFileSystem(Configuration namenodeConf ) { string user = UserGroupInformation.GetCurrentUser().GetShortUserName(); FileSystemAccessService.CachedFileSystem newCachedFS = new FileSystemAccessService.CachedFileSystem (purgeTimeout); FileSystemAccessService.CachedFileSystem cachedFS = fsCache.PutIfAbsent(user, newCachedFS ); if (cachedFS == null) { cachedFS = newCachedFS; } Configuration conf = new Configuration(namenodeConf); conf.Set(HttpfsFsUser, user); return(cachedFS.GetFileSytem(conf)); }
private ContainerLauncherImpl.Container GetContainer(ContainerLauncherEvent @event ) { ContainerId id = @event.GetContainerID(); ContainerLauncherImpl.Container c = containers[id]; if (c == null) { c = new ContainerLauncherImpl.Container(this, @event.GetTaskAttemptID(), @event.GetContainerID (), @event.GetContainerMgrAddress()); ContainerLauncherImpl.Container old = containers.PutIfAbsent(id, c); if (old != null) { c = old; } } return(c); }
// cache the canonicalized hostnames; the cache currently isn't expired, // but the canonicals will only change if the host's resolver configuration // changes private static string CanonicalizeHost(string host) { // check if the host has already been canonicalized string fqHost = canonicalizedHostCache[host]; if (fqHost == null) { try { fqHost = SecurityUtil.GetByName(host).GetHostName(); // slight race condition, but won't hurt canonicalizedHostCache.PutIfAbsent(host, fqHost); } catch (UnknownHostException) { fqHost = host; } } return(fqHost); }
/// <summary>Add group to cache</summary> /// <param name="group">name of the group to add to cache</param> /// <param name="users">list of users for a given group</param> public static void Add(string group, IList <string> users) { foreach (string user in users) { ICollection <string> userGroups = userToNetgroupsMap[user]; // ConcurrentHashMap does not allow null values; // So null value check can be used to check if the key exists if (userGroups == null) { //Generate a ConcurrentHashSet (backed by the keyset of the ConcurrentHashMap) userGroups = Collections.NewSetFromMap(new ConcurrentHashMap <string, bool >()); ICollection <string> currentSet = userToNetgroupsMap.PutIfAbsent(user, userGroups); if (currentSet != null) { userGroups = currentSet; } } userGroups.AddItem(group); } }
/// <summary> /// Try to add a value to the map. /// </summary> internal T Add(string key, T value) { while (true) { var newEntry = new SoftReference <T>(value); var entry = map.PutIfAbsent(key, newEntry); if (entry != null) { // There was an entry in the map. var result = entry.Get(); if (result != null) { // The entry holds a valid reference, we're done return(result); } else { // The entry has been cleared map.Replace(key, newEntry); } } } }
/// <summary>Get the number of occurrences and increment atomically.</summary> /// <param name="identity">the identity of the user to increment</param> /// <returns>the value before incrementation</returns> /// <exception cref="System.Exception"/> private long GetAndIncrement(object identity) { // We will increment the count, or create it if no such count exists AtomicLong count = this.callCounts[identity]; if (count == null) { // Create the count since no such count exists. count = new AtomicLong(0); // Put it in, or get the AtomicInteger that was put in by another thread AtomicLong otherCount = callCounts.PutIfAbsent(identity, count); if (otherCount != null) { count = otherCount; } } // Update the total totalCalls.GetAndIncrement(); // At this point value is guaranteed to be not null. It may however have // been clobbered from callCounts. Nonetheless, we return what // we have. return(count.GetAndIncrement()); }
public override void UpdateAttempt(TaskAttemptStatusUpdateEvent.TaskAttemptStatus status, long timestamp) { base.UpdateAttempt(status, timestamp); TaskAttemptId attemptID = status.id; TaskId taskID = attemptID.GetTaskId(); JobId jobID = taskID.GetJobId(); Org.Apache.Hadoop.Mapreduce.V2.App.Job.Job job = context.GetJob(jobID); if (job == null) { return; } Task task = job.GetTask(taskID); if (task == null) { return; } TaskAttempt taskAttempt = task.GetAttempt(attemptID); if (taskAttempt == null) { return; } long boxedStart = startTimes[attemptID]; long start = boxedStart == null ? long.MinValue : boxedStart; // We need to do two things. // 1: If this is a completion, we accumulate statistics in the superclass // 2: If this is not a completion, we learn more about it. // This is not a completion, but we're cooking. // if (taskAttempt.GetState() == TaskAttemptState.Running) { // See if this task is already in the registry AtomicLong estimateContainer = attemptRuntimeEstimates[taskAttempt]; AtomicLong estimateVarianceContainer = attemptRuntimeEstimateVariances[taskAttempt ]; if (estimateContainer == null) { if (attemptRuntimeEstimates[taskAttempt] == null) { attemptRuntimeEstimates[taskAttempt] = new AtomicLong(); estimateContainer = attemptRuntimeEstimates[taskAttempt]; } } if (estimateVarianceContainer == null) { attemptRuntimeEstimateVariances.PutIfAbsent(taskAttempt, new AtomicLong()); estimateVarianceContainer = attemptRuntimeEstimateVariances[taskAttempt]; } long estimate = -1; long varianceEstimate = -1; // This code assumes that we'll never consider starting a third // speculative task attempt if two are already running for this task if (start > 0 && timestamp > start) { estimate = (long)((timestamp - start) / Math.Max(0.0001, status.progress)); varianceEstimate = (long)(estimate * status.progress / 10); } if (estimateContainer != null) { estimateContainer.Set(estimate); } if (estimateVarianceContainer != null) { estimateVarianceContainer.Set(varianceEstimate); } } }
public void TestPutIfAbsent2_NullReferenceException() { try { ConcurrentHashMap<Object, Object> c = new ConcurrentHashMap<Object, Object>(5); c.PutIfAbsent("whatever", null); ShouldThrow(); } catch(NullReferenceException) { } }