package main

import (
	_ "reflect"
	"unsafe"
)

//go:linkname noescape runtime.noescape
func noescape(unsafe.Pointer) unsafe.Pointer

//go:linkname rtype_String reflect.(*rtype).String
func rtype_String(unsafe.Pointer) string

func main() {
	println(rtype_String(noescape(nil)))

  //    create convolutions too large for CuDNN to handle.
  return node.type_string() == "SelfAdjointEigV2" ||
         node.type_string() == "Svd" || node.type_string() == "Qr" ||
         node.type_string() == "MatrixInverse" ||
         node.type_string() == "MatrixSolve" ||
         node.type_string() == "ResizeBilinearGrad";
}

bool RecursiveCompilabilityChecker::IsCompilableNode(

      xla_launch_allowed_devices_.insert(device_type.type_string());
    }

    bool IsEnabledInXlaLaunchForDevice(const DeviceType& device_type) const {
      if (!enabled_for_gpu_ && device_type.type_string() == "GPU") return false;
      return enabled_for_all_ ||
             (enabled_for_xla_launch_ &&
              xla_launch_allowed_devices_.contains(device_type.type_string()));
    }

                          return name_attr_pair.second.has_func();
                        });
}
bool IsShapeConsumerOp(const Node& node) {
  return node.type_string() == "Shape" || node.type_string() == "Rank" ||
         node.type_string() == "Size";
}

namespace {
struct ClusterInfo {
  int size;

  // Maps op names to the number of times they appear in the cluster.

  DeviceType* device_type = id_to_device_type_.back().get();
  TF_RETURN_IF_ERROR(DeviceNameToDeviceType(names_.back(), device_type));

  is_cpu_.push_back(device_type->type_string() == DEVICE_CPU);
  is_gpu_.push_back(device_type->type_string() == DEVICE_GPU);

  name_to_id_.emplace(string(name), DeviceId(new_id));

  const XlaOpRegistry::DeviceRegistration* compilation_device;

                << context->DebugString(handle);
      }
    }

    int index = -1;
    if (n->type_string() == "_Arg") {
      // NOTE: during runtime, Placeholder ops will be replaced as `_Arg` ops.
      // And Args must have `index` attribute.
      TF_RETURN_IF_ERROR(GetNodeAttr(n->attrs(), "index", &index));
    } else if (n->type_string() == "Placeholder") {
      // Use custom attribute (prefixed with `_`) `_index` for placeholders as

  for (Node* n : graph->nodes()) {
    if (n->type_string() == "_Arg") {
      // Check if this is a guaranteed constant.
      if (is_guaranteed_constant(*n)) {
        return errors::InvalidArgument(
            "Guaranteed constants are not supported (", n->name(), ")");
      }
      args.push_back(n);
    } else if (n->type_string() == "_Retval") {
      retvals.push_back(n);
    }
  }

  return absl::StrCat(kPjRtDeviceCompilerResourceName, "_",
                      device_type.type_string());
}

std::string GetPjRtDeviceCompilationProfilerResourceName(
    const DeviceType& device_type) {
  return absl::StrCat(kPjRtDeviceCompilationProfilerResourceName, "_",
                      device_type.type_string());
}

absl::StatusOr<ResourceMgr*> GetResourceMgrForDeviceCompiler(

  // on parameter servers.
  const std::string jobType = "ps";
  const std::string nodeType = "_Arg";
  const std::string attrKey = "T";
  for (const Node* node : graph.nodes()) {
    if (node->type_string() == nodeType) {
      auto device_name = node->assigned_device_name();
      DeviceNameUtils::ParsedName device;
      if (DeviceNameUtils::ParseFullName(device_name, &device) &&

  NameAttrList func;
  if (fld->Contains(n->type_string())) {
    func.set_name(n->type_string());
    typedef protobuf::Map<string, AttrValue> AttrMap;
    *func.mutable_attr() = AttrMap(n->attrs().begin(), n->attrs().end());
  } else if (n->IsPartitionedCall()) {
    TF_RETURN_IF_ERROR(GetNodeAttr(n->def(), "f", &func));
  } else {
    TF_RET_CHECK(n->type_string() == FunctionLibraryDefinition::kGradientOp);