if hm.CPU.CPUCount > 0 {
						perc := math.Round(ls.Load1*100*100/float64(hm.CPU.CPUCount)) / 100
						updateResourceMetrics(cpuSubsystem, cpuLoad1Perc, perc, labels, false)
						perc = math.Round(ls.Load5*100*100/float64(hm.CPU.CPUCount)) / 100
						updateResourceMetrics(cpuSubsystem, cpuLoad5Perc, perc, labels, false)
						perc = math.Round(ls.Load15*100*100/float64(hm.CPU.CPUCount)) / 100

	cpuMetrics, _ := c.cpuMetrics.Get()

	if cpuMetrics.LoadStat != nil {
		m.Set(sysCPULoad, cpuMetrics.LoadStat.Load1)
		perc := cpuMetrics.LoadStat.Load1 * 100 / float64(cpuMetrics.CPUCount)
		m.Set(sysCPULoadPerc, math.Round(perc*100)/100)
	}

	ts := cpuMetrics.TimesStat
	tot := ts.User + ts.System + ts.Idle + ts.Iowait + ts.Nice + ts.Steal
	cpuUserVal := math.Round(ts.User/tot*100*100) / 100

package cmd

import (
	"context"
)

const (
	memTotal     = "total"
	memUsed      = "used"
	memFree      = "free"
	memBuffers   = "buffers"
	memCache     = "cache"
	memUsedPerc  = "used_perc"
	memShared    = "shared"
	memAvailable = "available"
)

var (
	memTotalMD     = NewGaugeMD(memTotal, "Total memory on the node")
	memUsedMD      = NewGaugeMD(memUsed, "Used memory on the node")

| `minio_node_drive_reads_per_sec`     | Reads per second on a drive.                             |
| `minio_node_drive_reads_kb_per_sec`  | Kilobytes read per second on a drive.                    |
| `minio_node_drive_reads_await`       | Average time for read requests to be served on a drive.  |
| `minio_node_drive_writes_per_sec`    | Writes per second on a drive.                            |

	driveCount        = "count"

	// iostat related
	driveReadsPerSec    = "reads_per_sec"
	driveReadsKBPerSec  = "reads_kb_per_sec"
	driveReadsAwait     = "reads_await"
	driveWritesPerSec   = "writes_per_sec"
	driveWritesKBPerSec = "writes_kb_per_sec"
	driveWritesAwait    = "writes_await"
	drivePercUtil       = "perc_util"
)

var (
	driveUsedBytesMD = NewGaugeMD(driveUsedBytes,

| `minio_system_drive_reads_per_sec`             | `gauge`   | Reads per second on a drive                                        | `drive,set_index,drive_index,pool_index,server`     |
| `minio_system_drive_reads_kb_per_sec`          | `gauge`   | Kilobytes read per second on a drive                               | `drive,set_index,drive_index,pool_index,server`     |

		Downloads:     totalBytesRead,
		UploadTimes:   uploadTimes,
		DownloadTimes: downloadTimes,
		DownloadTTFB:  downloadTTFB,
		Error:         retError,
	}, nil
}

// To collect RX stats during "mc support perf net"
// RXSample holds the RX bytes for the duration between
// the last peer to connect and the first peer to disconnect.
// This is to improve the RX throughput accuracy.
type netPerfRX struct {

}

fun Response.commonNewBuilder(): Response.Builder = Response.Builder(this)

val Response.commonIsRedirect: Boolean
  get() =
    when (code) {
      HTTP_PERM_REDIRECT, HTTP_TEMP_REDIRECT, HTTP_MULT_CHOICE, HTTP_MOVED_PERM, HTTP_MOVED_TEMP, HTTP_SEE_OTHER -> true
      else -> false
    }

val Response.commonCacheControl: CacheControl
  get() {
    var result = lazyCacheControl

}

// OpenFile captures time taken to call os.OpenFile
func OpenFile(name string, flag int, perm os.FileMode) (f *os.File, err error) {
	switch flag & writeMode {
	case writeMode:
		defer updateOSMetrics(osMetricOpenFileW, name)(err)
	default:
		defer updateOSMetrics(osMetricOpenFileR, name)(err)
	}
	return os.OpenFile(name, flag, perm)
}

// Access captures time taken to call syscall.Access()

        )

        assertEquals(
            listOf(
                "KILL_ALL_GRADLE_PROCESSES",
                "SETUP_VIRTUAL_DISK_FOR_PERF_TEST",
                "GRADLE_RUNNER",
                "REMOVE_VIRTUAL_DISK_FOR_PERF_TEST",
                "KILL_PROCESSES_STARTED_BY_GRADLE",
                "CHECK_CLEAN_M2_ANDROID_USER_HOME"
            ),