/**
   * A map of contents pre-created before experiment starts to only measure map creation cost. The
   * implementation for the creation of contents is independent and could be different from that of
   * the map under test.
   */
  Map<Element, Element> contents;

  /** Map pre-created before experiment starts to only measure iteration cost during experiment. */
  Map<Element, Element> map;

				totalDownloadTTFB = append(totalDownloadTTFB, throughputHighestResults[i].DownloadTTFB...)
			}

			result.PUTStats.Response = totalUploadTimes.Measure()
			result.GETStats.Response = totalDownloadTimes.Measure()
			result.GETStats.TTFB = totalDownloadTTFB.Measure()

			result.Size = opts.objectSize
			result.Disks = globalEndpoints.NEndpoints()
			result.Servers = len(globalNotificationSys.peerClients) + 1

  attributes:
    label: Summary
    description: >
      What change are you proposing to the upload configuration, and why?
      For new upload configuration, which new counters will be collected, what
      do they measure, and why is it important to collect them?
      Note that uploaded data must not carry sensitive user information.
      See [go.dev/doc/telemetry#proposals](https://go.dev/doc/telemetry#proposals)

  // +optional
  optional string holderIdentity = 1;

  // leaseDurationSeconds is a duration that candidates for a lease need
  // to wait to force acquire it. This is measure against time of last
  // observed renewTime.
  // +optional
  optional int32 leaseDurationSeconds = 2;

  // acquireTime is a time when the current lease was acquired.
  // +optional

import com.google.caliper.Benchmark;
import com.google.caliper.Param;
import com.google.common.collect.BenchmarkHelpers.SetImpl;

/**
 * This is meant to be used with {@code --measureMemory} to measure the memory usage of various
 * {@code Set} implementations.
 *
 * @author Christopher Swenson
 */
public class SetCreationBenchmark {
  @Param({

  private void weaklyReferenceQueue() {
    frq = new FinalizableReferenceQueue();
    queueReference = new WeakReference<>(frq.queue);

    /*
     * Queue and clear a reference for good measure. We test later on that
     * the finalizer thread stopped, but we should test that it actually
     * started first.
     */
    reference =
        new FinalizableWeakReference<Object>(new Object(), frq) {

			return
		}
	}
}

func (sr *SRStats) updateMovingAvg() {
	sr.lock.Lock()
	defer sr.lock.Unlock()
	for _, s := range sr.M {
		s.XferRateLrg.measure.updateExponentialMovingAverage(time.Now())
		s.XferRateSml.measure.updateExponentialMovingAverage(time.Now())
	}
}

// SRMetric captures replication metrics for a deployment
type SRMetric struct {

      label: "Orthogonality: How does this change interact or overlap with existing features?"
      description: "Is the goal of this change a performance improvement? If so, what quantifiable improvement should we expect? How would we measure it?"
    validations:
      required: false

  - type: textarea
    id: learning-curve
    attributes:
      label: "Would this change make Go easier or harder to learn, and why?"

  - type: textarea

  }

  @Footprint
  Object sizeOfStriped() {
    return impl.get(numStripes);
  }

  // a place to put the locks in sizeOfPopulatedStriped so they don't get GC'd before we measure
  final List<Lock> locks = new ArrayList<>(numStripes);

  @Footprint
  Object sizeOfPopulatedStriped() {
    locks.clear();
    Striped<Lock> striped = impl.get(numStripes);
    for (int i : stripes) {

  }

  @Footprint
  Object sizeOfStriped() {
    return impl.get(numStripes);
  }

  // a place to put the locks in sizeOfPopulatedStriped so they don't get GC'd before we measure
  final List<Lock> locks = new ArrayList<>(numStripes);

  @Footprint
  Object sizeOfPopulatedStriped() {
    locks.clear();
    Striped<Lock> striped = impl.get(numStripes);
    for (int i : stripes) {