CLOCK_UPTIME                   = 0x5
	CLOCK_UPTIME_FAST              = 0x8
	CLOCK_UPTIME_PRECISE           = 0x7
	CLOCK_VIRTUAL                  = 0x1
	CPUSTATES                      = 0x5
	CP_IDLE                        = 0x4
	CP_INTR                        = 0x3
	CP_NICE                        = 0x1
	CP_SYS                         = 0x2
	CP_USER                        = 0x0
	CREAD                          = 0x800

		req.queueNoteFn(inQueue)
	}
}

func (req *request) Finish(execFn func()) bool {
	exec, idle := req.wait()
	if !exec {
		return idle
	}
	func() {
		defer func() {
			idle = req.qs.finishRequestAndDispatchAsMuchAsPossible(req)
		}()

		execFn()
	}()

	return idle
}

func (req *request) wait() (bool, bool) {
	qs := req.qs

	// ContainerRuntimeEndpoint is the endpoint of container runtime.
	// unix domain sockets supported on Linux while npipes and tcp endpoints are supported for windows.
	// Examples:'unix:///path/to/runtime.sock', 'npipe:////./pipe/runtime'
	ContainerRuntimeEndpoint string

	// ImageServiceEndpoint is the endpoint of container image service.
	// If not specified the default value is ContainerRuntimeEndpoint
	// +optional

 * acquire(1000)} will result in exactly the same throttling, if any), but it affects the throttling
 * of the <i>next</i> request. I.e., if an expensive task arrives at an idle RateLimiter, it will be
 * granted immediately, but it is the <i>next</i> request that will experience extra throttling,
 * thus paying for the cost of the expensive task.
 *
 * @author Dimitris Andreou
 * @since 13.0
 */

	// mcache before allocating, but idle Ps may not. Since this
	// is necessary to sweep all spans, we need to ensure all
	// mcaches are flushed before we start the next GC cycle.
	//
	// While we're here, flush the page cache for idle Ps to avoid
	// having pages get stuck on them. These pages are hidden from
	// the scavenger, so in small idle heaps a significant amount

	CLOCK_PROCESS_CPUTIME_ID          = 0x2
	CLOCK_REALTIME                    = 0x0
	CLOCK_THREAD_CPUTIME_ID           = 0x4
	CLOCK_UPTIME                      = 0x5
	CPUSTATES                         = 0x6
	CP_IDLE                           = 0x5
	CP_INTR                           = 0x4
	CP_NICE                           = 0x1
	CP_SPIN                           = 0x3
	CP_SYS                            = 0x2

				s.syscallingP[ev.Proc()] = id
				s.syscallingG[id] = ev.Proc()
				g.lastSyscallTime = ev.Time()
			}

		// Handle procs to detect syscall blocking, which si identifiable as a
		// proc going idle while the goroutine it was attached to is in a syscall.
		case ResourceProc:
			id := st.Resource.Proc()
			old, new := st.Proc()
			if old != new && new == ProcIdle {
				if goid, ok := s.syscallingP[id]; ok {

|-------------------------------|---------|------------------------------------|----------|
| `minio_system_cpu_avg_idle`   | `gauge` | Average CPU idle time              | `server` |
| `minio_system_cpu_avg_iowait` | `gauge` | Average CPU IOWait time            | `server` |
| `minio_system_cpu_load`       | `gauge` | CPU load average 1min              | `server` |

					IdleTimeout: &durationpb.Duration{
						Seconds: 10,
					},
					MaxRequestsPerConnection: &wrappers.UInt32Value{Value: 10},
				},
			},
		},
		{
			name:    "ignore TCP idle timeout when HTTP idle timeout is specified",
			cluster: &cluster.Cluster{Name: "foo", ClusterDiscoveryType: &cluster.Cluster_Type{Type: cluster.Cluster_EDS}},
			httpProtocolOptions: &http.HttpProtocolOptions{

	}

	// Autolib
	lib.Autolib = append(lib.Autolib, r.Autolib()...)

	// DWARF file table
	nfile := r.NFile()
	unit.FileTable = make([]string, nfile)
	for i := range unit.FileTable {
		unit.FileTable[i] = r.File(i)
	}

	l.addObj(lib.Pkg, or)

	// The caller expects us consuming all the data