DeviceType compilation_device_type = DeviceType(DEVICE_GPU_XLA_JIT);

  se::Platform::Id platform_id = nullptr;
  auto xla_device_metadata = CreateXlaDeviceMetadata(compilation_device_type);
  std::shared_ptr<se::DeviceMemoryAllocator> custom_allocator;
  XlaPlatformInfo platform_info(
      compilation_device_type, platform_id, xla_device_metadata.get(),
      /*pjrt_device_metadata=*/nullptr, custom_allocator);

        persistor_config, DeviceType(DEVICE_TPU_XLA_JIT), nullptr);
    return absl::OkStatus();
  }

  if (platform_info.platform_id() == nullptr) {
    return errors::InvalidArgument("platform_id is null.");
  }
  auto platform =
      se::PlatformManager::PlatformWithId(platform_info.platform_id());
  if (!platform.ok()) {
    return platform.status();
  }

  absl::StatusOr<xla::Compiler*> compiler_for_platform =

  explicit XlaPlatformInfo(
      const DeviceType device_type, se::Platform::Id platform_id,
      const XlaDevice::Metadata* xla_device_metadata,
      const PjRtBaseDevice::Metadata* pjrt_device_metadata,
      std::shared_ptr<se::DeviceMemoryAllocator> device_allocator)
      : device_type_(device_type),
        platform_id_(platform_id),
        xla_device_metadata_(xla_device_metadata),

  // XlaPlatformInfo::device_type() is needed to build the appropriate
  // XlaDeviceCompiler.
  Device* device = nullptr;
  XlaPlatformInfo platform_info(DeviceType(DEVICE_TPU), /*platform_id=*/nullptr,
                                /*xla_device_metadata=*/nullptr,
                                /*pjrt_device_metadata=*/nullptr,
                                /*device_allocator=*/nullptr);

                             compiler_arg_source));

  se::Platform::Id platform_id = nullptr;
  if (platform_name == DEVICE_CPU) {
    platform_id = se::host::kHostPlatformId;
  }
  XlaPlatformInfo platform_info(DeviceType(platform_name), platform_id,
                                /*xla_device_metadata=*/nullptr,
                                /*pjrt_device_metadata=*/nullptr,

	[op(0x10)]
	int ShareGetInfo([in,string,unique] wchar_t *servername,
			[in,string] wchar_t *sharename,
			[in] int level,
			[out,switch_is(level)] ShareInfo *info);

	typedef struct {
		unsigned long platform_id;
		[string] wchar_t *name;
	} ServerInfo100;

	typedef [switch_type(int)] union {
		[case(0)] ServerInfo100 *info0;
	} ServerInfo;

	[op(0x15)]
	int ServerGetInfo([in,string,unique] wchar_t *servername,

        }
    }
    public static class ServerInfo100 extends NdrObject {

        public int platform_id;
        public String name;

        public void encode(NdrBuffer _dst) throws NdrException {
            _dst.align(4);
            _dst.enc_ndr_long(platform_id);
            _dst.enc_ndr_referent(name, 1);

            if (name != null) {
                _dst = _dst.deferred;

	[op(0x10)]
	int ShareGetInfo([in,string,unique] wchar_t *servername,
			[in,string] wchar_t *sharename,
			[in] int level,
			[out,switch_is(level)] ShareInfo *info);

	typedef struct {
		unsigned long platform_id;
		[string] wchar_t *name;
	} ServerInfo100;

	typedef [switch_type(int)] union {
		[case(0)] ServerInfo100 *info0;
	} ServerInfo;

	[op(0x15)]
	int ServerGetInfo([in,string,unique] wchar_t *servername,

        }
    }

    public static class ServerInfo100 extends NdrObject {

        public int platform_id;
        public String name;


        @Override
        public void encode ( NdrBuffer _dst ) throws NdrException {
            _dst.align(4);
            _dst.enc_ndr_long(this.platform_id);
            _dst.enc_ndr_referent(this.name, 1);

            if ( this.name != null ) {

  options.flib_def = function_library.GetFunctionLibraryDefinition();
  options.graph_def_version = function_library.graph_def_version();
  options.allow_cpu_custom_calls =
      (platform_info.platform_id() == se::host::kHostPlatformId);
  options.device_allocator = GetAllocator(device, stream, platform_info);
  if (platform_info.xla_device_metadata()) {
    options.shape_determination_fns =