platform.value()->Name(), ": ",
                                   status.ToString());
    }
  }

  xla::LocalClientOptions client_options;
  client_options.set_platform(platform.value());
  if (device != nullptr) {
    client_options.set_intra_op_parallelism_threads(
        device->tensorflow_cpu_worker_threads()->num_threads);
  }

  if (flr != nullptr) {

  // details of the host hardware when the client is created, so we
  // don't want to do it until we get a chance to hook the platform up
  // to a simulator.

  xla::LocalClientOptions options;
  options.set_platform(platform_)
      .set_allowed_devices(allowed_devices_)
      .set_intra_op_parallelism_threads(intra_op_parallelism_threads_);
  return xla::ClientLibrary::GetOrCreateLocalClient(options);
}

using OwnedTFStatus = tensorflow::TF_StatusPtr;

namespace {
absl::Status ValidateSPPlatform(const SP_Platform& platform) {
  TF_VALIDATE_STRUCT_SIZE(SP_Platform, platform, SP_PLATFORM_STRUCT_SIZE);
  TF_VALIDATE_NOT_NULL(SP_Platform, platform, name);
  TF_VALIDATE_NOT_NULL(SP_Platform, platform, type);
  TF_RETURN_IF_ERROR(
      tensorflow::device_utils::ValidateDeviceType(platform.name));
  TF_RETURN_IF_ERROR(

}

/*** Functions for creating SP_Platform ***/
void CreateTimerFns(const SP_Platform* platform, SP_TimerFns* timer_fns,
                    TF_Status* status) {
  TF_SetStatus(status, TF_OK, "");
  PopulateDefaultTimerFns(timer_fns);
}
void DestroyTimerFns(const SP_Platform* platform, SP_TimerFns* timer_fns) {}

void CreateStreamExecutor(const SP_Platform* platform,

        switch (osSupport) {
            case MAC_OS_X: return new JansiLibrary(os, MAC_OSX_LIB_FILENAME);
            case LINUX: return new JansiLibrary(jansiRuntimeResolver.getPlatform(), LINUX_LIB_FILENAME);
            case WINDOWS: return new JansiLibrary(jansiRuntimeResolver.getPlatform(), WINDOWS_LIB_FILENAME);
            default: return null;
        }
    }

// "Something" that can be manipulated via calls in the C interface.
class CPlatform : public Platform {
 public:
  explicit CPlatform(SP_Platform platform,
                     void (*destroy_platform)(SP_Platform*),
                     SP_PlatformFns platform_fns,
                     void (*destroy_platform_fns)(SP_PlatformFns*),

    private final String filename;

    public JansiLibrary(String platform, String filename) {
        this.platform = platform;
        this.filename = filename;
    }

    public String getPlatform() {
        return platform;
    }

    public String getFilename() {
        return filename;
    }

    public String getPath() {
        return platform + "/" + filename;
    }

        }
        if (name.startsWith("win")) {
            return WINDOWS.getIdentifier();
        }
        return name.replaceAll("\\W+", "_");
    }

    @Override
    public String getPlatform() {
        return getOperatingSystem() + getBitModel();
    }

    private int getBitModel() {
        String prop = System.getProperty("sun.arch.data.model");
        if (prop == null) {

 * limitations under the License.
 */

package org.gradle.internal.nativeintegration.jansi;

public interface JansiRuntimeResolver {

    String getOperatingSystem();
    String getPlatform();

		exit(1)
	}
}

func archauxv(tag, val uintptr) {
	switch tag {
	case _AT_HWCAP:
		cpu.HWCap = uint(val)
	case _AT_HWCAP2:
		cpu.HWCap2 = uint(val)
	case _AT_PLATFORM:
		cpu.Platform = gostringnocopy((*byte)(unsafe.Pointer(val)))
	}
}

//go:nosplit
func cputicks() int64 {
	// runtime·nanotime() is a poor approximation of CPU ticks that is enough for the profiler.