numaInfo *NUMAInfo
	opts     PolicyOptions
}

var _ Policy = &singleNumaNodePolicy{}

// PolicySingleNumaNode policy name.
const PolicySingleNumaNode string = "single-numa-node"

// NewSingleNumaNodePolicy returns single-numa-node policy.
func NewSingleNumaNodePolicy(numaInfo *NUMAInfo, opts PolicyOptions) Policy {
	return &singleNumaNodePolicy{numaInfo: numaInfo, opts: opts}
}

import (
	"flag"
	"fmt"
	"strings"
	"unicode"
)

func isSpaceByte(c byte) bool {
	return c == ' ' || c == '\t' || c == '\n' || c == '\r'
}

// Split splits s into a list of fields,
// allowing single or double quotes around elements.
// There is no unescaping or other processing within
// quoted fields.
//
// Keep in sync with cmd/dist/quoted.go
func Split(s string) ([]string, error) {

            val value: Any
        }

        interface ValueFactoryNode : ValueNode {
            val factoryName: String
            val values: List<ValueNode> // TODO: restrict to a single value? or even a single literal?
        }
    }

// CHECK-LABEL: func nested @_tpu_v1_compat_outlined_func0(%arg0: tensor<i1>) -> tensor<i1>
// CHECK-NEXT: tf.SomeTpuOp
// CHECK-NEXT: tf.SomeOtherTpuOp

// -----

// Test single-core TPU case with single-op cluster.

// CHECK-LABEL: @func4
func.func @func4() {
  tf_executor.graph {
// CHECK: island
// CHECK: PartitionedCall
// CHECK-SAME: @_tpu_v1_compat_outlined::@_tpu_v1_compat_outlined_func0

	}
}

// Must only be called from a single goroutine at a time.
//
//go:linkname signal_enable os/signal.signal_enable
func signal_enable(s uint32) {
	if !sig.inuse {
		// This is the first call to signal_enable. Initialize.
		sig.inuse = true // enable reception of signals; cannot disable
		noteclear(&sig.note)
	}
}

// Must only be called from a single goroutine at a time.
//

 * A marker interface for a provider that can be composed, i.e. multiple instances of the same provider can be composed into a single
 * provider.
 *
 * Composable providers share certain traits: There is a notion of a sequentially composed [KotlinCompositeProvider] of that kind, and there
 * is usually a merge function which allows to create a single provider from a list of providers. Mergers of composable providers may

  return a != Attribute() && b != Attribute() && c != Attribute();
}

// Returns the single float element from an ElementsAttr. Returns empty
// attribute if the number of elements in the attribute is not 1 or the
// element isn't a float attribute.
FloatAttr ExtractSingleElementAsFloat(ElementsAttr attr);

// Returns the single float element if the input is an ElementsAttr, or return

 *
 * <p>Implementations are not guaranteed to be completely thread-safe.
 * However, the implementations:
 * <ul>
 * <li>should allow separate threads for dispatching and receiving, i.e. single thread that dispatches
 * and a different single thread that receives should be perfectly safe</li>
 * <li>should allow stopping or requesting stopping from a different thread than receiving/dispatching</li>

        require(closure.call() == "result") { "parameter-less closure" }

    fun takingUnaryClosure(closure: Closure<*>) =
        require(closure.call("foo") == "result from single parameter foo") { "unary closure" }

    fun takingBinaryClosure(closure: Closure<*>) =
        require(closure.call("foo", "bar") == "result from parameters foo and bar") { "binary closure" }
}

// tag::kotlinClosure[]

// Test simple serialized computation consisting of a function named `main`
// with a tf.Identity op forwarding the function single argument to the function
// single result.

// CHECK-LABEL: module
// CHECK-SAME:  attributes {tf.versions = {producer = 888 : i32}} {
// CHECK-NEXT:   func @main([[ARG0:%.+]]: tensor<?xi32> loc({{.*}})) -> tensor<?xi32> {