/compiler/ir/backend.common/ "Kotlin JVM" "Kotlin Native" "Kotlin Wasm" "Kotlin Common Backend"
/compiler/ir/backend.js/ "Kotlin Common Backend"
/compiler/ir/backend.jvm/ "Kotlin JVM"
/compiler/ir/backend.wasm/ "Kotlin Wasm"
/compiler/ir/ir.actualization/ "Kotlin Compiler Core" "Kotlin Common Backend" Simon.Ogorodnik
/compiler/ir/ir.interpreter/ "Kotlin Common Backend"
/compiler/ir/ir.psi2ir/ "Kotlin JVM"

    } else {
      // TODO(b/78468222): This can fail, at least when the backend is GPU and
      // there is no GPU on the host.
      xla::Backend* backend = GetOrCreateClient().value()->mutable_backend();
      xla_allocator_ = XlaDeviceAllocatorState::GetOrCreateXlaDeviceAllocator(
          backend, device_ordinal_);
    }
  }
  return xla_allocator_;
}

}

func ingressBackendToHTTPRoute(backend *knetworking.IngressBackend, namespace string,
	domainSuffix string, services kclient.Client[*corev1.Service],
) *networking.HTTPRoute {
	if backend == nil {
		return nil
	}

	port := &networking.PortSelector{}

	if backend.Service == nil {
		log.Infof("backend service must be specified")
		return nil
	}
	if backend.Service.Port.Number > 0 {

		ObjectMeta: metav1.ObjectMeta{
			Namespace: "mock", // goes into backend full name
			Name:      "test",
		},
		Spec: net.IngressSpec{
			Rules: []net.IngressRule{
				{
					Host: "my.host.com",
					IngressRuleValue: net.IngressRuleValue{
						HTTP: &net.HTTPIngressRuleValue{
							Paths: []net.HTTPIngressPath{
								{
									Path: "/test",
									Backend: net.IngressBackend{
										Service: &net.IngressServiceBackend{

  // +optional
  optional string ingressClassName = 4;

  // backend is the default backend capable of servicing requests that don't match any
  // rule. At least one of 'backend' or 'rules' must be specified. This field
  // is optional to allow the loadbalancer controller or defaulting logic to
  // specify a global default.
  // +optional
  optional IngressBackend backend = 1;

			tlsConfig.InsecureSkipVerify = false
		}
	}

	backends := []Backend{}
	for server := range servers {
		backends = append(backends, Backend{
			Server: server,
			// We can't share TLSConfig across different backends to avoid races.
			// For more details see: https://pr.k8s.io/59338
			TLSConfig: tlsConfig.Clone(),
		})
	}
	return backends
}

  // +optional
  optional string ingressClassName = 4;

  // backend is the default backend capable of servicing requests that don't match any
  // rule. At least one of 'backend' or 'rules' must be specified. This field
  // is optional to allow the loadbalancer controller or defaulting logic to
  // specify a global default.
  // +optional
  optional IngressBackend backend = 1;

	// backend is the default backend capable of servicing requests that don't match any
	// rule. At least one of 'backend' or 'rules' must be specified. This field
	// is optional to allow the loadbalancer controller or defaulting logic to
	// specify a global default.
	// +optional
	Backend *IngressBackend `json:"backend,omitempty" protobuf:"bytes,1,opt,name=backend"`

	WrapTransport bool
	// UseRequestLocation will use the incoming request URL when talking to the backend server.
	UseRequestLocation bool
	// UseLocationHost overrides the HTTP host header in requests to the backend server to use the Host from Location.
	// This will override the req.Host field of a request, while UseRequestLocation will override the req.URL field

 */
class TaskRunner(
  val backend: Backend,
  internal val logger: Logger = TaskRunner.logger,
) {
  val lock: ReentrantLock = ReentrantLock()
  val condition: Condition = lock.newCondition()

  private var nextQueueName = 10000
  private var coordinatorWaiting = false
  private var coordinatorWakeUpAt = 0L

  /**
   * When we need a new thread to run tasks, we call [Backend.execute]. A few microseconds later we