fix: rename request count to permit count (#76623)

github-actions[bot] · Ali Khalili · web-flow · commit d8b3db47206e · 2022-10-05T11:00:31.000-07:00
Co-authored-by: Ali Khalili &lt;ali.khalili@oneadvanced.com&gt;
diff --git a/src/libraries/System.Threading.RateLimiting/ref/System.Threading.RateLimiting.cs b/src/libraries/System.Threading.RateLimiting/ref/System.Threading.RateLimiting.cs
@@ -29,8 +29,8 @@ public FixedWindowRateLimiter(System.Threading.RateLimiting.FixedWindowRateLimit
         public override System.TimeSpan? IdleDuration { get { throw null; } }
         public override bool IsAutoReplenishing { get { throw null; } }
         public override System.TimeSpan ReplenishmentPeriod { get { throw null; } }
-        protected override System.Threading.Tasks.ValueTask<System.Threading.RateLimiting.RateLimitLease> AcquireAsyncCore(int requestCount, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
-        protected override System.Threading.RateLimiting.RateLimitLease AttemptAcquireCore(int requestCount) { throw null; }
+        protected override System.Threading.Tasks.ValueTask<System.Threading.RateLimiting.RateLimitLease> AcquireAsyncCore(int permitCount, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        protected override System.Threading.RateLimiting.RateLimitLease AttemptAcquireCore(int permitCount) { throw null; }
         protected override void Dispose(bool disposing) { }
         protected override System.Threading.Tasks.ValueTask DisposeAsyncCore() { throw null; }
         public override System.Threading.RateLimiting.RateLimiterStatistics? GetStatistics() { throw null; }
@@ -150,8 +150,8 @@ public SlidingWindowRateLimiter(System.Threading.RateLimiting.SlidingWindowRateL
         public override System.TimeSpan? IdleDuration { get { throw null; } }
         public override bool IsAutoReplenishing { get { throw null; } }
         public override System.TimeSpan ReplenishmentPeriod { get { throw null; } }
-        protected override System.Threading.Tasks.ValueTask<System.Threading.RateLimiting.RateLimitLease> AcquireAsyncCore(int requestCount, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
-        protected override System.Threading.RateLimiting.RateLimitLease AttemptAcquireCore(int requestCount) { throw null; }
+        protected override System.Threading.Tasks.ValueTask<System.Threading.RateLimiting.RateLimitLease> AcquireAsyncCore(int permitCount, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        protected override System.Threading.RateLimiting.RateLimitLease AttemptAcquireCore(int permitCount) { throw null; }
         protected override void Dispose(bool disposing) { }
         protected override System.Threading.Tasks.ValueTask DisposeAsyncCore() { throw null; }
         public override System.Threading.RateLimiting.RateLimiterStatistics? GetStatistics() { throw null; }
diff --git a/src/libraries/System.Threading.RateLimiting/src/System/Threading/RateLimiting/FixedWindowRateLimiter.cs b/src/libraries/System.Threading.RateLimiting/src/System/Threading/RateLimiting/FixedWindowRateLimiter.cs
@@ -13,7 +13,7 @@ namespace System.Threading.RateLimiting
     /// </summary>
     public sealed class FixedWindowRateLimiter : ReplenishingRateLimiter
     {
-        private int _requestCount;
+        private int _permitCount;
         private int _queueCount;
         private long _lastReplenishmentTick;
         private long? _idleSince;
@@ -73,7 +73,7 @@ public FixedWindowRateLimiter(FixedWindowRateLimiterOptions options)
                 AutoReplenishment = options.AutoReplenishment
             };
 
-            _requestCount = options.PermitLimit;
+            _permitCount = options.PermitLimit;
 
             _idleSince = _lastReplenishmentTick = Stopwatch.GetTimestamp();
 
@@ -89,80 +89,80 @@ public FixedWindowRateLimiter(FixedWindowRateLimiterOptions options)
             ThrowIfDisposed();
             return new RateLimiterStatistics()
             {
-                CurrentAvailablePermits = _requestCount,
+                CurrentAvailablePermits = _permitCount,
                 CurrentQueuedCount = _queueCount,
                 TotalFailedLeases = Interlocked.Read(ref _failedLeasesCount),
                 TotalSuccessfulLeases = Interlocked.Read(ref _successfulLeasesCount),
             };
         }
 
         /// <inheritdoc/>
-        protected override RateLimitLease AttemptAcquireCore(int requestCount)
+        protected override RateLimitLease AttemptAcquireCore(int permitCount)
         {
             // These amounts of resources can never be acquired
             // Raises a PermitLimitExceeded ArgumentOutOFRangeException
-            if (requestCount > _options.PermitLimit)
+            if (permitCount > _options.PermitLimit)
             {
-                throw new ArgumentOutOfRangeException(nameof(requestCount), requestCount, SR.Format(SR.PermitLimitExceeded, requestCount, _options.PermitLimit));
+                throw new ArgumentOutOfRangeException(nameof(permitCount), permitCount, SR.Format(SR.PermitLimitExceeded, permitCount, _options.PermitLimit));
             }
 
             // Return SuccessfulLease or FailedLease depending to indicate limiter state
-            if (requestCount == 0 && !_disposed)
+            if (permitCount == 0 && !_disposed)
             {
                 // Check if the requests are permitted in a window
                 // Requests will be allowed if the total served request is less than the max allowed requests (permit limit).
-                if (_requestCount > 0)
+                if (_permitCount > 0)
                 {
                     Interlocked.Increment(ref _successfulLeasesCount);
                     return SuccessfulLease;
                 }
 
                 Interlocked.Increment(ref _failedLeasesCount);
-                return CreateFailedWindowLease(requestCount);
+                return CreateFailedWindowLease(permitCount);
             }
 
             lock (Lock)
             {
-                if (TryLeaseUnsynchronized(requestCount, out RateLimitLease? lease))
+                if (TryLeaseUnsynchronized(permitCount, out RateLimitLease? lease))
                 {
                     return lease;
                 }
 
                 Interlocked.Increment(ref _failedLeasesCount);
-                return CreateFailedWindowLease(requestCount);
+                return CreateFailedWindowLease(permitCount);
             }
         }
 
         /// <inheritdoc/>
-        protected override ValueTask<RateLimitLease> AcquireAsyncCore(int requestCount, CancellationToken cancellationToken = default)
+        protected override ValueTask<RateLimitLease> AcquireAsyncCore(int permitCount, CancellationToken cancellationToken = default)
         {
             // These amounts of resources can never be acquired
-            if (requestCount > _options.PermitLimit)
+            if (permitCount > _options.PermitLimit)
             {
-                throw new ArgumentOutOfRangeException(nameof(requestCount), requestCount, SR.Format(SR.PermitLimitExceeded, requestCount, _options.PermitLimit));
+                throw new ArgumentOutOfRangeException(nameof(permitCount), permitCount, SR.Format(SR.PermitLimitExceeded, permitCount, _options.PermitLimit));
             }
 
             ThrowIfDisposed();
 
-            // Return SuccessfulAcquisition if requestCount is 0 and resources are available
-            if (requestCount == 0 && _requestCount > 0)
+            // Return SuccessfulAcquisition if permitCount is 0 and resources are available
+            if (permitCount == 0 && _permitCount > 0)
             {
                 Interlocked.Increment(ref _successfulLeasesCount);
                 return new ValueTask<RateLimitLease>(SuccessfulLease);
             }
 
             lock (Lock)
             {
-                if (TryLeaseUnsynchronized(requestCount, out RateLimitLease? lease))
+                if (TryLeaseUnsynchronized(permitCount, out RateLimitLease? lease))
                 {
                     return new ValueTask<RateLimitLease>(lease);
                 }
 
                 // Avoid integer overflow by using subtraction instead of addition
                 Debug.Assert(_options.QueueLimit >= _queueCount);
-                if (_options.QueueLimit - _queueCount < requestCount)
+                if (_options.QueueLimit - _queueCount < permitCount)
                 {
-                    if (_options.QueueProcessingOrder == QueueProcessingOrder.NewestFirst && requestCount <= _options.QueueLimit)
+                    if (_options.QueueProcessingOrder == QueueProcessingOrder.NewestFirst && permitCount <= _options.QueueLimit)
                     {
                         // remove oldest items from queue until there is space for the newest acquisition request
                         do
@@ -179,17 +179,17 @@ protected override ValueTask<RateLimitLease> AcquireAsyncCore(int requestCount,
                                 Interlocked.Increment(ref _failedLeasesCount);
                             }
                         }
-                        while (_options.QueueLimit - _queueCount < requestCount);
+                        while (_options.QueueLimit - _queueCount < permitCount);
                     }
                     else
                     {
                         Interlocked.Increment(ref _failedLeasesCount);
                         // Don't queue if queue limit reached and QueueProcessingOrder is OldestFirst
-                        return new ValueTask<RateLimitLease>(CreateFailedWindowLease(requestCount));
+                        return new ValueTask<RateLimitLease>(CreateFailedWindowLease(permitCount));
                     }
                 }
 
-                CancelQueueState tcs = new CancelQueueState(requestCount, this, cancellationToken);
+                CancelQueueState tcs = new CancelQueueState(permitCount, this, cancellationToken);
                 CancellationTokenRegistration ctr = default;
                 if (cancellationToken.CanBeCanceled)
                 {
@@ -199,32 +199,32 @@ protected override ValueTask<RateLimitLease> AcquireAsyncCore(int requestCount,
                     }, tcs);
                 }
 
-                RequestRegistration registration = new RequestRegistration(requestCount, tcs, ctr);
+                RequestRegistration registration = new RequestRegistration(permitCount, tcs, ctr);
                 _queue.EnqueueTail(registration);
-                _queueCount += requestCount;
+                _queueCount += permitCount;
                 Debug.Assert(_queueCount <= _options.QueueLimit);
 
                 return new ValueTask<RateLimitLease>(registration.Tcs.Task);
             }
         }
 
-        private RateLimitLease CreateFailedWindowLease(int requestCount)
+        private RateLimitLease CreateFailedWindowLease(int permitCount)
         {
-            int replenishAmount = requestCount - _requestCount + _queueCount;
+            int replenishAmount = permitCount - _permitCount + _queueCount;
             // can't have 0 replenish window, that would mean it should be a successful lease
             int replenishWindow = Math.Max(replenishAmount / _options.PermitLimit, 1);
 
             return new FixedWindowLease(false, TimeSpan.FromTicks(_options.Window.Ticks * replenishWindow));
         }
 
-        private bool TryLeaseUnsynchronized(int requestCount, [NotNullWhen(true)] out RateLimitLease? lease)
+        private bool TryLeaseUnsynchronized(int permitCount, [NotNullWhen(true)] out RateLimitLease? lease)
         {
             ThrowIfDisposed();
 
             // if permitCount is 0 we want to queue it if there are no available permits
-            if (_requestCount >= requestCount && _requestCount != 0)
+            if (_permitCount >= permitCount && _permitCount != 0)
             {
-                if (requestCount == 0)
+                if (permitCount == 0)
                 {
                     Interlocked.Increment(ref _successfulLeasesCount);
                     // Edge case where the check before the lock showed 0 available permit counters but when we got the lock, some permits were now available
@@ -237,8 +237,8 @@ private bool TryLeaseUnsynchronized(int requestCount, [NotNullWhen(true)] out Ra
                 if (_queueCount == 0 || (_queueCount > 0 && _options.QueueProcessingOrder == QueueProcessingOrder.NewestFirst))
                 {
                     _idleSince = null;
-                    _requestCount -= requestCount;
-                    Debug.Assert(_requestCount >= 0);
+                    _permitCount -= permitCount;
+                    Debug.Assert(_permitCount >= 0);
                     Interlocked.Increment(ref _successfulLeasesCount);
                     lease = SuccessfulLease;
                     return true;
@@ -294,15 +294,15 @@ private void ReplenishInternal(long nowTicks)
 
                 _lastReplenishmentTick = nowTicks;
 
-                int availableRequestCounters = _requestCount;
+                int availablePermitCounters = _permitCount;
 
-                if (availableRequestCounters >= _options.PermitLimit)
+                if (availablePermitCounters >= _options.PermitLimit)
                 {
                     // All counters available, nothing to do
                     return;
                 }
 
-                _requestCount = _options.PermitLimit;
+                _permitCount = _options.PermitLimit;
 
                 // Process queued requests
                 while (_queue.Count > 0)
@@ -312,7 +312,7 @@ private void ReplenishInternal(long nowTicks)
                           ? _queue.PeekHead()
                           : _queue.PeekTail();
 
-                    if (_requestCount >= nextPendingRequest.Count)
+                    if (_permitCount >= nextPendingRequest.Count)
                     {
                         // Request can be fulfilled
                         nextPendingRequest =
@@ -321,13 +321,13 @@ private void ReplenishInternal(long nowTicks)
                             : _queue.DequeueTail();
 
                         _queueCount -= nextPendingRequest.Count;
-                        _requestCount -= nextPendingRequest.Count;
-                        Debug.Assert(_requestCount >= 0);
+                        _permitCount -= nextPendingRequest.Count;
+                        Debug.Assert(_permitCount >= 0);
 
                         if (!nextPendingRequest.Tcs.TrySetResult(SuccessfulLease))
                         {
                             // Queued item was canceled so add count back
-                            _requestCount += nextPendingRequest.Count;
+                            _permitCount += nextPendingRequest.Count;
                             // Updating queue count is handled by the cancellation code
                             _queueCount += nextPendingRequest.Count;
                         }
@@ -345,7 +345,7 @@ private void ReplenishInternal(long nowTicks)
                     }
                 }
 
-                if (_requestCount == _options.PermitLimit)
+                if (_permitCount == _options.PermitLimit)
                 {
                     Debug.Assert(_idleSince is null);
                     Debug.Assert(_queueCount == 0);
@@ -426,9 +426,9 @@ public override bool TryGetMetadata(string metadataName, out object? metadata)
 
         private readonly struct RequestRegistration
         {
-            public RequestRegistration(int requestCount, TaskCompletionSource<RateLimitLease> tcs, CancellationTokenRegistration cancellationTokenRegistration)
+            public RequestRegistration(int permitCount, TaskCompletionSource<RateLimitLease> tcs, CancellationTokenRegistration cancellationTokenRegistration)
             {
-                Count = requestCount;
+                Count = permitCount;
                 // Use VoidAsyncOperationWithData<T> instead
                 Tcs = tcs;
                 CancellationTokenRegistration = cancellationTokenRegistration;
@@ -443,14 +443,14 @@ public RequestRegistration(int requestCount, TaskCompletionSource<RateLimitLease
 
         private sealed class CancelQueueState : TaskCompletionSource<RateLimitLease>
         {
-            private readonly int _requestCount;
+            private readonly int _permitCount;
             private readonly FixedWindowRateLimiter _limiter;
             private readonly CancellationToken _cancellationToken;
 
-            public CancelQueueState(int requestCount, FixedWindowRateLimiter limiter, CancellationToken cancellationToken)
+            public CancelQueueState(int permitCount, FixedWindowRateLimiter limiter, CancellationToken cancellationToken)
                 : base(TaskCreationOptions.RunContinuationsAsynchronously)
             {
-                _requestCount = requestCount;
+                _permitCount = permitCount;
                 _limiter = limiter;
                 _cancellationToken = cancellationToken;
             }
@@ -461,7 +461,7 @@ public CancelQueueState(int requestCount, FixedWindowRateLimiter limiter, Cancel
                 {
                     lock (_limiter.Lock)
                     {
-                        _limiter._queueCount -= _requestCount;
+                        _limiter._queueCount -= _permitCount;
                     }
                     return true;
                 }
diff --git a/src/libraries/System.Threading.RateLimiting/src/System/Threading/RateLimiting/SlidingWindowRateLimiter.cs b/src/libraries/System.Threading.RateLimiting/src/System/Threading/RateLimiting/SlidingWindowRateLimiter.cs

Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ namespace System.Threading.RateLimiting`
`13`	`13`	`/// </summary>`
`14`	`14`	`public sealed class FixedWindowRateLimiter : ReplenishingRateLimiter`
`15`	`15`	`{`
`16`		`- private int _requestCount;`
	`16`	`+ private int _permitCount;`
`17`	`17`	`private int _queueCount;`
`18`	`18`	`private long _lastReplenishmentTick;`
`19`	`19`	`private long? _idleSince;`
`@@ -73,7 +73,7 @@ public FixedWindowRateLimiter(FixedWindowRateLimiterOptions options)`
`73`	`73`	`AutoReplenishment = options.AutoReplenishment`
`74`	`74`	`};`
`75`	`75`
`76`		`- _requestCount = options.PermitLimit;`
	`76`	`+ _permitCount = options.PermitLimit;`
`77`	`77`
`78`	`78`	`_idleSince = _lastReplenishmentTick = Stopwatch.GetTimestamp();`
`79`	`79`
`@@ -89,80 +89,80 @@ public FixedWindowRateLimiter(FixedWindowRateLimiterOptions options)`
`89`	`89`	`ThrowIfDisposed();`
`90`	`90`	`return new RateLimiterStatistics()`
`91`	`91`	`{`
`92`		`- CurrentAvailablePermits = _requestCount,`
	`92`	`+ CurrentAvailablePermits = _permitCount,`
`93`	`93`	`CurrentQueuedCount = _queueCount,`
`94`	`94`	`TotalFailedLeases = Interlocked.Read(ref _failedLeasesCount),`
`95`	`95`	`TotalSuccessfulLeases = Interlocked.Read(ref _successfulLeasesCount),`
`96`	`96`	`};`
`97`	`97`	`}`
`98`	`98`
`99`	`99`	`/// <inheritdoc/>`
`100`		`- protected override RateLimitLease AttemptAcquireCore(int requestCount)`
	`100`	`+ protected override RateLimitLease AttemptAcquireCore(int permitCount)`
`101`	`101`	`{`
`102`	`102`	`// These amounts of resources can never be acquired`
`103`	`103`	`// Raises a PermitLimitExceeded ArgumentOutOFRangeException`
`104`		`- if (requestCount > _options.PermitLimit)`
	`104`	`+ if (permitCount > _options.PermitLimit)`
`105`	`105`	`{`
`106`		`- throw new ArgumentOutOfRangeException(nameof(requestCount), requestCount, SR.Format(SR.PermitLimitExceeded, requestCount, _options.PermitLimit));`
	`106`	`+ throw new ArgumentOutOfRangeException(nameof(permitCount), permitCount, SR.Format(SR.PermitLimitExceeded, permitCount, _options.PermitLimit));`
`107`	`107`	`}`
`108`	`108`
`109`	`109`	`// Return SuccessfulLease or FailedLease depending to indicate limiter state`
`110`		`- if (requestCount == 0 && !_disposed)`
	`110`	`+ if (permitCount == 0 && !_disposed)`
`111`	`111`	`{`
`112`	`112`	`// Check if the requests are permitted in a window`
`113`	`113`	`// Requests will be allowed if the total served request is less than the max allowed requests (permit limit).`
`114`		`- if (_requestCount > 0)`
	`114`	`+ if (_permitCount > 0)`
`115`	`115`	`{`
`116`	`116`	`Interlocked.Increment(ref _successfulLeasesCount);`
`117`	`117`	`return SuccessfulLease;`
`118`	`118`	`}`
`119`	`119`
`120`	`120`	`Interlocked.Increment(ref _failedLeasesCount);`
`121`		`- return CreateFailedWindowLease(requestCount);`
	`121`	`+ return CreateFailedWindowLease(permitCount);`
`122`	`122`	`}`
`123`	`123`
`124`	`124`	`lock (Lock)`
`125`	`125`	`{`
`126`		`- if (TryLeaseUnsynchronized(requestCount, out RateLimitLease? lease))`
	`126`	`+ if (TryLeaseUnsynchronized(permitCount, out RateLimitLease? lease))`
`127`	`127`	`{`
`128`	`128`	`return lease;`
`129`	`129`	`}`
`130`	`130`
`131`	`131`	`Interlocked.Increment(ref _failedLeasesCount);`
`132`		`- return CreateFailedWindowLease(requestCount);`
	`132`	`+ return CreateFailedWindowLease(permitCount);`
`133`	`133`	`}`
`134`	`134`	`}`
`135`	`135`
`136`	`136`	`/// <inheritdoc/>`
`137`		`- protected override ValueTask<RateLimitLease> AcquireAsyncCore(int requestCount, CancellationToken cancellationToken = default)`
	`137`	`+ protected override ValueTask<RateLimitLease> AcquireAsyncCore(int permitCount, CancellationToken cancellationToken = default)`
`138`	`138`	`{`
`139`	`139`	`// These amounts of resources can never be acquired`
`140`		`- if (requestCount > _options.PermitLimit)`
	`140`	`+ if (permitCount > _options.PermitLimit)`
`141`	`141`	`{`
`142`		`- throw new ArgumentOutOfRangeException(nameof(requestCount), requestCount, SR.Format(SR.PermitLimitExceeded, requestCount, _options.PermitLimit));`
	`142`	`+ throw new ArgumentOutOfRangeException(nameof(permitCount), permitCount, SR.Format(SR.PermitLimitExceeded, permitCount, _options.PermitLimit));`
`143`	`143`	`}`
`144`	`144`
`145`	`145`	`ThrowIfDisposed();`
`146`	`146`
`147`		`- // Return SuccessfulAcquisition if requestCount is 0 and resources are available`
`148`		`- if (requestCount == 0 && _requestCount > 0)`
	`147`	`+ // Return SuccessfulAcquisition if permitCount is 0 and resources are available`
	`148`	`+ if (permitCount == 0 && _permitCount > 0)`
`149`	`149`	`{`
`150`	`150`	`Interlocked.Increment(ref _successfulLeasesCount);`
`151`	`151`	`return new ValueTask<RateLimitLease>(SuccessfulLease);`
`152`	`152`	`}`
`153`	`153`
`154`	`154`	`lock (Lock)`
`155`	`155`	`{`
`156`		`- if (TryLeaseUnsynchronized(requestCount, out RateLimitLease? lease))`
	`156`	`+ if (TryLeaseUnsynchronized(permitCount, out RateLimitLease? lease))`
`157`	`157`	`{`
`158`	`158`	`return new ValueTask<RateLimitLease>(lease);`
`159`	`159`	`}`
`160`	`160`
`161`	`161`	`// Avoid integer overflow by using subtraction instead of addition`
`162`	`162`	`Debug.Assert(_options.QueueLimit >= _queueCount);`
`163`		`- if (_options.QueueLimit - _queueCount < requestCount)`
	`163`	`+ if (_options.QueueLimit - _queueCount < permitCount)`
`164`	`164`	`{`
`165`		`- if (_options.QueueProcessingOrder == QueueProcessingOrder.NewestFirst && requestCount <= _options.QueueLimit)`
	`165`	`+ if (_options.QueueProcessingOrder == QueueProcessingOrder.NewestFirst && permitCount <= _options.QueueLimit)`
`166`	`166`	`{`
`167`	`167`	`// remove oldest items from queue until there is space for the newest acquisition request`
`168`	`168`	`do`
`@@ -179,17 +179,17 @@ protected override ValueTask<RateLimitLease> AcquireAsyncCore(int requestCount,`
`179`	`179`	`Interlocked.Increment(ref _failedLeasesCount);`
`180`	`180`	`}`
`181`	`181`	`}`
`182`		`- while (_options.QueueLimit - _queueCount < requestCount);`
	`182`	`+ while (_options.QueueLimit - _queueCount < permitCount);`
`183`	`183`	`}`
`184`	`184`	`else`
`185`	`185`	`{`
`186`	`186`	`Interlocked.Increment(ref _failedLeasesCount);`
`187`	`187`	`// Don't queue if queue limit reached and QueueProcessingOrder is OldestFirst`
`188`		`- return new ValueTask<RateLimitLease>(CreateFailedWindowLease(requestCount));`
	`188`	`+ return new ValueTask<RateLimitLease>(CreateFailedWindowLease(permitCount));`
`189`	`189`	`}`
`190`	`190`	`}`
`191`	`191`
`192`		`- CancelQueueState tcs = new CancelQueueState(requestCount, this, cancellationToken);`
	`192`	`+ CancelQueueState tcs = new CancelQueueState(permitCount, this, cancellationToken);`
`193`	`193`	`CancellationTokenRegistration ctr = default;`
`194`	`194`	`if (cancellationToken.CanBeCanceled)`
`195`	`195`	`{`
`@@ -199,32 +199,32 @@ protected override ValueTask<RateLimitLease> AcquireAsyncCore(int requestCount,`
`199`	`199`	`}, tcs);`
`200`	`200`	`}`
`201`	`201`
`202`		`- RequestRegistration registration = new RequestRegistration(requestCount, tcs, ctr);`
	`202`	`+ RequestRegistration registration = new RequestRegistration(permitCount, tcs, ctr);`
`203`	`203`	`_queue.EnqueueTail(registration);`
`204`		`- _queueCount += requestCount;`
	`204`	`+ _queueCount += permitCount;`
`205`	`205`	`Debug.Assert(_queueCount <= _options.QueueLimit);`
`206`	`206`
`207`	`207`	`return new ValueTask<RateLimitLease>(registration.Tcs.Task);`
`208`	`208`	`}`
`209`	`209`	`}`
`210`	`210`
`211`		`- private RateLimitLease CreateFailedWindowLease(int requestCount)`
	`211`	`+ private RateLimitLease CreateFailedWindowLease(int permitCount)`
`212`	`212`	`{`
`213`		`- int replenishAmount = requestCount - _requestCount + _queueCount;`
	`213`	`+ int replenishAmount = permitCount - _permitCount + _queueCount;`
`214`	`214`	`// can't have 0 replenish window, that would mean it should be a successful lease`
`215`	`215`	`int replenishWindow = Math.Max(replenishAmount / _options.PermitLimit, 1);`
`216`	`216`
`217`	`217`	`return new FixedWindowLease(false, TimeSpan.FromTicks(_options.Window.Ticks * replenishWindow));`
`218`	`218`	`}`
`219`	`219`
`220`		`- private bool TryLeaseUnsynchronized(int requestCount, [NotNullWhen(true)] out RateLimitLease? lease)`
	`220`	`+ private bool TryLeaseUnsynchronized(int permitCount, [NotNullWhen(true)] out RateLimitLease? lease)`
`221`	`221`	`{`
`222`	`222`	`ThrowIfDisposed();`
`223`	`223`
`224`	`224`	`// if permitCount is 0 we want to queue it if there are no available permits`
`225`		`- if (_requestCount >= requestCount && _requestCount != 0)`
	`225`	`+ if (_permitCount >= permitCount && _permitCount != 0)`
`226`	`226`	`{`
`227`		`- if (requestCount == 0)`
	`227`	`+ if (permitCount == 0)`
`228`	`228`	`{`
`229`	`229`	`Interlocked.Increment(ref _successfulLeasesCount);`
`230`	`230`	`// Edge case where the check before the lock showed 0 available permit counters but when we got the lock, some permits were now available`
`@@ -237,8 +237,8 @@ private bool TryLeaseUnsynchronized(int requestCount, [NotNullWhen(true)] out Ra`
`237`	`237`	`if (_queueCount == 0 \|\| (_queueCount > 0 && _options.QueueProcessingOrder == QueueProcessingOrder.NewestFirst))`
`238`	`238`	`{`
`239`	`239`	`_idleSince = null;`
`240`		`- _requestCount -= requestCount;`
`241`		`- Debug.Assert(_requestCount >= 0);`
	`240`	`+ _permitCount -= permitCount;`
	`241`	`+ Debug.Assert(_permitCount >= 0);`
`242`	`242`	`Interlocked.Increment(ref _successfulLeasesCount);`
`243`	`243`	`lease = SuccessfulLease;`
`244`	`244`	`return true;`
`@@ -294,15 +294,15 @@ private void ReplenishInternal(long nowTicks)`
`294`	`294`
`295`	`295`	`_lastReplenishmentTick = nowTicks;`
`296`	`296`
`297`		`- int availableRequestCounters = _requestCount;`
	`297`	`+ int availablePermitCounters = _permitCount;`
`298`	`298`
`299`		`- if (availableRequestCounters >= _options.PermitLimit)`
	`299`	`+ if (availablePermitCounters >= _options.PermitLimit)`
`300`	`300`	`{`
`301`	`301`	`// All counters available, nothing to do`
`302`	`302`	`return;`
`303`	`303`	`}`
`304`	`304`
`305`		`- _requestCount = _options.PermitLimit;`
	`305`	`+ _permitCount = _options.PermitLimit;`
`306`	`306`
`307`	`307`	`// Process queued requests`
`308`	`308`	`while (_queue.Count > 0)`
`@@ -312,7 +312,7 @@ private void ReplenishInternal(long nowTicks)`
`312`	`312`	`? _queue.PeekHead()`
`313`	`313`	`: _queue.PeekTail();`
`314`	`314`
`315`		`- if (_requestCount >= nextPendingRequest.Count)`
	`315`	`+ if (_permitCount >= nextPendingRequest.Count)`
`316`	`316`	`{`
`317`	`317`	`// Request can be fulfilled`
`318`	`318`	`nextPendingRequest =`
`@@ -321,13 +321,13 @@ private void ReplenishInternal(long nowTicks)`
`321`	`321`	`: _queue.DequeueTail();`
`322`	`322`
`323`	`323`	`_queueCount -= nextPendingRequest.Count;`
`324`		`- _requestCount -= nextPendingRequest.Count;`
`325`		`- Debug.Assert(_requestCount >= 0);`
	`324`	`+ _permitCount -= nextPendingRequest.Count;`
	`325`	`+ Debug.Assert(_permitCount >= 0);`
`326`	`326`
`327`	`327`	`if (!nextPendingRequest.Tcs.TrySetResult(SuccessfulLease))`
`328`	`328`	`{`
`329`	`329`	`// Queued item was canceled so add count back`
`330`		`- _requestCount += nextPendingRequest.Count;`
	`330`	`+ _permitCount += nextPendingRequest.Count;`
`331`	`331`	`// Updating queue count is handled by the cancellation code`
`332`	`332`	`_queueCount += nextPendingRequest.Count;`
`333`	`333`	`}`
`@@ -345,7 +345,7 @@ private void ReplenishInternal(long nowTicks)`
`345`	`345`	`}`
`346`	`346`	`}`
`347`	`347`
`348`		`- if (_requestCount == _options.PermitLimit)`
	`348`	`+ if (_permitCount == _options.PermitLimit)`
`349`	`349`	`{`
`350`	`350`	`Debug.Assert(_idleSince is null);`
`351`	`351`	`Debug.Assert(_queueCount == 0);`
`@@ -426,9 +426,9 @@ public override bool TryGetMetadata(string metadataName, out object? metadata)`
`426`	`426`
`427`	`427`	`private readonly struct RequestRegistration`
`428`	`428`	`{`
`429`		`- public RequestRegistration(int requestCount, TaskCompletionSource<RateLimitLease> tcs, CancellationTokenRegistration cancellationTokenRegistration)`
	`429`	`+ public RequestRegistration(int permitCount, TaskCompletionSource<RateLimitLease> tcs, CancellationTokenRegistration cancellationTokenRegistration)`
`430`	`430`	`{`
`431`		`- Count = requestCount;`
	`431`	`+ Count = permitCount;`
`432`	`432`	`// Use VoidAsyncOperationWithData<T> instead`
`433`	`433`	`Tcs = tcs;`
`434`	`434`	`CancellationTokenRegistration = cancellationTokenRegistration;`
`@@ -443,14 +443,14 @@ public RequestRegistration(int requestCount, TaskCompletionSource<RateLimitLease`
`443`	`443`
`444`	`444`	`private sealed class CancelQueueState : TaskCompletionSource<RateLimitLease>`
`445`	`445`	`{`
`446`		`- private readonly int _requestCount;`
	`446`	`+ private readonly int _permitCount;`
`447`	`447`	`private readonly FixedWindowRateLimiter _limiter;`
`448`	`448`	`private readonly CancellationToken _cancellationToken;`
`449`	`449`
`450`		`- public CancelQueueState(int requestCount, FixedWindowRateLimiter limiter, CancellationToken cancellationToken)`
	`450`	`+ public CancelQueueState(int permitCount, FixedWindowRateLimiter limiter, CancellationToken cancellationToken)`
`451`	`451`	`: base(TaskCreationOptions.RunContinuationsAsynchronously)`
`452`	`452`	`{`
`453`		`- _requestCount = requestCount;`
	`453`	`+ _permitCount = permitCount;`
`454`	`454`	`_limiter = limiter;`
`455`	`455`	`_cancellationToken = cancellationToken;`
`456`	`456`	`}`
`@@ -461,7 +461,7 @@ public CancelQueueState(int requestCount, FixedWindowRateLimiter limiter, Cancel`
`461`	`461`	`{`
`462`	`462`	`lock (_limiter.Lock)`
`463`	`463`	`{`
`464`		`- _limiter._queueCount -= _requestCount;`
	`464`	`+ _limiter._queueCount -= _permitCount;`
`465`	`465`	`}`
`466`	`466`	`return true;`
`467`	`467`	`}`