// if the CPU requested is a multiple of the number of virtual cpus per physical cores.
			// In case CPU request is not a multiple of the number of virtual cpus per physical cores the Pod will be put
			// in Failed state, with SMTAlignmentError as reason. Since the allocation happens in terms of physical cores
			// and the scheduler is responsible for ensuring that the workload goes to a node that has enough CPUs,

// pcBuf and dst should not overlap.
//
// fpunwindExpand checks if pcBuf contains logical frames (which include inlined
// frames) or physical frames (produced by frame pointer unwinding) using a
// sentinel value in pcBuf[0]. Logical frames are simply returned without the
// sentinel. Physical frames are turned into logical frames via inline unwinding
// and by applying the skip value that's stored in pcBuf[0].

	//
	//Connection Name:  Local Area Connection
	//Network Adapter:  Intel Gigabit Network Connection
	//Physical Address: XX-XX-XX-XX-XX-XX
	//Transport Name:   \Device\Tcpip_{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}
	//
	//Connection Name:  Wireless Network Connection
	//Network Adapter:  Wireles WLAN Card
	//Physical Address: XX-XX-XX-XX-XX-XX
	//Transport Name:   Media disconnected
	//

        final OsMemoryObj osMemoryObj = new OsMemoryObj();
        osObj.memory = osMemoryObj;
        final OsMemoryPhysicalObj osMemoryPhysicalObj = new OsMemoryPhysicalObj();
        osMemoryObj.physical = osMemoryPhysicalObj;
        osMemoryPhysicalObj.free = osProbe.getFreePhysicalMemorySize();
        osMemoryPhysicalObj.total = osProbe.getTotalPhysicalMemorySize();

bool TypeValidForXLA(const mlir::Type& type);

// Returns the map from core to the host that is associated with the
// core. If `cluster` is not replicated then the core is a physical core index
// and the host is a physical host name. If `cluster` is replicated then the
// core with index `i` is a logical core (`TPU_REPLICATED_CORE_i`), and the host
// is the associated virtual device name (`TPU_REPLICATED_HOST_i`).

TF_CAPI_EXPORT extern size_t TFE_TensorHandleDeviceMemorySize(TFE_TensorHandle*,
                                                              TF_Status*);

// Creates a new TensorHandle from memory residing in the physical device
// device_name. Takes ownership of the memory, and will call deleter to release
// it after TF no longer needs it or in case of error.
//
// Custom devices must use TFE_NewCustomDeviceTensorHandle instead.

	// reserved for the heap. This includes virtual address space
	// that has been reserved but not yet used, which consumes no
	// physical memory, but tends to be small, as well as virtual
	// address space for which the physical memory has been
	// returned to the OS after it became unused (see HeapReleased
	// for a measure of the latter).
	//
	// HeapSys estimates the largest size the heap has had.

	// Test printing exactly the maximum number of frames to make sure we don't
	// print any "elided" message, eliding exactly 1 so we have to pick back up
	// in the paused physical frame, and eliding 10 so we have to advance the
	// physical frame forward.
	for _, elided := range []int{0, 1, 10} {
		t.Run(fmt.Sprintf("elided=%d", elided), func(t *testing.T) {
			n := elided + runtime.TracebackInnerFrames + runtime.TracebackOuterFrames

// set `availableCPUs`. `topo` describes how the CPUs are arranged between sockets, NUMA nodes
// and physical cores (if hyperthreading is on a "CPU" is a thread rather than a full physical
// core).
//
// If sockets are higher than NUMA nodes in the memory hierarchy (i.e. a socket contains more than
// one NUMA node), the CPUs are selected as follows.
//

	Msglen  uint16
	Version uint8
	Type    uint8
	Addrs   int32
	Flags   int32
	Index   uint16
	Data    IfData
}

type IfData struct {
	Type       uint8
	Typelen    uint8
	Physical   uint8
	Addrlen    uint8
	Hdrlen     uint8
	Recvquota  uint8
	Xmitquota  uint8
	Unused1    uint8
	Mtu        uint32
	Metric     uint32
	Baudrate   uint32
	Ipackets   uint32
	Ierrors    uint32