Status GradientRegistry::Register(
    const string& op_name, GradientFunctionFactory gradient_function_factory) {
  auto iter = registry_.find(op_name);
  if (iter != registry_.end()) {
    const string error_msg = "Gradient already exists for op: " + op_name + ".";
    return errors::AlreadyExists(error_msg);
  }
  registry_.insert({op_name, gradient_function_factory});
  return absl::OkStatus();
}
Status GradientRegistry::Lookup(

//   // More complex gradient functions can use inputs/attrs etc. from the
//   // forward `op`.
//   return new AddGradientFunction;
// }
//
// Status RegisterGradients(GradientRegistry* registry) {
//   return registry->Register("Add", AddRegisterer);
// }
class GradientFunction {
 public:
  virtual Status Compute(AbstractContext* ctx,
                         absl::Span<AbstractTensorHandle* const> grad_outputs,

	se := serviceentry.NewController(
		configController,
		xdsUpdater,
		env.Watcher,
		serviceentry.WithClusterID(opts.ClusterID))
	// TODO allow passing in registry, for k8s, mem reigstry
	serviceDiscovery.AddRegistry(se)
	msd := memregistry.NewServiceDiscovery(opts.Services...)
	msd.XdsUpdater = xdsUpdater
	for _, instance := range opts.Instances {
		msd.AddInstance(instance)
	}

   * of the Mozilla Foundation's <a href="http://publicsuffix.org/">Public Suffix List</a> (PSL). A
   * registry suffix is one under which Internet users can directly register names via a domain name
   * registrar, and have such registrations lawfully protected by internet-governing bodies such as

   * of the Mozilla Foundation's <a href="http://publicsuffix.org/">Public Suffix List</a> (PSL). A
   * registry suffix is one under which Internet users can directly register names via a domain name
   * registrar, and have such registrations lawfully protected by internet-governing bodies such as

            def lease = registry.currentWorkerLease
            def nested = registry.runAsWorkerThread({
                assert registry.workerThread
                assert registry.currentWorkerLease == lease
                "result"
            } as Factory)
            assert registry.workerThread
            assert registry.currentWorkerLease == lease
            nested
        } as Factory

        given:

        given:
        registry.registerInstance("foo", 12.toInteger())
        registry.realize("foo")
        registry.registerInstance("bar", new Bean())
        registry.mutate { it.path("bar").type(Bean).action(Integer, action) }
        action.execute(_, 12) >> { bean, value -> bean.value = "[12]" }

        expect:
        registry.realize("bar", Bean).value == "[12]"
    }

        registry.versions.size() == 1
        registry.libraries.size() == 1
        registry.versions[0].alias == "group-artifact"
        registry.versions[0].module == "group:artifact"
        registry.versions[0].version == "1.1"
        registry.libraries[0].alias == "group-artifact"
        registry.libraries[0].module == "group:artifact"
        registry.libraries[0].version == "1.1"
        registry.libraries[0].versionRef == "group-artifact"

    def "can add type to registry that has package private constructor"() {
        when:
        def registry = new DefaultServiceRegistry()
        registry.register {
            it.add(String, "Potato")
            it.add(ModifierStubs.PackagePrivateConstructor)
        }
        then:
        noExceptionThrown()

    }

    def "cannot register a handle once the registry is stopped" () {
        given:
        registry.stop()

        when:
        registry.start("id", DeploymentRegistry.ChangeBehavior.NONE, TestDeploymentHandle)
        then:
        def e = thrown(IllegalStateException)
        e.message == "Cannot modify deployment handles once the registry has been stopped."
    }