Struct CudaCompressedCiphertextList 

pub struct CudaCompressedCiphertextList { /* private fields */ }

Implementations

impl CudaCompressedCiphertextList

pub fn gpu_indexes(&self) -> &[GpuIndex]

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn get_kind_of(&self, index: usize) -> Option<DataKind>

pub fn get<T>( &self, index: usize, decomp_key: &CudaDecompressionKey, streams: &CudaStreams, ) -> Result<Option<T>>

where T: CudaExpandable,

pub fn get_decompression_size_on_gpu( &self, index: usize, decomp_key: &CudaDecompressionKey, streams: &CudaStreams, ) -> Option<u64>

pub fn to_compressed_ciphertext_list( &self, streams: &CudaStreams, ) -> CompressedCiphertextList

 use tfhe::core_crypto::gpu::CudaStreams;
use tfhe::integer::gpu::ciphertext::boolean_value::CudaBooleanBlock;
use tfhe::integer::gpu::ciphertext::compressed_ciphertext_list::CudaCompressedCiphertextListBuilder;
use tfhe::integer::gpu::ciphertext::{CudaSignedRadixCiphertext, CudaUnsignedRadixCiphertext};
use tfhe::integer::gpu::gen_keys_radix_gpu;
use tfhe::shortint::parameters::{
    PARAM_GPU_MULTI_BIT_GROUP_4_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M128,
    COMP_PARAM_GPU_MULTI_BIT_GROUP_4_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M128
};

let block_params = PARAM_GPU_MULTI_BIT_GROUP_4_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M128;
let compression_params = COMP_PARAM_GPU_MULTI_BIT_GROUP_4_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M128;
let num_blocks = 32;
let streams = CudaStreams::new_multi_gpu();

let (radix_cks, _) = gen_keys_radix_gpu(block_params,
    num_blocks,
    &streams,
);
let cks = radix_cks.as_ref();

let private_compression_key =
cks.new_compression_private_key(compression_params);

let (cuda_compression_key, cuda_decompression_key) =
radix_cks.new_cuda_compression_decompression_keys(&private_compression_key, &streams);

let private_compression_key =
    cks.new_compression_private_key(compression_params);

let (compressed_compression_key, compressed_decompression_key) =
    radix_cks.new_compressed_compression_decompression_keys(&private_compression_key);

let cuda_compression_key = compressed_compression_key.decompress_to_cuda(&streams);

let compression_key = compressed_compression_key.decompress();
let decompression_key = compressed_decompression_key.decompress();

let ct1 = radix_cks.encrypt(3_u32);
let ct2 = radix_cks.encrypt_signed(-2);
let ct3 = radix_cks.encrypt_bool(true);

// Copy to GPU
let d_ct1 = CudaUnsignedRadixCiphertext::from_radix_ciphertext(&ct1, &streams);
let d_ct2 = CudaSignedRadixCiphertext::from_signed_radix_ciphertext(&ct2, &streams);
let d_ct3 = CudaBooleanBlock::from_boolean_block(&ct3, &streams);

let cuda_compressed = CudaCompressedCiphertextListBuilder::new()
    .push(d_ct1, &streams)
    .push(d_ct2, &streams)
    .push(d_ct3, &streams)
    .build(&cuda_compression_key, &streams);

let converted_compressed = cuda_compressed.to_compressed_ciphertext_list(&streams);

pub fn duplicate(&self, streams: &CudaStreams) -> Self

Trait Implementations

impl Clone for CudaCompressedCiphertextList

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'de> Deserialize<'de> for CudaCompressedCiphertextList

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for CudaCompressedCiphertextList

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.