session_init_op = builder.create<SessionInitializerOp>(
        module_op.getLoc(), /*initializers=*/builder.getArrayAttr({}));
  }

  return session_init_op;
}

// Create the initializer function right after the SessionInitializer op.
// Returns the newly created initializer function. The initializer function's
// initializer_type is set to "restore_op" since it essentially serves as a

}

TEST_F(SaveVariablesToCheckpointTest, MultipleVariablesSavedToCheckpoint) {
  // Module's session intializer contains two variables.
  constexpr absl::string_view kModuleCode = R"mlir(
    module attributes {tf_saved_model.semantics} {
      "tf_saved_model.session_initializer"() {initializers = [@init_func_restore_op]} : () -> ()

	}
}

// Initialize checks the initialization interfaces implemented by each plugin
// and provide the appropriate initialization data
func (i *PluginInitializer) Initialize(plugin admission.Interface) {
	if wants, ok := plugin.(initializer.WantsQuotaConfiguration); ok {
		wants.SetQuotaConfiguration(i.quotaConfiguration)
	}

	if wants, ok := plugin.(initializer.WantsExcludedAdmissionResources); ok {

		authorizer:        authz,
		featureGates:      featureGates,
		stopCh:            stopCh,
		restMapper:        restMapper,
	}
}

// Initialize checks the initialization interfaces implemented by a plugin
// and provide the appropriate initialization data
func (i pluginInitializer) Initialize(plugin admission.Interface) {
	// First tell the plugin about drained notification, so it can pass it to further initializations.

module attributes {tf_saved_model.semantics} {
}

// -----

// Nothing happens when there are no initializer functions.

// CHECK-LABEL: module
module attributes {tf_saved_model.semantics} {
  "tf_saved_model.session_initializer"() {initializers = []} : () -> ()
}

// -----

// Nothing happens when the initializer function of type = "restore_op" is
// empty.

// CHECK-LABEL: module

func NewPluginInitializer(cloudConfig []byte) *PluginInitializer {
	return &PluginInitializer{
		cloudConfig: cloudConfig,
	}
}

// Initialize checks the initialization interfaces implemented by each plugin
// and provide the appropriate initialization data
func (i *PluginInitializer) Initialize(plugin admission.Interface) {
	if wants, ok := plugin.(WantsCloudConfig); ok {
		wants.SetCloudConfig(i.cloudConfig)
	}

func main() {
	ok := true
	for i, s := range same {
		if !reflect.DeepEqual(s.a, s.b) {
			ok = false
			fmt.Printf("#%d not same: %v and %v\n", i+1, s.a, s.b)
		}
	}
	if !ok {
		fmt.Println("BUG: test/initialize")
	}

}

func TestRESTMapperAdmissionPlugin(t *testing.T) {
	initializer := initializer.New(nil, nil, nil, &TestAuthorizer{}, nil, nil, &doNothingRESTMapper{})
	wantsRESTMapperAdmission := &WantsRESTMapperAdmissionPlugin{}
	initializer.Initialize(wantsRESTMapperAdmission)

	if wantsRESTMapperAdmission.mapper == nil {
		t.Errorf("Expected REST mapper to be initialized but found nil")
	}
}

Rama Chavali <******@****.***> 1667160478 +0530

  let summary = "Initializes TensorFlow session state.";
  let description = [{
    The session initializer op marks one or more functions that must be called
    by an external agent exactly once to initialize TensorFlow session state,
    and this must happen before any other exported functions are called. There
    must be no more than one session initializer op in a saved model.