}

Device* DeviceSetup::GetDevice(const string& device_name) {
  if (device_mgr_ == nullptr) {
    return nullptr;
  }

  string full_device_name = absl::StrCat(
      "/job:localhost/replica:0/task:0/device:", device_name, ":0");
  Device* device;
  TF_CHECK_OK(device_mgr_->LookupDevice(full_device_name, &device));
  return device;
}

class RuntimeDevices;

// Returns true if at least one GPU device is available at runtime.
bool CanUseGpuDevice(const RuntimeDevices &devices);

// Returns true if all of the GPUs available at runtime support TensorCores
// (NVIDIA compute capability >= 7.0).
bool CanUseTensorCores(const RuntimeDevices &devices);

// Returns true if operation does not have explicit device placement that would
// prevent it from running on GPU device.

		if len(entries) == 3 && entries[1] == "devices" {
			return strings.TrimSpace(entries[2]), nil
		}
	}
	return "", fmt.Errorf("could not find devices cgroup location")
}

// GetFullContainerName gets the container name given the root process id of the container.
// E.g. if the devices cgroup for the container is stored in /sys/fs/cgroup/devices/docker/nginx,

  tf_device.replicate() {n = 2 : i32, devices = {TPU_REPLICATED_CORE_0 = ["/DEVICE:0", "/DEVICE:1"], TPU_REPLICATED_CORE_1 = ["/DEVICE:2", "/DEVICE:3"]}} {
    tf_device.return
  }
  func.return

// CHECK:      tf_device.replicate
// CHECK-SAME: devices = {TPU_REPLICATED_CORE_0 = ["/DEVICE:0", "/DEVICE:1"], TPU_REPLICATED_CORE_1 = ["/DEVICE:2", "/DEVICE:3"]}
// CHECK-SAME: n = 2
// CHECK-NEXT:   tf_device.return

// RUN: tf-tfrt-opt -tfrt-lower-cluster-to-runtime-ops-tpu -split-input-file -verify-diagnostics %s | FileCheck %s

module attributes {tf.versions = {producer = 888 : i32}, tf.devices = ["/job:worker/replica:0/task:0/device:CPU:0", "/job:worker/replica:0/task:0/device:TPU_SYSTEM:0", "/job:worker/replica:0/task:0/device:TPU:0"]} {

  // CHECK-LABEL: @converts_cluster
  func.func @converts_cluster() {
    // CHECK: %0:2 = "tf_device.launch"() <{{.*}}> ({

    SessionOptions options;
    std::vector<std::unique_ptr<Device>> devices;
    Status s = device_factory->CreateDevices(
        options, "/job:worker/replica:0/task:0", &devices);
    device_ = std::move(devices[0]);

    AllocatorAttributes host_alloc_attr;
    host_alloc_attr.set_on_host(true);
    host_allocator_ = device_->GetAllocator(host_alloc_attr);

    AllocatorAttributes device_alloc_attr;

func (info *ClaimInfo) cdiDevicesAsList() []kubecontainer.CDIDevice {
	var cdiDevices []kubecontainer.CDIDevice
	for _, devices := range info.CDIDevices {
		for _, device := range devices {
			cdiDevices = append(cdiDevices, kubecontainer.CDIDevice{Name: device})
		}
	}
	return cdiDevices
}

// addPodReference adds a pod reference to the claim info.

limitations under the License.
*/

package procfs

type FakeProcFS struct{}

// GetFullContainerName gets the container name given the root process id of the container.
// E.g. if the devices cgroup for the container is stored in /sys/fs/cgroup/devices/docker/nginx,
// return docker/nginx. Assumes that the process is part of exactly one cgroup hierarchy.
func (fakePfs *FakeProcFS) GetFullContainerName(pid int) (string, error) {
	return "", nil

// CHECK-SAME:    sharding={
// CHECK-SAME:    {devices=[1,2]0,1}
// CHECK-SAME:    {maximal device=0}
// CHECK-SAME:    {replicated}
// CHECK-SAME:    }
// CHECK:         get-tuple-element((f32[128,10]{1,0}, f32[10,1024]{1,0}, f32[128,1024]{1,0}) %[[ARG_TUPLE]]), index=0
// CHECK-SAME:    sharding={devices=[1,2]0,1}

// The id of the compiled cluster.
extern const char* const kXlaClusterIdAttr;  // "_xla_compile_id"

[[deprecated("XLA:CPU/GPU devices are deprecated")]] void
RequestXlaDevicesCreation();

[[deprecated("XLA:CPU/GPU devices are deprecated")]] bool
XlaDevicesCreationRequired();

}  // namespace tensorflow