// picked over a node with a smaller number of pods with the same negative
				// priority (and similar scenarios).
				sumPriorities += int64(corev1helpers.PodPriority(pod)) + int64(math.MaxInt32+1)
			}
			// The smaller the sumPriorities, the higher the score.
			return -sumPriorities
		}
		minNumPodsScoreFunc := func(node string) int64 {
			// The smaller the length of pods, the higher the score.

package cgotest

/*
#include <resolv.h>
*/
import "C"

import (
	"internal/syscall/unix"
	"unsafe"
)

// This will cause a compile error when the size of
// unix.ResState is too small.

        .put("tar.snappy.small", new SnappyPacker(new CommonsTarPacker(2)))
        .put("tar.snappy.large", new SnappyPacker(new CommonsTarPacker(64)))
        .put("tar", new CommonsTarPacker(4))
        .put("tar.commons", new CommonsTarPacker(4))
        .put("tar.jtar", new JTarPacker(4))
        .put("tar.small", new CommonsTarPacker(2))
        .put("tar.large", new CommonsTarPacker(64))

        "//tensorflow/core/platform:str_util",
        "@com_google_absl//absl/strings",
    ],
    alwayslink = 1,
)

tf_cc_test(
    name = "cpp_generator_test",
    size = "small",
    srcs = ["cpp_generator_test.cc"],
    data = ["//tensorflow/c/experimental/ops/gen/cpp/golden"],
    deps = [
        ":cpp",
        "//tensorflow/core:core_cpu",
        "//tensorflow/core:framework",

#     size_override = {
#         "compile.benchmark.small.mlir": "medium",
#         "batching_fallback.mlir": "medium",
#     },
#     tags_override = {
#         "async_op_thread.mlir": ["nomsan"],  # Can't instrument code in precompiled lib (cuDNN)
#         "batching_fallback.mlir": ["nomsan"],  # Can't instrument code in precompiled lib (cuDNN)

        "//tensorflow/core:lib",
        "//tensorflow/core:lib_internal",
        "@com_google_absl//absl/strings",
    ],
    alwayslink = 1,
)

tf_cc_tests(
    name = "renderer_tests",
    size = "small",
    srcs = glob(
        ["*_test.cc"],
    ),
    deps = [
        ":renderers",
        "//tensorflow/c/experimental/ops/gen/common",
        "//tensorflow/core:core_cpu",
        "//tensorflow/core:framework",

    assertEquals(-1, read);

    lin.reset();
    byte[] small = new byte[5];
    read = lin.read(small);
    assertEquals(2, read);
    assertEquals(big[0], small[0]);
    assertEquals(big[1], small[1]);

    lin.reset();
    read = lin.read(small, 2, 3);
    assertEquals(2, read);
    assertEquals(big[0], small[2]);
    assertEquals(big[1], small[3]);
  }

  public void testLimit_mark() throws Exception {

func (out *OutBuf) Mmap(filesize uint64) error {
	// We need space to put all the symbols before we apply relocations.
	oldheap := out.heap
	if filesize < uint64(len(oldheap)) {
		panic("mmap size too small")
	}
	out.heap = make([]byte, filesize)
	copy(out.heap, oldheap)
	return nil
}

	buf := bytes.Repeat([]byte{0xCD}, direntBufSize)
	for {
		n, err := syscall.ReadDirent(fd, buf)
		if err == syscall.EINVAL {
			// On linux, 'man getdents64' says that EINVAL indicates “result buffer is too small”.
			// Try a bigger buffer.
			t.Logf("ReadDirent: %v; retrying with larger buffer", err)
			buf = bytes.Repeat([]byte{0xCD}, len(buf)*2)
			continue
		}
		if err != nil {
			t.Fatalf("syscall.readdir: %v", err)

// stack frame (since we don't know the types of the spilled
// registers).

package runtime

import (
	"internal/goarch"
	"internal/runtime/atomic"
	"unsafe"
)

// testSmallBuf forces a small write barrier buffer to stress write
// barrier flushing.
const testSmallBuf = false

// wbBuf is a per-P buffer of pointers queued by the write barrier.
// This buffer is flushed to the GC workbufs when it fills up and on