LogicalResult MatchReduceToArgMinMaxType2(mhlo::ReduceOp reduce_op,
                                          bool is_argmax);

// Base class for converting mhlo::ReduceOp to TF/TFL ArgMax/ArgMin ops.
template <typename Reduce, typename ArgReduce, typename BooleanReduce,
          bool is_argmax>
class ConvertReduceOpToArgMinMax : public OpConversionPattern<mhlo::ReduceOp> {
 public:
  using OpConversionPattern::OpConversionPattern;

limitations under the License.
==============================================================================*/

#include "tensorflow/compiler/mlir/lite/stablehlo/transforms/legalize_hlo_conversions/reduce.h"

#include <optional>

#include "llvm/Support/Casting.h"
#include "mlir/IR/Block.h"  // from @llvm-project
#include "mlir/Support/LLVM.h"  // from @llvm-project

        "tf-reduce-identity.mlir": ["no_windows"],
    },
    test_file_exts = ["mlir"],
)

# Bundle together all of the test utilities that are used by tests.
filegroup(
    name = "test_utilities",
    testonly = True,
    data = [
        ":reducer_tester",
        "//tensorflow/compiler/mlir:tf-opt",
        "//tensorflow/compiler/mlir:tf-reduce",
        "@llvm-project//llvm:FileCheck",

`Make[T]` function, which produces a reference to a canonical copy of
the value in the form of a `Handle[T]`.
Two `Handle[T]` are equal if and only if the values used to produce the
handles are equal, allowing programs to deduplicate values and reduce
their memory footprint.
Comparing two `Handle[T]` values is efficient, reducing down to a simple

    llvm::cl::desc("Wether serialize stablehlo ops or not"),
    llvm::cl::init(true));

// NOLINTNEXTLINE
opt<bool> reduce_type_precision(
    "reduce-type-precision",
    llvm::cl::desc("Convert tensors to a lower precision if all values are "
                   "within the reduced precision range. This could have side "
                   "effects triggered by downstream packing algorithms."),

    type = "rpm"
    builtBy("rpm")
}
// end::custom-artifact[]

tasks.register("rpm") {
    // Reduce scope of property for compatibility with the configuration cache
    val rpmFile = rpmFile
    outputs.file(rpmFile)
    doLast {
        // produce real RPM here
        rpmFile.get().asFile.writeText("file contents")
    }
}

// tag::custom-artifact-publication[]
publishing {

	// workbufAlloc is the number of bytes to allocate at a time
	// for new workbufs. This must be a multiple of pageSize and
	// should be a multiple of _WorkbufSize.
	//
	// Larger values reduce workbuf allocation overhead. Smaller
	// values reduce heap fragmentation.
	workbufAlloc = 32 << 10
)

func init() {
	if workbufAlloc%pageSize != 0 || workbufAlloc%_WorkbufSize != 0 {
		throw("bad workbufAlloc")
	}
}

# Reduce Xmx after https://github.com/gradle/gradle-private/issues/4168 is resolved
org.gradle.jvmargs=-Xmx2700m -XX:MaxMetaspaceSize=768m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
org.gradle.parallel=true
org.gradle.caching=true
org.gradle.configuration-cache=true
systemProp.gradle.publish.skip.namespace.check=true
# Kotlin DSL settings
org.gradle.kotlin.dsl.allWarningsAsErrors=true
# Kotlin settings
kotlin.incremental.useClasspathSnapshot=true

	n := uint(len(rr.limbs))
	mLen := uint(m.BitLen())
	logR := _W * n

	// We start by computing R = 2^(_W * n) mod m. We can get pretty close, to
	// 2^⌊log₂m⌋, by setting the highest bit we can without having to reduce.
	rr.limbs[n-1] = 1 << ((mLen - 1) % _W)
	// Then we double until we reach 2^(_W * n).
	for i := mLen - 1; i < logR; i++ {
		rr.Add(rr, m)
	}

	// carry and partially reduce the partial products
	REDUCE(H_0, H_1, H_2, H_3, H_4)

	CMPBNE R3, $0, loop

finish:
	// sum lane 0 and lane 1 and put the result in lane 1
	VZERO  T_0
	VSUMQG H_0, T_0, H_0
	VSUMQG H_3, T_0, H_3
	VSUMQG H_1, T_0, H_1
	VSUMQG H_4, T_0, H_4
	VSUMQG H_2, T_0, H_2

	// reduce again after summation