mlir::PassPipelineRegistration<> replicated_clustering_bridge_v2(
    "tf-replicated-clustering-bridge-v2",
    "Run all the passes involved in transforming a TensorFlow 2 graph before "
    "execution so that it is suitable for targeting devices.",
    CreateReplicatedClusteringPipelineV2);

}  // namespace v2
}  // namespace tf2xla

//
// The fixup table below helps overcome this hurdle. At the point
// where a parameter/variable reference is made (via a call to
// "ReferenceChildDIE"), a fixup record is generate that records
// the relocation that is targeting that child variable. At a later
// point when the abstract function DIE is emitted, there will be
// a call to "RegisterChildDIEOffsets", at which point the offsets

	r := f.f.RegAlloc
	for _, b := range f.blocks {
		for _, v := range b.Values {
			if v.Op == OpLoadReg && r[v.ID].String() == "g" {
				t.Errorf("Saw OpLoadReg targeting g register: %s", v.LongString())
			}
		}
	}
}

// Test to make sure we don't push spills into loops.
// See issue #19595.
func TestSpillWithLoop(t *testing.T) {
	c := testConfig(t)
	f := c.Fun("entry",

  // on TPU.
  // Extracts the StableHLO module from tf.XlaCallModuleOp if the StableHLO
  // module is serialized in it.
  pm.addPass(mlir::odml::CreateLegalizeTFXlaCallModuleToStablehloPass());

  // Preprocesses TPU-targeting StableHLO module for support in TF Quantizer.
  pm.addPass(mlir::quant::CreateConvertTpuModelToCpuPass());
  pm.addPass(mlir::createInlinerPass());
  pm.addNestedPass<mlir::func::FuncOp>(mlir::createCanonicalizerPass());

mlir::PassPipelineRegistration<> replicated_clustering_bridge_v1(
    "tf-replicated-clustering-bridge-v1",
    "Run all the passes involved in transforming a TensorFlow V1 graph before "
    "execution so that it is suitable for targeting devices.",
    CreateReplicatedBridgePipelineV1);

}  // namespace v1
}  // namespace tf2xla

        then:
        sb1.other == "other"
    }

    static class SetProp extends RuleSource {
        @Mutate
        void m(@Path("foo") Bean bean) {}
    }

    def "when targeting by type, paths are interpreted relative to item"() {
        given:
        def mmType = ModelTypes.modelMap(Bean)

        registry
            .registerModelMap("beans", Bean) {

//     clusters.
//
//  2. Enables Kubernetes MCS use cases, where endpoints for a service might be exported in one
//     cluster but not another within the same network. By targeting the gateway for the cluster
//     where the exported endpoints reside, we ensure that we only send traffic to exported endpoints.
func (b *EndpointBuilder) selectNetworkGateways(nw network.ID, c cluster.ID) []model.NetworkGateway {

include::sample[dir="kotlin",files="convention-plugins/build.gradle.kts[tags=apply]"]
include::sample[dir="groovy",files="convention-plugins/build.gradle[tags=apply]"]
====

== Publishing convention plugins

In this sample we are targeting a multi-repo setup. In order to apply the above plugins to separate projects, they have to be published
to a company's artifact repository.

include::sample[dir="kotlin",files="convention-plugins/build.gradle.kts[tags=apply]"]
include::sample[dir="groovy",files="convention-plugins/build.gradle[tags=apply]"]
====

== Publishing convention plugins

In this sample we are targeting a multi-repo setup. In order to apply the above plugins to separate projects, they have to be published
to a company's artifact repository.

So, **avoid publishing custom variants** if they are for internal use only.
====

[[targeting-different-platforms]]
== Targeting different platforms

It is common for a library to target different platforms.
In the Java ecosystem, we often see different artifacts for the same library, distinguished by a different _classifier_.