addWakeupEvent(kq)
}

func netpollopen(fd uintptr, pd *pollDesc) int32 {
	// Arm both EVFILT_READ and EVFILT_WRITE in edge-triggered mode (EV_CLEAR)
	// for the whole fd lifetime. The notifications are automatically unregistered
	// when fd is closed.
	var ev [2]keventt
	*(*uintptr)(unsafe.Pointer(&ev[0].ident)) = fd
	ev[0].filter = _EVFILT_READ
	ev[0].flags = _EV_ADD | _EV_CLEAR
	ev[0].fflags = 0
	ev[0].data = 0

// RUN: tf-opt %s -allow-unregistered-dialect --tf-group-by-dialect --split-input-file | FileCheck %s

func.func @three_dialects(%arg0: tensor<f32>) -> tensor<f32> {
  %one = "glue.constant"() { value = 1: i32 } : () -> i32
  %done = "glue.compare" (%one, %one) { predicate = #glue<"compare LTE"> } : (i32, i32) -> i1
  %2 = mhlo.constant dense<[[1.1]]> : tensor<1x1xf32>
  %3 = mhlo.multiply %2, %2 : tensor<1x1xf32>

  func.return %arg : tensor<*xi32>
}

func.func private @custom_callee() -> tensor<2xi32>  {
  %0 = "tf.CustomTFOp"() : () -> tensor<2xi32>
  func.return %0 : tensor<2xi32>
}

// Test that unregistered user-defined custom TF operations can not be inlined
// when there are duplicated cases.

// CHECK-LABEL: func @dont_inline_custom_on_duplicated_cases(
func.func @dont_inline_custom_on_duplicated_cases() -> tensor<2xi32> {

// removePlugin is called whenever a plugin has been unregistered.
func (c *nodeResourcesController) removePlugin(driverName string) {
	if c == nil {
		return
	}

	klog.FromContext(c.ctx).V(2).Info("Removing plugin", "driverName", driverName)
	c.mutex.Lock()
	defer c.mutex.Unlock()
	if active, ok := c.activePlugins[driverName]; ok {
		active.cancel(errors.New("plugin has unregistered"))
		delete(c.activePlugins, driverName)

			}
		}
		gp.m.blocked = false
		return true
	}

	deadline = nanotime() + ns
	for {
		// Registered. Sleep.
		gp.m.blocked = true
		if *cgo_yield != nil && ns > 10e6 {
			ns = 10e6
		}
		if semasleep(ns) >= 0 {
			gp.m.blocked = false
			// Acquired semaphore, semawakeup unregistered us.
			// Done.
			return true
		}
		if *cgo_yield != nil {
			asmcgocall(*cgo_yield, nil)
		}

// RUN: tf-opt %s -allow-unregistered-dialect --tf-remove-unused-arguments --split-input-file | FileCheck %s

func.func private @f(%arg0: tensor<f32>, %arg1: tensor<f32>) -> tensor<f32> {
  "SomeOp"(%arg1) : (tensor<f32>) -> ()
  return %arg1 : tensor<f32>
}

// CHECK-LABEL: removes_first_arg
func.func @removes_first_arg(%arg0: tensor<f32>, %arg1: tensor<f32>) -> tensor<f32> {
  // CHECK: call{{.*}}(%arg1)

// RUN: tf-quant-opt %s -quant-merge-save-function-ops-to-main \
// RUN:     -allow-unregistered-dialect -mlir-disable-threading \
// RUN:     -split-input-file -verify-diagnostics | FileCheck %s

// Test that the @tf_quant_save's ops are cloned to @main.

module attributes {tf_saved_model.semantics} {
  func.func private @tf_quant__save(%arg: tensor<!tf_type.string>) -> () {
    tf_executor.graph {

// the gorestful handler (used for the API) which falls through to the nonGoRestful handler on unregistered paths,
// and the nonGoRestful handler (which can contain a fallthrough of its own)
// FullHandlerChain -> Director -> {GoRestfulContainer,NonGoRestfulMux} based on inspection of registered web services
type APIServerHandler struct {

// RUN: tf-quant-opt %s -quant-optimize -allow-unregistered-dialect | FileCheck %s

func.func @remove_redundant_cast(%arg0: tensor<1x100x100x1xf32>) -> (tensor<1x96x96x1xf32>) {
  %cst = "tf.Const"() {value = dense<-128> : tensor<i32>} : () -> tensor<i32>
  %cst_0 = "tf.Const"() {value = dense<0.0235294122> : tensor<f32>} : () -> tensor<f32>
  %cst_1 = "tf.Const"() {value = dense<0.00708661414> : tensor<1xf32>} : () -> tensor<1xf32>

				if plugin.SocketPath == socketPath {
					return false, nil
				}
			}
			return true, nil
		},
	)

	if err != nil {
		t.Fatalf("Timed out waiting for plugin to be unregistered:\n%s.", socketPath)
	}
}

func retryWithExponentialBackOff(initialDuration time.Duration, fn wait.ConditionFunc) error {
	backoff := wait.Backoff{
		Duration: initialDuration,
		Factor:   3,