goroutines for bootstrapping

[JohnJimAir]

Hello, I want to use goroutines to accelerate my program. Is there anything wrong in the code below?

cts := []*rlwe.Ciphertext{ct1, ct2}
for i:=0;i<len(cts);i++ {
	myfunctions.PrintScaleAndLevel(cts[i])
}

var wg sync.WaitGroup
for i:=0;i<len(cts);i++ {
	wg.Add(1)
	go func(i int) {
		defer wg.Done()
		eval_boot := eval_boot.ShallowCopy()
		cts[i], err = eval_boot.Bootstrap(cts[i])
		fmt.Println("pppppppppppppppp")
	}(i)
}
wg.Wait()
fmt.Println("00000000000000000000000")
for i:=0;i<len(cts);i++ {
	fmt.Println(op[i].Slots())
}

It says: panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x2 addr=0x10 pc=0x101175e78]
for last line "fmt.Println(op[i].Slots()) "

thanks!

[JohnJimAir]

but when there is only one element in cts, it works well

[JohnJimAir]

panic the err in "cts[i], err = eval_boot.Bootstrap(cts[i])",it says: "panic: cannot BootstrapMany: cannot PackAndSwitchN1ToN2: PackN2: cannot Pack: cts[0].Value[0].N()=8192 != params.N()=1"

[JohnJimAir]

add "fmt.Println(eval_boot.BootstrappingParameters.N())" after "eval_boot := eval_boot.ShallowCopy()", it prints out "1". So it seems that the ShallowCopy() miss something to copy.

[Pro7ech]

@yiquedexianshi If you believe there is a bug, please open an bug related issue and follow the steps

[JohnJimAir]

Sorry, "op" is just "cts". At beginning, I used a very casual name "op". For the code to be better understood, when I open this discussion I changed the name to "cts", but I missed the last one.
Never mind, it is not relevant. Because when panic the err in an IF statement after "cts[i], err = eval_boot.Bootstrap(cts[i])", the program will be terminated at this point and saying: "panic: cannot BootstrapMany: cannot PackAndSwitchN1ToN2: PackN2: cannot Pack: cts[0].Value[0].N()=8192 != params.N()=1", as mentioned in the reply followed.
I will paste a complete code next day, but It just add some initializations such as params initialization, and some trivial operations to consume one level of "ct1" and "ct2" at the beginning,.
Thank you!

[Pro7ech]

Looking forward to!

[JohnJimAir]

package main

import (
	"flag"
	"fmt"
	"sync"

	"github.com/tuneinsight/lattigo/v5/core/rlwe"
	"github.com/tuneinsight/lattigo/v5/he/hefloat"
	"github.com/tuneinsight/lattigo/v5/he/hefloat/bootstrapping"
	"github.com/tuneinsight/lattigo/v5/ring"
	"github.com/tuneinsight/lattigo/v5/utils"
)

var flagShort = flag.Bool("short", false, "run the example with a smaller and insecure ring degree.")

