type MonitorReaderOptions struct {
	BucketOptions
	HeaderSize int
}

// Read implements a throttled read
func (r *MonitoredReader) Read(buf []byte) (n int, err error) {
	if r.throttle == nil {
		return r.r.Read(buf)
	}
	if r.lastErr != nil {
		err = r.lastErr
		return n, err
	}
	b := r.throttle.Burst()  // maximum available tokens
	need := len(buf)         // number of bytes requested by caller

	limitBytes := limit / int64(m.NodeCount)
	throttle, ok := m.bucketsThrottle[BucketOptions{Name: bucket, ReplicationARN: arn}]
	if !ok {
		throttle = &bucketThrottle{}
	}
	throttle.NodeBandwidthPerSec = limitBytes
	throttle.Limiter = rate.NewLimiter(rate.Limit(float64(limitBytes)), int(limitBytes))
	m.bucketsThrottle[BucketOptions{Name: bucket, ReplicationARN: arn}] = throttle
}

   * body, which it will attempt to do otherwise:
   *
   *  * Don't cache the response. The cache will try to read the entire response body so that it
   *    can successfully complete the cache entry.
   *
   *  * Throttle the response. The HTTP/1 connection pool will attempt to read the entire response
   *    body so that it can pool the connection.
   */
  private fun trailersWithClientPrematureClose(protocol: Protocol) {

// the name displayed in logs and trace to be accurate. The name is extracted
// via reflection.
//
// When **no** flags are passed, the behavior is to trace both headers and body,
// gzip the response and throttle the handler via `maxClients`. Each of these
// can be disabled via the corresponding `s3HFlag`.
//
// CAUTION: for requests involving large req/resp bodies ensure to pass the

    assertThat(server.takeRequest().exchangeIndex).isEqualTo(1)
  }

  /**
   * Test to ensure we don't  throw a read timeout on responses that are progressing.  For this
   * case, we take a 4KiB body and throttle it to 1KiB/second.  We set the read timeout to two
   * seconds.  If our implementation is acting correctly, it will not throw, as it is progressing.
   */
  @Test
  fun readTimeoutMoreGranularThanBodySize() {

}

func (t *apiConfig) getRequestsPool() chan struct{} {
	t.mu.RLock()
	defer t.mu.RUnlock()

	if t.requestsPool == nil {
		return nil
	}

	return t.requestsPool
}

// maxClients throttles the S3 API calls
func maxClients(f http.HandlerFunc) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		globalHTTPStats.incS3RequestsIncoming()

- Kubemark: added two flags, `--kube-api-qps` which indicates the maximum QPS to the apiserver, and `--kube-api-burst` which indicates maximum burst for throttle to the apiserver. ([#124147](https://github.com/kubernetes/kubernetes/pull/124147), [@devincd](https://github.com/devincd))

        newcomers.
    *   Clarified documentation on `resize_images.align_corners` parameter.
    *   Additional documentation for TPUs.
*   Google Cloud Storage (GCS):
    *   Add client-side throttle.
    *   Add a `FlushCaches()` method to the FileSystem interface, with an
        implementation for GcsFileSystem.
*   Other:
    *   Add `tf.contrib.distributions.Kumaraswamy`.

	scannerCycle                         = uatomic.NewDuration(dataScannerStartDelay)
	scannerIdleMode                      = uatomic.NewInt32(0) // default is throttled when idle
	scannerExcessObjectVersions          = uatomic.NewInt64(100)
	scannerExcessObjectVersionsTotalSize = uatomic.NewInt64(1024 * 1024 * 1024 * 1024) // 1 TB
	scannerExcessFolders                 = uatomic.NewInt64(50000)