disable loop unrolling by default

lib/Pipelines/ArithmeticPipelineRegistration.cpp

@@ -201,7 +201,7 @@ void mlirToSecretArithmeticPipelineBuilder(
 
   // Vectorize and optimize rotations
   // TODO(#2320): figure out where this fits in the new pipeline
-  hecoSIMDVectorizerPipelineBuilder(pm, options.experimentalDisableLoopUnroll);
+  hecoSIMDVectorizerPipelineBuilder(pm, !options.unrollFheKernelLoops);
   mathToPolynomialApproximationBuilder(pm, options.useCompositeRelu);
 
   // Layout assignment and optimization
@@ -223,7 +223,7 @@ void mlirToSecretArithmeticPipelineBuilder(
   ConvertToCiphertextSemanticsOptions convertToCiphertextSemanticsOptions;
   convertToCiphertextSemanticsOptions.minSlotCount = options.minSlotCount;
   convertToCiphertextSemanticsOptions.unrollKernels =
-      !options.experimentalDisableLoopUnroll;
+      options.unrollFheKernelLoops;
   convertToCiphertextSemanticsOptions.codegenStrategy = options.codegenStrategy;
   pm.addPass(
       createConvertToCiphertextSemantics(convertToCiphertextSemanticsOptions));
@@ -254,6 +254,7 @@ void mlirToPlaintextPipelineBuilder(OpPassManager& pm,
   // Convert to secret arithmetic
   MlirToRLWEPipelineOptions mlirToRLWEPipelineOptions;
   mlirToRLWEPipelineOptions.minSlotCount = options.plaintextSize;
+  mlirToRLWEPipelineOptions.unrollFheKernelLoops = options.unrollFheKernelLoops;
   mlirToSecretArithmeticPipelineBuilder(pm, mlirToRLWEPipelineOptions);
 
   // Insert debug handler calls and/or lower debug.validate
@@ -429,7 +430,7 @@ void mlirToRLWEPipeline(OpPassManager& pm,
   }
 
   // TODO(#2600): support loops in optimize-relinearization
-  if (!options.experimentalDisableLoopUnroll) {
+  if (options.unrollFheKernelLoops) {
     OptimizeRelinearizationOptions optimizeRelinearizationOptions;
     optimizeRelinearizationOptions.allowMixedDegreeOperands = false;
     pm.addPass(createOptimizeRelinearization(optimizeRelinearizationOptions));
@@ -731,8 +732,7 @@ void torchLinalgToCkksBuilder(OpPassManager& manager,
   suboptions.scalingModBits = options.scalingModBits;
   suboptions.firstModBits = options.firstModBits;
   suboptions.enableSplitPreprocessing = options.enableSplitPreprocessing;
-  suboptions.experimentalDisableLoopUnroll =
-      options.experimentalDisableLoopUnroll;
+  suboptions.unrollFheKernelLoops = options.unrollFheKernelLoops;
   suboptions.usePublicKey = options.usePublicKey;
   suboptions.encryptionTechniqueExtended = options.encryptionTechniqueExtended;
   suboptions.greedyModulusSwitchAfterMul = options.greedyModulusSwitchAfterMul;

lib/Pipelines/ArithmeticPipelineRegistration.h

@@ -20,9 +20,9 @@ enum RLWEScheme { ckksScheme, bgvScheme, bfvScheme };
 enum CiphertextManagementStyle { greedy, orbitIlp };
 
 struct LoopOptions : public PassPipelineOptions<LoopOptions> {
-  PassOptions::Option<bool> experimentalDisableLoopUnroll{
-      *this, "experimental-disable-loop-unroll",
-      llvm::cl::desc("Experimental: disable loop unroll, may break analyses "
+  PassOptions::Option<bool> unrollFheKernelLoops{
+      *this, "unroll-fhe-kernel-loops",
+      llvm::cl::desc("Unroll FHE kernel loops "
                      "(default to false)"),
       llvm::cl::init(false)};
 };
@@ -191,6 +191,10 @@ struct PlaintextBackendOptions
       llvm::cl::desc("The size of the plaintexts; i.e., the number of slots "
                      "to use for packing."),
       llvm::cl::init(1024)};
+  PassOptions::Option<bool> unrollFheKernelLoops{
+      *this, "unroll-fhe-kernel-loops",
+      llvm::cl::desc("Unroll FHE kernel loops (default to false)"),
+      llvm::cl::init(false)};
 };
 
 struct BackendOptions : public PassPipelineOptions<BackendOptions> {

tests/Dialect/Openfhe/Transforms/eval_add_count.mlir

@@ -1,4 +1,6 @@
-// RUN: heir-opt --mlir-to-secret-arithmetic --secret-insert-mgmt-bgv --openfhe-count-add-and-key-switch %s | FileCheck %s
+// TODO(#2257): Loop unrolling is required because convert-to-ciphertext-semantics
+// does not support dynamic extraction indices from ciphertexts.
+// RUN: heir-opt --mlir-to-secret-arithmetic='unroll-fhe-kernel-loops=true' --secret-insert-mgmt-bgv --openfhe-count-add-and-key-switch %s | FileCheck %s
 
 // CHECK: #mgmt.openfhe_params<
 // CHECK-SAME: evalAddCount = 8

tests/Examples/lattigo/bgv/box_blur/BUILD

@@ -5,12 +5,14 @@ load("@rules_go//go:def.bzl", "go_test")
 
 package(default_applicable_licenses = ["@heir//:license"])
 
+# TODO(#2257): Loop unrolling is required because convert-to-ciphertext-semantics
+# does not support dynamic extraction indices from ciphertexts.
 heir_lattigo_lib(
     name = "box_blur",
     go_library_name = "boxblur",
     heir_opt_flags = [
         "--annotate-module=backend=lattigo scheme=bgv",
-        "--mlir-to-bgv=plaintext-modulus=786433 min-slot-count=2048",
+        "--mlir-to-bgv=plaintext-modulus=786433 min-slot-count=2048 unroll-fhe-kernel-loops=true",
         "--scheme-to-lattigo",
     ],
     mlir_src = "@heir//tests/Examples/common:box_blur_16x16.mlir",

tests/Examples/lattigo/bgv/roberts_cross/BUILD

@@ -5,12 +5,14 @@ load("@rules_go//go:def.bzl", "go_test")
 
 package(default_applicable_licenses = ["@heir//:license"])
 
+# TODO(#2257): Loop unrolling is required because convert-to-ciphertext-semantics
+# does not support dynamic extraction indices from ciphertexts.
 heir_lattigo_lib(
     name = "roberts_cross",
     go_library_name = "robertscross",
     heir_opt_flags = [
         "--annotate-module=backend=lattigo scheme=bgv",
-        "--mlir-to-bgv=min-slot-count=4096 plaintext-modulus=536903681",
+        "--mlir-to-bgv=min-slot-count=4096 plaintext-modulus=536903681 unroll-fhe-kernel-loops=true",
         "--scheme-to-lattigo",
     ],
     mlir_src = "@heir//tests/Examples/common:roberts_cross_16x16.mlir",

tests/Examples/lattigo/bgv/simple_sum/BUILD

@@ -14,12 +14,14 @@ go_test(
 # For Google-internal reasons we must separate the go_test rules from the macro
 # above.
 
+# TODO(#2257): Loop unrolling is required because convert-to-ciphertext-semantics
+# does not support dynamic extraction indices from ciphertexts.
 heir_lattigo_lib(
     name = "simple_sum",
     go_library_name = "simplesum",
     heir_opt_flags = [
         "--annotate-module=backend=lattigo scheme=bgv",
-        "--mlir-to-bgv=min-slot-count=1024",
+        "--mlir-to-bgv=min-slot-count=1024 unroll-fhe-kernel-loops=true",
         "--scheme-to-lattigo",
     ],
     mlir_src = "@heir//tests/Examples/common:simple_sum.mlir",

tests/Examples/lattigo/ckks/batch_matmul/BUILD

@@ -7,7 +7,7 @@ heir_lattigo_lib(
     go_library_name = "batchmatmul",
     heir_opt_flags = [
         "--annotate-module=backend=lattigo scheme=ckks",
-        "--mlir-to-ckks=min-slot-count=4096 experimental-disable-loop-unroll=true greedy-level-budget=40 first-mod-bits=60 scaling-mod-bits=50",
+        "--mlir-to-ckks=min-slot-count=4096 unroll-fhe-kernel-loops=false greedy-level-budget=40 first-mod-bits=60 scaling-mod-bits=50",
         "--scheme-to-lattigo",
     ],
     mlir_src = "@heir//tests/Examples/common:batch_matmul.mlir",

tests/Examples/lattigo/ckks/conv1d_dilated/conv1d_dilated_test.go

@@ -39,13 +39,14 @@ func TestConv1DDilated(t *testing.T) {
 	}
 
 	ct0 := Conv1d_dilated__encrypt__arg0(evaluator, params, ecd, enc, arg0)
+	ctZero := Conv1d_dilated__encrypt__zero__0(evaluator, params, ecd, enc)
 
 	startPre := time.Now()
 	filterPlains := conv1d_dilated_utils.Conv1d_dilated__preprocessing(params, ecd)
 	t.Logf("Preprocessing took %s", time.Since(startPre))
 
 	start := time.Now()
-	resultCt := Conv1d_dilated__preprocessed(evaluator, params, ecd, ct0, filterPlains)
+	resultCt := Conv1d_dilated__preprocessed(evaluator, params, ecd, ct0, ctZero, filterPlains)
 	t.Logf("Conv1d_dilated (preprocessed) took %s", time.Since(start))
 
 	result := Conv1d_dilated__decrypt__result0(evaluator, params, ecd, dec, resultCt)

tests/Examples/lattigo/ckks/conv1d_ncw_channel_padding/BUILD

@@ -8,7 +8,7 @@ heir_lattigo_lib(
     go_library_name = "conv1dncwchannelpadding",
     heir_opt_flags = [
         "--annotate-module=backend=lattigo scheme=ckks",
-        "--mlir-to-ckks=min-slot-count=1024 experimental-disable-loop-unroll=true",
+        "--mlir-to-ckks=min-slot-count=1024 unroll-fhe-kernel-loops=false",
         "--scheme-to-lattigo",
     ],
     mlir_src = "conv1d_ncw_channel_padding.mlir",

tests/Examples/lattigo/ckks/conv1d_ncw_padded/conv1d_ncw_padded_test.go

@@ -20,7 +20,8 @@ func TestConv1DPadded(t *testing.T) {
 	}
 
 	ct0 := Conv1d_ncw_padded__encrypt__arg0(evaluator, params, ecd, enc, arg0)
-	resultCt := Conv1d_ncw_padded(evaluator, params, ecd, ct0)
+	ctZero := Conv1d_ncw_padded__encrypt__zero__0(evaluator, params, ecd, enc)
+	resultCt := Conv1d_ncw_padded(evaluator, params, ecd, ct0, ctZero)
 	result := Conv1d_ncw_padded__decrypt__result0(evaluator, params, ecd, dec, resultCt)
 	errorThreshold := float64(0.05)
 	for i := range expected {

tests/Examples/lattigo/ckks/conv2d_dilated/BUILD

@@ -8,7 +8,7 @@ heir_lattigo_lib(
     go_library_name = "conv2d_dilated",
     heir_opt_flags = [
         "--annotate-module=backend=lattigo scheme=ckks",
-        "--torch-linalg-to-ckks=min-slot-count=1024 scaling-mod-bits=45 first-mod-bits=60 experimental-disable-loop-unroll=true",
+        "--torch-linalg-to-ckks=min-slot-count=1024 scaling-mod-bits=45 first-mod-bits=60 unroll-fhe-kernel-loops=false",
         "--scheme-to-lattigo",
     ],
     mlir_src = "conv2d_dilated.mlir",

tests/Examples/lattigo/ckks/conv2d_nchw_chain/conv2d_nchw_chain_test.go

@@ -63,11 +63,13 @@ func TestConv2dChain(t *testing.T) {
 	expected := conv2dNchwFchw(out1, filter2, 1, 1, 3, 3, 1, 2, 1, 1, 1, 0, 0)
 
 	ct0 := Conv2d_chain__encrypt__arg0(evaluator, params, ecd, enc, arg0)
+	ctZero0 := Conv2d_chain__encrypt__zero__0(evaluator, params, ecd, enc)
+	ctZero1 := Conv2d_chain__encrypt__zero__1(evaluator, params, ecd, enc)
 	startPre := time.Now()
 	filterPlains := conv2dnchwchain_utils.Conv2d_chain__preprocessing(params, ecd)
 	t.Logf("Preprocessing took %s", time.Since(startPre))
 	start := time.Now()
-	resultCt := Conv2d_chain__preprocessed(evaluator, params, ecd, ct0, filterPlains)
+	resultCt := Conv2d_chain__preprocessed(evaluator, params, ecd, ct0, ctZero0, ctZero1, filterPlains)
 	t.Logf("Conv2d chain (preprocessed) took %s", time.Since(start))
 	result := Conv2d_chain__decrypt__result0(evaluator, params, ecd, dec, resultCt)
 	errorThreshold := float64(0.01)

tests/Examples/lattigo/ckks/conv2d_nchw_channel_padding/conv2d_nchw_channel_padding_test.go

@@ -65,11 +65,12 @@ func TestConv2dChannelPadding(t *testing.T) {
 	expected := conv2dNchwFchw(arg0, filter, 1, 1, 4, 4, 3, 2, 2, 2, 2)
 
 	ct0 := Conv2d_channel_pad__encrypt__arg0(evaluator, params, ecd, enc, arg0)
+	ctZero := Conv2d_channel_pad__encrypt__zero__0(evaluator, params, ecd, enc)
 	startPre := time.Now()
 	filterPlains := conv2dnchwchannelpadding_utils.Conv2d_channel_pad__preprocessing(params, ecd)
 	t.Logf("Preprocessing took %s", time.Since(startPre))
 	start := time.Now()
-	resultCt := Conv2d_channel_pad__preprocessed(evaluator, params, ecd, ct0, filterPlains)
+	resultCt := Conv2d_channel_pad__preprocessed(evaluator, params, ecd, ct0, ctZero, filterPlains)
 	t.Logf("Conv2d (preprocessed) took %s", time.Since(start))
 	result := Conv2d_channel_pad__decrypt__result0(evaluator, params, ecd, dec, resultCt)
 

tests/Examples/lattigo/ckks/conv2d_nchw_padded/BUILD

@@ -8,7 +8,7 @@ heir_lattigo_lib(
     go_library_name = "conv2dnchwpadded",
     heir_opt_flags = [
         "--annotate-module=backend=lattigo scheme=ckks",
-        "--mlir-to-ckks=min-slot-count=1024 greedy-modulus-switch-after-mul=true experimental-disable-loop-unroll=true",
+        "--mlir-to-ckks=min-slot-count=1024 greedy-modulus-switch-after-mul=true unroll-fhe-kernel-loops=false",
         "--scheme-to-lattigo",
     ],
     mlir_src = "@heir//tests/Examples/common:conv2d_nchw_padded.mlir",

tests/Examples/lattigo/ckks/conv2d_nchw_tall_1/conv2d_nchw_tall_1_test.go

@@ -23,7 +23,8 @@ func TestConv2D(t *testing.T) {
 	}
 
 	ct0 := Conv2d_nchw__encrypt__arg0(evaluator, params, ecd, enc, arg0)
-	resultCt := Conv2d_nchw(evaluator, params, ecd, ct0)
+	ctZero := Conv2d_nchw__encrypt__zero__0(evaluator, params, ecd, enc)
+	resultCt := Conv2d_nchw(evaluator, params, ecd, ct0, ctZero)
 	result := Conv2d_nchw__decrypt__result0(evaluator, params, ecd, dec, resultCt)
 	errorThreshold := float64(0.5)
 	for i := 0; i < 32; i++ {

tests/Examples/lattigo/ckks/conv2d_nchw_tall_2/conv2d_nchw_tall_2_test.go

@@ -23,7 +23,8 @@ func TestConv2D(t *testing.T) {
 	}
 
 	ct0 := Conv2d_nchw__encrypt__arg0(evaluator, params, ecd, enc, arg0)
-	resultCt := Conv2d_nchw(evaluator, params, ecd, ct0)
+	ctZero := Conv2d_nchw__encrypt__zero__0(evaluator, params, ecd, enc)
+	resultCt := Conv2d_nchw(evaluator, params, ecd, ct0, ctZero)
 	result := Conv2d_nchw__decrypt__result0(evaluator, params, ecd, dec, resultCt)
 	errorThreshold := float64(0.5)
 	for i := 0; i < 128; i++ {

tests/Examples/lattigo/ckks/conv_pool_fusion/BUILD

@@ -8,7 +8,7 @@ heir_lattigo_lib(
     go_library_name = "conv_pool_fusion",
     heir_opt_flags = [
         "--annotate-module=backend=lattigo scheme=ckks",
-        "--torch-linalg-to-ckks=min-slot-count=4096 greedy-modulus-switch-after-mul=true experimental-disable-loop-unroll=true",
+        "--torch-linalg-to-ckks=min-slot-count=4096 greedy-modulus-switch-after-mul=true unroll-fhe-kernel-loops=false",
         "--scheme-to-lattigo",
     ],
     mlir_src = "conv_pool_fusion.mlir",

tests/Examples/lattigo/ckks/lola/lola_test.go

@@ -61,14 +61,17 @@ func TestLoLA(t *testing.T) {
 	}
 
 	ct0 := Lola__encrypt__arg0(evaluator, params, ecd, enc, arg0)
+	ctZero0 := Lola__encrypt__zero__0(evaluator, params, ecd, enc)
+	ctZero1 := Lola__encrypt__zero__1(evaluator, params, ecd, enc)
+	ctZero2 := Lola__encrypt__zero__2(evaluator, params, ecd, enc)
 
 	// The embedded constant weights are encoded into plaintexts once, up front.
 	startPre := time.Now()
 	weightPlains := lola_utils.Lola__preprocessing(params, ecd)
 	t.Logf("Lola__preprocessing took %s", time.Since(startPre))
 
 	start := time.Now()
-	resultCt := Lola__preprocessed(evaluator, params, ecd, ct0, weightPlains)
+	resultCt := Lola__preprocessed(evaluator, params, ecd, ct0, ctZero0, ctZero1, ctZero2, weightPlains)
 	t.Logf("Lola__preprocessed took %s", time.Since(start))
 
 	result := Lola__decrypt__result0(evaluator, params, ecd, dec, resultCt)

tests/Examples/lattigo/ckks/matvec_512x784/BUILD

@@ -8,7 +8,7 @@ heir_lattigo_lib(
     go_library_name = "matvec512x784",
     heir_opt_flags = [
         "--annotate-module=backend=lattigo scheme=ckks",
-        "--mlir-to-ckks=min-slot-count=1024 greedy-modulus-switch-after-mul=true experimental-disable-loop-unroll=true greedy-level-budget=40 first-mod-bits=55",
+        "--mlir-to-ckks=min-slot-count=1024 greedy-modulus-switch-after-mul=true unroll-fhe-kernel-loops=false greedy-level-budget=40 first-mod-bits=55",
         "--scheme-to-lattigo",
     ],
     mlir_src = "@heir//tests/Examples/common:matvec_512x784.mlir",

tests/Examples/lattigo/ckks/matvec_square/BUILD

@@ -8,7 +8,7 @@ heir_lattigo_lib(
     go_library_name = "matvec512x512",
     heir_opt_flags = [
         "--annotate-module=backend=lattigo scheme=ckks",
-        "--mlir-to-ckks=min-slot-count=1024 greedy-modulus-switch-after-mul=true experimental-disable-loop-unroll=true greedy-level-budget=40 first-mod-bits=55",
+        "--mlir-to-ckks=min-slot-count=1024 greedy-modulus-switch-after-mul=true unroll-fhe-kernel-loops=false greedy-level-budget=40 first-mod-bits=55",
         "--scheme-to-lattigo",
     ],
     mlir_src = "@heir//tests/Examples/common:matvec_512x512.mlir",

tests/Examples/lattigo/ckks/mnist/BUILD

@@ -8,7 +8,7 @@ heir_lattigo_lib(
     go_library_name = "mnist",
     heir_opt_flags = [
         "--annotate-module=backend=lattigo scheme=ckks",
-        "--torch-linalg-to-ckks=min-slot-count=1024 greedy-modulus-switch-after-mul=true experimental-disable-loop-unroll=true greedy-level-budget=40 first-mod-bits=55",
+        "--torch-linalg-to-ckks=min-slot-count=1024 greedy-modulus-switch-after-mul=true unroll-fhe-kernel-loops=false greedy-level-budget=40 first-mod-bits=55",
         "--scheme-to-lattigo",
     ],
     mlir_src = "@heir//tests/Examples/common/mnist:mnist.mlir",

tests/Examples/lattigo/ckks/pooling/pooling_test.go

@@ -59,13 +59,14 @@ func TestPooling(t *testing.T) {
 	}
 
 	ct0 := Pooling__encrypt__arg0(evaluator, params, ecd, enc, arg0)
+	ctZero := Pooling__encrypt__zero__0(evaluator, params, ecd, enc)
 
 	startPre := time.Now()
 	filterPlains := pooling_utils.Pooling__preprocessing(params, ecd)
 	t.Logf("Preprocessing took %s", time.Since(startPre))
 
 	start := time.Now()
-	resultCt := Pooling__preprocessed(evaluator, params, ecd, ct0, filterPlains)
+	resultCt := Pooling__preprocessed(evaluator, params, ecd, ct0, ctZero, filterPlains)
 	t.Logf("Pooling (preprocessed) took %s", time.Since(start))
 
 	result := Pooling__decrypt__result0(evaluator, params, ecd, dec, resultCt)

tests/Examples/lattigo/ckks/pooling1d/pooling1d_test.go

@@ -53,13 +53,14 @@ func TestPooling(t *testing.T) {
 	}
 
 	ct0 := Pooling1d__encrypt__arg0(evaluator, params, ecd, enc, arg0)
+	ctZero := Pooling1d__encrypt__zero__0(evaluator, params, ecd, enc)
 
 	startPre := time.Now()
 	filterPlains := pooling1d_utils.Pooling1d__preprocessing(params, ecd)
 	t.Logf("Preprocessing took %s", time.Since(startPre))
 
 	start := time.Now()
-	resultCt := Pooling1d__preprocessed(evaluator, params, ecd, ct0, filterPlains)
+	resultCt := Pooling1d__preprocessed(evaluator, params, ecd, ct0, ctZero, filterPlains)
 	t.Logf("Pooling1d (preprocessed) took %s", time.Since(start))
 
 	result := Pooling1d__decrypt__result0(evaluator, params, ecd, dec, resultCt)

tests/Examples/openfhe/bgv/box_blur/BUILD

@@ -4,12 +4,14 @@ load("@heir//tests/Examples/openfhe:test.bzl", "openfhe_end_to_end_test")
 
 package(default_applicable_licenses = ["@heir//:license"])
 
+# TODO(#2257): Loop unrolling is required because convert-to-ciphertext-semantics
+# does not support dynamic extraction indices from ciphertexts.
 openfhe_end_to_end_test(
     name = "box_blur_16x16_test",
     generated_lib_header = "box_blur_16x16_lib.h",
     heir_opt_flags = [
         "--annotate-module=backend=openfhe scheme=bgv",
-        "--mlir-to-bgv=plaintext-modulus=786433",
+        "--mlir-to-bgv=plaintext-modulus=786433 unroll-fhe-kernel-loops=true",
         "--scheme-to-openfhe",
     ],
     mlir_src = "@heir//tests/Examples/common:box_blur_16x16.mlir",

tests/Examples/openfhe/bgv/roberts_cross/BUILD

@@ -4,12 +4,14 @@ load("@heir//tests/Examples/openfhe:test.bzl", "openfhe_end_to_end_test")
 
 package(default_applicable_licenses = ["@heir//:license"])
 
+# TODO(#2257): Loop unrolling is required because convert-to-ciphertext-semantics
+# does not support dynamic extraction indices from ciphertexts.
 openfhe_end_to_end_test(
     name = "roberts_cross_16x16_test",
     generated_lib_header = "roberts_cross_16x16_lib.h",
     heir_opt_flags = [
         "--annotate-module=backend=openfhe scheme=bgv",
-        "--mlir-to-bgv=min-slot-count=4096 plaintext-modulus=536903681",
+        "--mlir-to-bgv=min-slot-count=4096 plaintext-modulus=536903681 unroll-fhe-kernel-loops=true",
         "--scheme-to-openfhe",
     ],
     mlir_src = "@heir//tests/Examples/common:roberts_cross_16x16.mlir",

tests/Examples/openfhe/bgv/simple_sum/BUILD

@@ -4,12 +4,14 @@ load("@heir//tests/Examples/openfhe:test.bzl", "openfhe_end_to_end_test")
 
 package(default_applicable_licenses = ["@heir//:license"])
 
+# TODO(#2257): Loop unrolling is required because convert-to-ciphertext-semantics
+# does not support dynamic extraction indices from ciphertexts.
 openfhe_end_to_end_test(
     name = "simple_sum_test",
     generated_lib_header = "simple_sum_lib.h",
     heir_opt_flags = [
         "--annotate-module=backend=openfhe scheme=bgv",
-        "--mlir-to-bgv=min-slot-count=8192",
+        "--mlir-to-bgv=min-slot-count=8192 unroll-fhe-kernel-loops=true",
         "--scheme-to-openfhe",
     ],
     mlir_src = "@heir//tests/Examples/common:simple_sum.mlir",

tests/Examples/openfhe/ckks/batch_matmul/BUILD

@@ -7,7 +7,7 @@ openfhe_end_to_end_test(
     generated_lib_header = "batch_matmul_lib.h",
     heir_opt_flags = [
         "--annotate-module=backend=openfhe scheme=ckks",
-        "--mlir-to-ckks=min-slot-count=4096 experimental-disable-loop-unroll=true greedy-level-budget=10 first-mod-bits=60 scaling-mod-bits=50",
+        "--mlir-to-ckks=min-slot-count=4096 unroll-fhe-kernel-loops=false greedy-level-budget=10 first-mod-bits=60 scaling-mod-bits=50",
         "--scheme-to-openfhe",
     ],
     mlir_src = "@heir//tests/Examples/common:batch_matmul.mlir",

tests/Examples/openfhe/ckks/conv_1d/conv_1d_test.cpp

@@ -27,8 +27,9 @@ TEST(Conv1DTest, RunTest) {
 
   auto ctEncrypted =
       conv_1d__encrypt__arg0(cryptoContext, m, keyPair.publicKey);
+  auto ctZero = conv_1d__encrypt__zero__0(cryptoContext, keyPair.publicKey);
 
-  auto result = conv_1d(cryptoContext, ctEncrypted, filter);
+  auto result = conv_1d(cryptoContext, ctEncrypted, filter, ctZero);
 
   auto actual =
       conv_1d__decrypt__result0(cryptoContext, result, keyPair.secretKey);