public static void DecrementExchangeExecutingCmdlets() { if (ThrottlingPerfCounterWrapper.PerfCountersInitialized) { ThrottlingPerfCounterWrapper.DecrementPerfCounter(ThrottlingPerfCounterWrapper.throttlingPerfCounters.ExchangeExecutingCmdlets); } }
// Token: 0x06007294 RID: 29332 RVA: 0x0017B570 File Offset: 0x00179770 public static bool SleepIfNecessary(uint cpuStartPercent, out int sleepTime, out float cpuPercent) { sleepTime = -1; cpuPercent = -1f; if (cpuStartPercent >= 100U || CPUBasedSleeper.ProcessCPUCounter == null) { return(false); } cpuPercent = CPUBasedSleeper.ProcessCPUCounter.GetValue(); if (cpuPercent >= cpuStartPercent) { int num = (int)(100U - cpuStartPercent); if (num > 0) { float num2 = 500f / (float)num; sleepTime = (int)((cpuPercent - cpuStartPercent) * num2); } if (sleepTime > 0) { Thread.Sleep(sleepTime); } else { sleepTime = -1; } } ThrottlingPerfCounterWrapper.UpdateAverageThreadSleepTime((long)Math.Max(sleepTime, 0)); return(sleepTime >= 0); }
public static void DecrementActivePowerShellRunspaces() { if (ThrottlingPerfCounterWrapper.PerfCountersInitialized) { ThrottlingPerfCounterWrapper.DecrementPerfCounter(ThrottlingPerfCounterWrapper.throttlingPerfCounters.ActivePowerShellRunspaces); } }
private static void UpdateBudgetsMicroDelayed() { if (!ThrottlingPerfCounterWrapper.PerfCountersInitialized) { return; } ThrottlingPerfCounterWrapper.SetNumberAndPercentCounters(ThrottlingPerfCounterWrapper.budgetsMicroDelayed, ThrottlingPerfCounterWrapper.userThrottlingPerfCounters.NumberOfUsersMicroDelayed, ThrottlingPerfCounterWrapper.userThrottlingPerfCounters.PercentageUsersMicroDelayed); }
private static void UpdateBudgetsAtMaxDelay() { if (!ThrottlingPerfCounterWrapper.PerfCountersInitialized) { return; } ThrottlingPerfCounterWrapper.SetNumberAndPercentCounters(ThrottlingPerfCounterWrapper.budgetsAtMaximumDelay, ThrottlingPerfCounterWrapper.userThrottlingPerfCounters.NumberOfUsersAtMaximumDelay, ThrottlingPerfCounterWrapper.userThrottlingPerfCounters.PercentageUsersAtMaximumDelay); }
public static void IncrementBudgetsAtMaxDelay(BudgetKey key) { if (!ThrottlingPerfCounterWrapper.PerfCountersInitialized) { return; } ThrottlingPerfCounterWrapper.budgetsAtMaximumDelay.TryInsertAbsolute(key, key, ThrottlingPerfCounterWrapper.PerfCounterRefreshWindow); ThrottlingPerfCounterWrapper.UpdateBudgetsAtMaxDelay(); }
public static void DecrementBudgetCount() { if (!ThrottlingPerfCounterWrapper.PerfCountersInitialized) { return; } ThrottlingPerfCounterWrapper.userThrottlingPerfCounters.TotalUniqueBudgets.Decrement(); ThrottlingPerfCounterWrapper.UpdateBudgetsAtMaxDelay(); ThrottlingPerfCounterWrapper.UpdateBudgetsLockedOut(); ThrottlingPerfCounterWrapper.UpdateBudgetsMicroDelayed(); ThrottlingPerfCounterWrapper.UpdateOverBudget(); }
// Token: 0x06007473 RID: 29811 RVA: 0x001800CC File Offset: 0x0017E2CC protected override void UpdateCachedPolicyValues(bool resetBudgetValues) { base.UpdateCachedPolicyValues(resetBudgetValues); lock (base.SyncRoot) { this.maxConcurrency = (int)(base.ThrottlingPolicy.MaxConcurrency.IsUnlimited ? 2147483647U : base.ThrottlingPolicy.MaxConcurrency.Value); if (resetBudgetValues) { this.connections = 0; ThrottlingPerfCounterWrapper.DecrementBudgetsAtMaxConcurrency(base.Owner); } } }
public static void IncrementOverBudget(BudgetKey key, TimeSpan backoffTime) { if (!ThrottlingPerfCounterWrapper.PerfCountersInitialized) { return; } if (backoffTime == TimeSpan.Zero || backoffTime == TimeSpan.MaxValue) { backoffTime = ThrottlingPerfCounterWrapper.PerfCounterRefreshWindow; } ThrottlingPerfCounterWrapper.budgetsOverBudget.TryInsertAbsolute(key, key, backoffTime); ThrottlingPerfCounterWrapper.userThrottlingPerfCounters.UniqueBudgetsOverBudget.RawValue = (long)ThrottlingPerfCounterWrapper.budgetsOverBudget.Count; ThrottlingPerfCounterWrapper.LogEventsIfNecessary(); }
// Token: 0x06007471 RID: 29809 RVA: 0x00180084 File Offset: 0x0017E284 protected override void AccountForCostHandle(CostHandle costHandle) { if (costHandle.CostType != CostType.Connection) { base.AccountForCostHandle(costHandle); return; } if (this.connections <= 0) { throw new InvalidOperationException("[StandardBudget.AccountForCostHandle] End for Connections was called, but there are no outstanding Connections."); } this.connections--; ThrottlingPerfCounterWrapper.DecrementBudgetsAtMaxConcurrency(base.Owner); }
// Token: 0x060073E1 RID: 29665 RVA: 0x0017DCC8 File Offset: 0x0017BEC8 public CostHandle StartActiveRunspace(Action <CostHandle> onRelease) { ExTraceGlobals.ClientThrottlingTracer.TraceDebug <BudgetKey>((long)this.GetHashCode(), "[PowerShellBudget.StartActiveRunspace] Start called for user {0}", base.Owner); this.Update(); if (this.IsMaxRunspacesPerTimePeriodEnabled()) { Interlocked.Decrement(ref this.runspacesRemaining); } Interlocked.Increment(ref this.activeRunspaces); if (this.TrackActiveRunspacePerfCounter) { ThrottlingPerfCounterWrapper.IncrementActivePowerShellRunspaces(); } return(new CostHandle(this, CostType.ActiveRunspace, onRelease, "PowerShellBudget.StartActiveRunspace", default(TimeSpan))); }
public static void Initialize(BudgetType budgetType, int?massOverBudgetPercent, bool allowReinitialize) { if (ThrottlingPerfCounterWrapper.PerfCountersInitialized && !allowReinitialize) { throw new InvalidOperationException(string.Format("ThrottlingPerformanceCounters were already initialized with budget type of '{0}'.", ThrottlingPerfCounterWrapper.budgetType)); } if (massOverBudgetPercent != null && (massOverBudgetPercent.Value < 0 || massOverBudgetPercent.Value > 100)) { throw new ArgumentOutOfRangeException("massOverBudgetPercent", massOverBudgetPercent.Value, "massOverBudgetPercent must be between 0 and 100 inclusive"); } ThrottlingPerfCounterWrapper.budgetType = budgetType; ThrottlingPerfCounterWrapper.massiveNumberOfUsersOverBudgetPercent = ((massOverBudgetPercent != null) ? massOverBudgetPercent.Value : DefaultThrottlingAlertValues.MassUserOverBudgetPercent(budgetType)); try { string instanceName = ThrottlingPerfCounterWrapper.GetInstanceName(budgetType.ToString()); ThrottlingPerfCounterWrapper.throttlingPerfCounters = MSExchangeThrottling.GetInstance(instanceName); ThrottlingPerfCounterWrapper.userThrottlingPerfCounters = MSExchangeUserThrottling.GetInstance(instanceName); ThrottlingPerfCounterWrapper.PerfCountersInitialized = true; } catch (Exception ex) { ThrottlingPerfCounterWrapper.PerfCountersInitialized = false; Globals.LogEvent(DirectoryEventLogConstants.Tuple_InitializePerformanceCountersFailed, string.Empty, new object[] { ex.ToString() }); ExTraceGlobals.ClientThrottlingTracer.TraceError <string, string>(0L, "[ThrottlingPerfCounterWrapper.Initialize] Perf counter initialization failed with exception type: {0}, Messsage: {1}", ex.GetType().FullName, ex.Message); } ThrottlingPerfCounterWrapper.budgetsMicroDelayed = new ExactTimeoutCache <BudgetKey, BudgetKey>(delegate(BudgetKey key, BudgetKey value, RemoveReason reason) { ThrottlingPerfCounterWrapper.UpdateBudgetsMicroDelayed(); }, null, null, 1000000, false, CacheFullBehavior.ExpireExisting); ThrottlingPerfCounterWrapper.budgetsAtMaximumDelay = new ExactTimeoutCache <BudgetKey, BudgetKey>(delegate(BudgetKey key, BudgetKey value, RemoveReason reason) { ThrottlingPerfCounterWrapper.UpdateBudgetsAtMaxDelay(); }, null, null, 1000000, false, CacheFullBehavior.ExpireExisting); ThrottlingPerfCounterWrapper.budgetsLockedOut = new ExactTimeoutCache <BudgetKey, BudgetKey>(delegate(BudgetKey key, BudgetKey value, RemoveReason reason) { ThrottlingPerfCounterWrapper.UpdateBudgetsLockedOut(); }, null, null, 1000000, false, CacheFullBehavior.ExpireExisting); ThrottlingPerfCounterWrapper.budgetsOverBudget = new ExactTimeoutCache <BudgetKey, BudgetKey>(delegate(BudgetKey key, BudgetKey value, RemoveReason reason) { ThrottlingPerfCounterWrapper.UpdateOverBudget(); }, null, null, 1000000, false, CacheFullBehavior.ExpireExisting); ThrottlingPerfCounterWrapper.budgetsAtMaxConcurrency = new HashSet <BudgetKey>(); }
private static void SetNumberAndPercentCounters(ExactTimeoutCache <BudgetKey, BudgetKey> cache, ExPerformanceCounter numberCounter, ExPerformanceCounter percentCounter) { if (!ThrottlingPerfCounterWrapper.PerfCountersInitialized) { return; } int budgetCount = ThrottlingPerfCounterWrapper.GetBudgetCount(); int count = cache.Count; numberCounter.RawValue = (long)count; int num = (budgetCount == 0) ? 0 : (100 * count / budgetCount); if (num > 100) { num = 100; } percentCounter.RawValue = (long)num; }
// Token: 0x060073E0 RID: 29664 RVA: 0x0017DC20 File Offset: 0x0017BE20 public CostHandle StartCmdlet(string cmdLetName, Action <CostHandle> onRelease) { ExTraceGlobals.ClientThrottlingTracer.TraceDebug <BudgetKey, string>((long)this.GetHashCode(), "[PowerShellBudget.StartCmdlet] Start called for user {0}, cmdlet: {1}", base.Owner, cmdLetName); this.Update(); if (this.IsCmdletPerTimePeriodEnabled()) { Interlocked.Decrement(ref this.cmdletsRemaining); } if (this.IsExchangeCmdletPerTimePeriodEnabled()) { Interlocked.Decrement(ref this.exchangeCmdletsRemaining); } if (this.IsDestructiveCmdletPerTimePeriodEnabled() && !string.IsNullOrEmpty(cmdLetName) && PowerShellBudget.DestructiveCmdlets.Contains(cmdLetName.ToLower())) { Interlocked.Decrement(ref this.destructiveCmdletsRemaining); } ThrottlingPerfCounterWrapper.IncrementExchangeExecutingCmdlets(); return(new CostHandle(this, CostType.CMDLET, onRelease, string.Format("PowerShellBudgetCache.StartCmdlet.{0}", cmdLetName), default(TimeSpan))); }
// Token: 0x0600746F RID: 29807 RVA: 0x0017FEEC File Offset: 0x0017E0EC public CostHandle StartConnection(Action <CostHandle> onRelease, string callerInfo) { CostHandle result; lock (base.SyncRoot) { int num = this.connections + 1; ExTraceGlobals.FaultInjectionTracer.TraceTest <int>(3701878077U, ref num); bool flag2 = false; ExTraceGlobals.FaultInjectionTracer.TraceTest <bool>(2630233405U, ref flag2); if (num > this.maxConcurrency || flag2) { ThrottlingPerfCounterWrapper.IncrementBudgetsAtMaxConcurrency(base.Owner); throw base.CreateOverBudgetException("MaxConcurrency", flag2 ? "FaultInjection" : this.maxConcurrency.ToString(), 0); } this.connections++; result = new CostHandle(this, CostType.Connection, onRelease, callerInfo, default(TimeSpan)); } return(result); }
private DelayInfo GetMicroDelay(ICollection <CostType> consideredCostTypes, BudgetTypeSetting budgetTypeSetting) { if (this.microDelayWorthyWork == TimeSpan.Zero || !consideredCostTypes.Contains(CostType.CAS)) { return(DelayInfo.NoDelay); } float balance = this.innerBudget.CasTokenBucket.GetBalance(); if (balance < 0f) { SingleComponentThrottlingPolicy throttlingPolicy = this.innerBudget.ThrottlingPolicy; int num = (int)this.microDelayWorthyWork.TotalMilliseconds; int num2 = num * (int)(3600000U / throttlingPolicy.RechargeRate.Value); float num3 = -balance / throttlingPolicy.RechargeRate.Value; TimeSpan timeSpan = TimeSpan.FromMilliseconds((double)((float)num2 * num3)); TimeSpan timeSpan2 = (BudgetWrapper <T> .MinimumMicroDelay > timeSpan) ? BudgetWrapper <T> .MinimumMicroDelay : timeSpan; TimeSpan timeSpan3 = timeSpan2; TimeSpan timeSpan4 = (budgetTypeSetting.MaxMicroDelayMultiplier == int.MaxValue) ? TimeSpan.MaxValue : TimeSpan.FromMilliseconds((double)(num * budgetTypeSetting.MaxMicroDelayMultiplier)); if (timeSpan3 > timeSpan4) { ExTraceGlobals.ClientThrottlingTracer.TraceDebug((long)this.GetHashCode(), "[BudgetWrapper.GetDelay] Budget '{0}' calculated an overBudgetFactor of '{1}', but used registry cap of '{2}' instead. Budget Snapshot: '{3}'", new object[] { this.Owner, num3, budgetTypeSetting.MaxMicroDelayMultiplier, this }); timeSpan3 = timeSpan4; } if (timeSpan3 > budgetTypeSetting.MaxDelay) { ExTraceGlobals.ClientThrottlingTracer.TraceDebug <BudgetKey, TimeSpan, TimeSpan>((long)this.GetHashCode(), "[BudgetWrapper.GetDelay] Budget '{0}' calculated a cappedDelay of '{1}' which was higher than registry MaxDelay of '{2}'. Using MaxDelay instead.", this.Owner, timeSpan3, budgetTypeSetting.MaxDelay); ThrottlingPerfCounterWrapper.IncrementBudgetsAtMaxDelay(this.Owner); timeSpan3 = budgetTypeSetting.MaxDelay; } ThrottlingPerfCounterWrapper.IncrementBudgetsMicroDelayed(this.Owner); DelayInfo.TraceMicroDelays(this, TimeSpan.FromMilliseconds((double)num), timeSpan3); return(new DelayInfo(timeSpan3, false)); } return(DelayInfo.NoDelay); }
private static void LogEventsIfNecessary() { int num = 0; int num2 = 0; int num3 = 0; lock (ThrottlingPerfCounterWrapper.staticLock) { int budgetCount = ThrottlingPerfCounterWrapper.GetBudgetCount(); num3 = ((budgetCount > 0) ? (100 * ThrottlingPerfCounterWrapper.budgetsOverBudget.Count / budgetCount) : 0); } if (num3 > ThrottlingPerfCounterWrapper.massiveNumberOfUsersOverBudgetPercent && ThrottlingPerfCounterWrapper.budgetsOverBudget.Count > ThrottlingPerfCounterWrapper.minUniqueBudgetsForMassiveOverBudgetAlert) { bool flag2 = false; lock (ThrottlingPerfCounterWrapper.staticLock) { if (ThrottlingPerfCounterWrapper.budgetsOverBudget.Count > ThrottlingPerfCounterWrapper.minUniqueBudgetsForMassiveOverBudgetAlert) { flag2 = true; num = ThrottlingPerfCounterWrapper.GetBudgetCount(); num2 = ThrottlingPerfCounterWrapper.budgetsOverBudget.Count; } } if (flag2) { if (ThrottlingPerfCounterWrapper.OnLogMassiveNumberOfUsersOverBudgetDelegate != null) { ThrottlingPerfCounterWrapper.OnLogMassiveNumberOfUsersOverBudgetDelegate(num, num3); } Globals.LogEvent(DirectoryEventLogConstants.Tuple_ExcessiveMassUserThrottling, ThrottlingPerfCounterWrapper.budgetType.ToString(), new object[] { num2, ThrottlingPerfCounterWrapper.budgetType, num, num3 }); } } }
// Token: 0x060073E4 RID: 29668 RVA: 0x0017DDDC File Offset: 0x0017BFDC protected override void AccountForCostHandle(CostHandle costHandle) { ExTraceGlobals.ClientThrottlingTracer.TraceDebug <BudgetKey, CostType, BudgetType>((long)this.GetHashCode(), "[PowerShellBudget.AccountForCostHandle] End called for user {0}, cost type {1}, budget type {2}", base.Owner, costHandle.CostType, base.Owner.BudgetType); base.AccountForCostHandle(costHandle); switch (costHandle.CostType) { case CostType.CMDLET: ThrottlingPerfCounterWrapper.DecrementExchangeExecutingCmdlets(); return; case CostType.ActiveRunspace: Interlocked.Decrement(ref this.activeRunspaces); if (this.TrackActiveRunspacePerfCounter) { ThrottlingPerfCounterWrapper.DecrementActivePowerShellRunspaces(); } return; default: return; } }
private void LockBucket() { lock (this.instanceLock) { this.locked = true; this.lockedAt = TimeProvider.UtcNow; } DateTime value = this.LockedUntilUtcNonUpdating.Value; ThrottlingPerfCounterWrapper.IncrementBudgetsLockedOut(this.BudgetKey, value - TimeProvider.UtcNow); if (Globals.ProcessInstanceType != InstanceType.NotInitialized) { Globals.LogEvent(DirectoryEventLogConstants.Tuple_UserLockedOutThrottling, string.Empty, new object[] { this.BudgetKey, value, this.GetTraceInt(this.MaximumBalance), this.GetTraceInt(this.RechargeRate), this.GetTraceInt(this.MinimumBalance) }); } ExTraceGlobals.ClientThrottlingTracer.TraceDebug <DateTime, int>((long)this.GetHashCode(), "[TokenBucket.LockBucket] Bucket locked until {0}. Current Pending charges: {1}", value, this.PendingCharges); }
// Token: 0x060071F1 RID: 29169 RVA: 0x00179CB8 File Offset: 0x00177EB8 protected override T CreateOnCacheMiss(BudgetKey key, ref bool shouldAdd) { if (key == null) { throw new ArgumentNullException("key"); } IThrottlingPolicy throttlingPolicy = null; LookupBudgetKey lookupBudgetKey = key as LookupBudgetKey; if (lookupBudgetKey != null) { throttlingPolicy = lookupBudgetKey.Lookup(); } if (throttlingPolicy == null) { ExTraceGlobals.ClientThrottlingTracer.TraceDebug <string>((long)this.GetHashCode(), "[BudgetCache.CreateOnCacheMiss] Using global policy for account: {0}", key.ToString()); throttlingPolicy = ThrottlingPolicyCache.Singleton.GetGlobalThrottlingPolicy(); } T result = this.CreateBudget(key, throttlingPolicy); ThrottlingPerfCounterWrapper.IncrementBudgetCount(); Interlocked.Increment(ref this.cacheMisses); return(result); }
public static void Initialize(BudgetType budgetType, int?massOverBudgetPercent) { ThrottlingPerfCounterWrapper.Initialize(budgetType, massOverBudgetPercent, false); }
protected ThrottlingPolicyCache() { this.globalThrottlingPolicyCache = new ThrottlingPolicyCache.GlobalThrottlingPolicyCache(ThrottlingPolicyCache.cacheExpirationInterval); this.organizationThrottlingPolicies = new AutoRefreshCache <OrganizationId, CachableThrottlingPolicyItem, object>(10000L, ThrottlingPolicyCache.cacheExpirationInterval, ThrottlingPolicyCache.cacheCleanupInterval, ThrottlingPolicyCache.cachePurgeInterval, ThrottlingPolicyCache.cacheRefreshInterval, new DefaultCacheTracer <OrganizationId>(ThrottlingPolicyCache.Tracer, "OrganizationThrottlingPolicies"), ThrottlingPerfCounterWrapper.GetOrganizationThrottlingPolicyCacheCounters(10000L), new AutoRefreshCache <OrganizationId, CachableThrottlingPolicyItem, object> .CreateEntryDelegate(ThrottlingPolicyCache.ResolveOrganizationThrottlingPolicy)); this.throttlingPolicies = new AutoRefreshCache <OrgAndObjectId, CachableThrottlingPolicyItem, object>(10000L, ThrottlingPolicyCache.cacheExpirationInterval, ThrottlingPolicyCache.cacheCleanupInterval, ThrottlingPolicyCache.cachePurgeInterval, ThrottlingPolicyCache.cacheRefreshInterval, new DefaultCacheTracer <OrgAndObjectId>(ThrottlingPolicyCache.Tracer, "ThrottlingPolicies"), ThrottlingPerfCounterWrapper.GetThrottlingPolicyCacheCounters(10000L), new AutoRefreshCache <OrgAndObjectId, CachableThrottlingPolicyItem, object> .CreateEntryDelegate(ThrottlingPolicyCache.ResolveThrottlingPolicy)); }
public static void Initialize(BudgetType budgetType) { ThrottlingPerfCounterWrapper.Initialize(budgetType, null, false); }
// Token: 0x060071F2 RID: 29170 RVA: 0x00179D37 File Offset: 0x00177F37 protected override void HandleRemove(BudgetKey key, T value, RemoveReason reason) { ThrottlingPerfCounterWrapper.DecrementBudgetCount(); base.HandleRemove(key, value, reason); value.Expire(); }
// Token: 0x0600723C RID: 29244 RVA: 0x0017A49C File Offset: 0x0017869C public static void Update(bool isOneHour) { if (!ThrottlingPerfCounterWrapper.PerfCountersInitialized) { return; } int[] array = null; int averageUsage = 0; int[] array2 = null; int averageUsage2 = 0; PercentileUsage[] array3 = null; if (BudgetUsageTracker.budgetUsage.Count > 0) { List <BudgetKey> list = null; lock (BudgetUsageTracker.staticLock) { if (BudgetUsageTracker.budgetUsage.Count > 0) { array3 = new PercentileUsage[BudgetUsageTracker.budgetUsage.Count]; int num = 0; foreach (KeyValuePair <BudgetKey, PercentileUsage> keyValuePair in BudgetUsageTracker.budgetUsage) { array3[num++] = new PercentileUsage(keyValuePair.Value); if (keyValuePair.Value.FiveMinuteUsage == 0 && keyValuePair.Value.OneHourUsage == 0 && TimeProvider.UtcNow - keyValuePair.Value.CreationTime > BudgetUsageTracker.PeriodicLoggingInterval) { if (list == null) { list = new List <BudgetKey>(); } list.Add(keyValuePair.Key); } keyValuePair.Value.Clear(isOneHour); } if (list != null) { foreach (BudgetKey key in list) { PercentileUsage percentileUsage; if (BudgetUsageTracker.budgetUsage.TryGetValue(key, out percentileUsage)) { percentileUsage.Expired = true; BudgetUsageTracker.budgetUsage.Remove(key); } } } } } } if (array3 != null) { BudgetUsageTracker.GetPercentileUsage(array3, false, out array, out averageUsage); ThrottlingPerfCounterWrapper.SetFiveMinuteBudgetUsage(array[0], array[1], array[2], averageUsage); if (isOneHour) { BudgetUsageTracker.GetPercentileUsage(array3, true, out array2, out averageUsage2); ThrottlingPerfCounterWrapper.SetOneHourBudgetUsage(array2[0], array2[1], array2[2], averageUsage2); return; } } else { if (isOneHour) { ThrottlingPerfCounterWrapper.SetOneHourBudgetUsage(0, 0, 0, 0); return; } ThrottlingPerfCounterWrapper.SetFiveMinuteBudgetUsage(0, 0, 0, 0); } }
internal override void Clear() { base.Clear(); ThrottlingPerfCounterWrapper.ClearCaches(); }