}
}

func cpuHogger(f func(x int) int, y *int, dur time.Duration) {
	// We only need to get one 100 Hz clock tick, so we've got
	// a large safety buffer.
	// But do at least 500 iterations (which should take about 100ms),
	// otherwise TestCPUProfileMultithreaded can fail if only one
	// thread is scheduled during the testing period.
	t0 := time.Now()
	accum := *y

		}
	}
}

func TestBitwiseContended8(t *testing.T) {
	// Start with every bit in array set to 0.
	a := make([]uint8, 16)

	// Iterations to try.
	N := 1 << 16
	if testing.Short() {
		N = 1 << 10
	}

	// Set and then clear every bit in the array bit-by-bit in different goroutines.
	done := make(chan bool)
	for i := 0; i < 8; i++ {

	// one iteration.
	for _, x := range xl {
		if x != nil {
			return false
		}
	}
	return true
}

// isAll reports whether the termlist xl represents the set of all types.
func (xl termlist) isAll() bool {
	// If there's a 𝓤 term, the entire list is 𝓤.
	// If the termlist is in normal form, this requires at most
	// one iteration.
	for _, x := range xl {

  let summary = "Asynchronously execution of while op for tf_mlrt";
  let description = [{
    cond: The boolean to control whether the first iteration should be executed.
    arguments: The last $invariant_size elements are invariants between iterations.
    results: a list of futures.
    body_fn: input is [predicate_promise, arg0_future, arg0_promise, arg1_future, arg1_promise, ..., invariant_args] and has no returned results.

      max_us = g.second;
    }
  }
  int max_digits = 1;
  while (max_us >= 10.0) {
    max_us /= 10.0;
    ++max_digits;
  }
  // Dump stats out.
  printf("Benchmark ran %zu iterations over %lld us\n", count_us,
         static_cast<long long>(stats.total_us));  // NOLINT
  for (const auto& g : groups) {
    printf("  %-*s %*.3f us\n", max_label_size, g.first.c_str(), max_digits + 4,
           g.second);

	VMOV V4.B16, V20.B16
	VMOV V5.B16, V21.B16
	VMOV V6.B16, V22.B16
	VMOV V7.B16, V23.B16
	VMOV V8.B16, V24.B16
	VMOV V9.B16, V25.B16
	VMOV V10.B16, V26.B16
	VMOV V11.B16, V27.B16

	// 4 iterations. Each iteration is 8 quarter-rounds.
	MOVD $4, R0
loop:
	QR(V0, V4, V8, V12)
	QR(V1, V5, V9, V13)
	QR(V2, V6, V10, V14)
	QR(V3, V7, V11, V15)

	QR(V0, V5, V10, V15)
	QR(V1, V6, V11, V12)
	QR(V2, V7, V8, V13)

package main

import (
	"fmt"
	"math"
	"time"
)

// checkLinear asserts that the running time of f(n) is in O(n).
// tries is the initial number of iterations.
func checkLinear(typ string, tries int, f func(n int)) {
	// Depending on the machine and OS, this test might be too fast
	// to measure with accurate enough granularity. On failure,

  OpPassManager pass_manager;
  llvm::StringRef device_type = "XLA_CPU_JIT";
  absl::string_view kInlinePass =
      "inline{default-pipeline=canonicalize "
      "inlining-threshold=4294967295 max-iterations=4 }";

  CreateConvertMlirToXlaHloPipeline(pass_manager, device_type,
                                    /*enable_op_fallback=*/true,
                                    /*custom_legalization_passes*/ {});

	// The initial temporary is X15, so zero its memory instead
	// of X15 itself.
	MOVL $0, DX
	MOVQ DX, X13
	MOVQ DX, X14
	MOVOU X14, (15*16)(BX)

	// 4 iterations. Each iteration is 8 quarter-rounds.
	MOVL $4, DX
loop:
	QR(X0, X4, X8, X12, X15)
	MOVOU X4, (4*16)(BX) // save X4
	QR(X1, X5, X9, X13, X15)
	MOVOU (15*16)(BX), X15 // reload X15; temp now X4

string BackPropFrameName(const string& forward_frame_name) {
  return strings::StrCat(forward_frame_name, "_backprop");
}

// Creates a loop that counts the number of iterations performed by the
// while loop associated with `while_ctx`. The returned output yields the
// iteration count.
Status AddForwardLoopCounter(WhileContext* while_ctx, const Scope& scope,
                             Output* count) {
  // Create while loop:
  //   i = 0