func main() {

	var err error

	flag.Parse()
	LogN := 16
	if *flagShort {
		LogN -= 3
	}
	
	var params hefloat.Parameters
	if params, err = hefloat.NewParametersFromLiteral(
		hefloat.ParametersLiteral{
			LogN:            LogN,                                              // Log2 of the ring degree
			LogQ:            []int{55, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40}, // Log2 of the ciphertext prime moduli
			LogP:            []int{61, 61, 61},                                 // Log2 of the key-switch auxiliary prime moduli
			LogDefaultScale: 40,                                                // Log2 of the scale
			Xs:              ring.Ternary{H: 192},
			RingType:        0,
		}); err != nil {
		panic(err)
	}
	kgen := rlwe.NewKeyGenerator(params)
	sk, pk := kgen.GenKeyPairNew()
	rlk := kgen.GenRelinearizationKeyNew(sk)
	evk := rlwe.NewMemEvaluationKeySet(rlk)

	encoder := hefloat.NewEncoder(params)
	encryptor := rlwe.NewEncryptor(params, pk)
	// decryptor := rlwe.NewDecryptor(params, sk)
	eval := hefloat.NewEvaluator(params, evk)

	// LogSlots := params.LogMaxSlots()
	// Slots := 1 << LogSlots


	fmt.Printf("============================\n")
	fmt.Printf("GENERATE BOOTSTRAP EVALUATOR\n")
	fmt.Printf("============================\n")

	btpParametersLit := bootstrapping.ParametersLiteral{
		// We specify LogN to ensure that both the residual parameters and the bootstrapping parameters
		// have the same LogN. This is not required, but we want it for this example.
		LogN: utils.Pointy(LogN), 
		// In this example we need manually specify the number of auxiliary primes (i.e. #Pi) used by the
		// evaluation keys of the bootstrapping circuit, so that the size of LogQP  meets the security target.
		LogP: []int{61, 61, 61, 61},
		// In this example we manually specify the bootstrapping parameters' secret distribution.
		// This is not necessary, but we ensure here that they are the same as the residual parameters.
		Xs: params.Xs(),
	}
	btpParams, err := bootstrapping.NewParametersFromLiteral(params, btpParametersLit)
	if err != nil {
		panic(err)
	}
	
	fmt.Println("Generating bootstrapping evaluation keys...")
	evk_boot, _, err := btpParams.GenEvaluationKeys(sk)
	if err != nil {
		panic(err)
	}
	fmt.Println("Done")
	var eval_boot *bootstrapping.Evaluator
	if eval_boot, err = bootstrapping.NewEvaluator(btpParams, evk_boot); err != nil {
		panic(err)
	}

	fmt.Printf("============================\n")
	// get three simple ciphertexts
	ct0_values := make([]float64, params.MaxSlots())
	for i := 0; i < len(ct0_values); i++ {
		ct0_values[i] = 0.6
	}
	ct0_pt := hefloat.NewPlaintext(params, params.MaxLevel())
	if err = encoder.Encode(ct0_values, ct0_pt); err != nil {
		panic(err)
	}
	ct0_ct, err := encryptor.EncryptNew(ct0_pt)
	if err != nil {
		panic(err)
	}

	ct1_values := make([]float64, params.MaxSlots())
	for i := 0; i < len(ct1_values); i++ {
		ct1_values[i] = 2.4
	}
	ct1_pt := hefloat.NewPlaintext(params, params.MaxLevel())
	if err = encoder.Encode(ct1_values, ct1_pt); err != nil {
		panic(err)
	}
	ct1_ct, err := encryptor.EncryptNew(ct1_pt)
	if err != nil {
		panic(err)
	}

	ct2_values := make([]float64, params.MaxSlots())
	for i := 0; i < len(ct2_values); i++ {
		ct2_values[i] = 5.4
	}
	ct2_pt := hefloat.NewPlaintext(params, params.MaxLevel())
	if err = encoder.Encode(ct2_values, ct2_pt); err != nil {
		panic(err)
	}
	ct2_ct, err := encryptor.EncryptNew(ct2_pt)
	if err != nil {
		panic(err)
	}

	// multiply with ct0_ct to consume one level
	ct1_ct, err = eval.MulRelinNew(ct1_ct, ct0_ct)
	if err != nil {
		panic(err)
	}
	if err = eval.Rescale(ct1_ct, ct1_ct); err != nil {  
		panic(err)
	}

	ct2_ct, err = eval.MulRelinNew(ct2_ct, ct0_ct)
	if err != nil {
		panic(err)
	}
	if err = eval.Rescale(ct2_ct, ct2_ct); err != nil {
		panic(err)
	}

	// use goroutines to bootstrap in parallel
	cts := []*rlwe.Ciphertext{ct1_ct, ct2_ct}
	for i:=0;i<len(cts);i++ {
		fmt.Println(cts[i].Level())
	}
	var wg sync.WaitGroup
	for i:=0;i<len(cts);i++ {
		wg.Add(1)
		go func(i int) {
			defer wg.Done()
			eval_boot := eval_boot.ShallowCopy()
			fmt.Println(eval_boot.BootstrappingParameters.N())
			cts[i], err = eval_boot.Bootstrap(cts[i])
			if err != nil {
				panic(err)
			}
			fmt.Println("pppppppppppppppp")
		}(i)
	}
	wg.Wait()
	fmt.Println("00000000000000000000000")
	for i:=0;i<len(cts);i++ {
		fmt.Println(cts[i].Level())
		fmt.Println(cts[i].Slots())
	}	

}

Here is the complete code. You can copy this complete code and run it in your own computer.
In my computer, this program terminates at "panic(err)" after "cts[i], err = eval_boot.Bootstrap(cts[i])", saying "panic: cannot BootstrapMany: cannot PackAndSwitchN1ToN2: PackN2: cannot Pack: cts[0].Value[0].N()=8192 != params.N()=1".
Get the same error with or withnot "-short" flag, except that "8192" in "cannot Pack: cts[0].Value[0].N()=8192 != params.N()=1" changes to "65536".

[Pro7ech]

There is indeed a bug in the shallow copy, I'll open an issue and a PR with a fix

[Pro7ech]

This should fix it: #438