Skip to content

Bit packing serialization #758

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
James Ryan Carr (jryancarr) wants to merge 11 commits into
base: contrib
Choose a base branch
from
Open

Bit packing serialization #758

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
11 commits
Select commit Hold shift + click to select a range
1f7f120
Add bit-packing serialization mode (compr_mode_type::bitpack).
jryancarr Aug 3, 2026
a02e9a8
Replace bitpack format description with ASCII diagrams.
jryancarr Aug 3, 2026
33d0e4c
Make the bitpack block size part of the encoded stream; default to 10…
jryancarr Aug 3, 2026
0474ef8
Express the phase bound as bytes_per_word - 1 instead of a literal 7.
jryancarr Aug 4, 2026
346b72f
Document and test tiny-block phase handling.
jryancarr Aug 4, 2026
a8845f0
rewrite bitpack overview
jryancarr Aug 6, 2026
fc3dff8
minor doc edits
jryancarr Aug 6, 2026
742e571
More tests, continued to edit docs
jryancarr Aug 6, 2026
3655d11
New benchmarks
jryancarr Aug 6, 2026
b447806
Address review: document no-integrity-checking, add key round-trip te…
jryancarr Aug 6, 2026
26e961f
More small doc changes
jryancarr Aug 7, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
6 changes: 5 additions & 1 deletion dotnet/src/Serialization.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -25,7 +25,11 @@ public enum ComprModeType : byte
ZLIB = 1,

/// <summary>Use Zstandard compression.</summary>
ZSTD = 2
ZSTD = 2,

/// <summary>Use bit-packing compression. Unlike ZLIB and Zstandard, bit-packing performs no
/// integrity checking of the data.</summary>
BitPack = 3
}

/// <summary>Class to provide functionality for serialization.</summary>
Expand Down
38 changes: 38 additions & 0 deletions dotnet/tests/CiphertextTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -221,6 +221,44 @@ public void BFVSaveLoadTest()
}
}

[TestMethod]
public void BFVBitPackSaveLoadTest()
{
SEALContext context = GlobalContext.BFVContext;
KeyGenerator keygen = new KeyGenerator(context);
keygen.CreatePublicKey(out PublicKey publicKey);

Encryptor encryptor = new Encryptor(context, publicKey);
Plaintext plain = new Plaintext("2x^3 + 4x^2 + 5x^1 + 6");
Ciphertext cipher = new Ciphertext();

encryptor.Encrypt(plain, cipher);

Ciphertext loaded = new Ciphertext();
long saveSize = 0;

using (MemoryStream mem = new MemoryStream())
{
saveSize = cipher.Save(mem, ComprModeType.BitPack);

mem.Seek(offset: 0, loc: SeekOrigin.Begin);

loaded.Load(context, mem);
}

Assert.IsTrue(ValCheck.IsValidFor(loaded, context));

ulong ulongCount = cipher.Size * cipher.PolyModulusDegree * cipher.CoeffModulusSize;
for (ulong i = 0; i < ulongCount; i++)
{
Assert.AreEqual(cipher[i], loaded[i]);
}

// The coefficients are uniformly random modulo the coefficient modulus primes, which are well under
// 64 bits, so packing each 64-bit word to its significant bits must beat the unpacked size.
Assert.IsTrue(saveSize < cipher.SaveSize(ComprModeType.None));
}

[TestMethod]
public void BGVSaveLoadTest()
{
Expand Down
4 changes: 3 additions & 1 deletion dotnet/tests/SerializationTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -28,7 +28,9 @@ public void IsValidHeader()
invalidHeader.VersionMajor = 0x02;
Assert.IsFalse(Serialization.IsValidHeader(invalidHeader));
invalidHeader.VersionMajor = SEALVersion.Major;
invalidHeader.ComprMode = (ComprModeType)0x03;
invalidHeader.ComprMode = ComprModeType.BitPack;
Assert.IsTrue(Serialization.IsValidHeader(invalidHeader));
invalidHeader.ComprMode = (ComprModeType)0x04;
Assert.IsFalse(Serialization.IsValidHeader(invalidHeader));
}

Expand Down
1 change: 1 addition & 0 deletions native/bench/CMakeLists.txt
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -58,6 +58,7 @@ if(SEAL_BUILD_BENCH)
${CMAKE_CURRENT_LIST_DIR}/bench.cpp
${CMAKE_CURRENT_LIST_DIR}/keygen.cpp
${CMAKE_CURRENT_LIST_DIR}/ntt.cpp
${CMAKE_CURRENT_LIST_DIR}/serialize.cpp
${CMAKE_CURRENT_LIST_DIR}/bfv.cpp
${CMAKE_CURRENT_LIST_DIR}/bgv.cpp
${CMAKE_CURRENT_LIST_DIR}/ckks.cpp
Expand Down
143 changes: 143 additions & 0 deletions native/bench/bench.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -129,6 +129,7 @@ namespace sealbench
// 3. BGV
// 4. CKKS
// 5. Util
// 6. Serialize
int n = static_cast<int>(parms.first);
int log_q = static_cast<int>(
bm_env_map.find(parms_ckks)->second->context().key_context_data()->total_coeff_modulus_bit_count());
Expand Down Expand Up @@ -224,6 +225,148 @@ namespace sealbench
SEAL_BENCHMARK_REGISTER(UTIL, n, 0, NTTInverseLowLevel, bm_util_ntt_inverse_low_level, bm_env_bfv);
SEAL_BENCHMARK_REGISTER(UTIL, n, 0, NTTForwardLowLevelLazy, bm_util_ntt_forward_low_level_lazy, bm_env_bfv);
SEAL_BENCHMARK_REGISTER(UTIL, n, 0, NTTInverseLowLevelLazy, bm_util_ntt_inverse_low_level_lazy, bm_env_bfv);

// Serialization cases save and load a ciphertext (per scheme) and the keys under each supported
// compression mode, reporting the serialized size in bytes as the counter "size". Keys have the same
// size and content shape in every scheme, so they are registered once, under the BFV environment. Note
// that the Galois keys here contain two elements; full rotation key sets scale the numbers linearly.
#define SEAL_BENCHMARK_REGISTER_SERIALIZE(name, func, env, mode) \
SEAL_BENCHMARK_REGISTER(SERIALIZE, n, log_q, name, func, env, seal::compr_mode_type::mode)

SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveCiphertextBFVNone, bm_serialize_save_ct, bm_env_bfv, none);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadCiphertextBFVNone, bm_serialize_load_ct, bm_env_bfv, none);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveCiphertextBGVNone, bm_serialize_save_ct, bm_env_bgv, none);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadCiphertextBGVNone, bm_serialize_load_ct, bm_env_bgv, none);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveCiphertextCKKSNone, bm_serialize_save_ct, bm_env_ckks, none);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadCiphertextCKKSNone, bm_serialize_load_ct, bm_env_ckks, none);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SavePublicKeyNone, bm_serialize_save_pk, bm_env_bfv, none);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadPublicKeyNone, bm_serialize_load_pk, bm_env_bfv, none);
#ifdef SEAL_USE_ZLIB
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveCiphertextBFVZlib, bm_serialize_save_ct, bm_env_bfv, zlib);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadCiphertextBFVZlib, bm_serialize_load_ct, bm_env_bfv, zlib);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveCiphertextBGVZlib, bm_serialize_save_ct, bm_env_bgv, zlib);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadCiphertextBGVZlib, bm_serialize_load_ct, bm_env_bgv, zlib);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveCiphertextCKKSZlib, bm_serialize_save_ct, bm_env_ckks, zlib);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadCiphertextCKKSZlib, bm_serialize_load_ct, bm_env_ckks, zlib);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SavePublicKeyZlib, bm_serialize_save_pk, bm_env_bfv, zlib);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadPublicKeyZlib, bm_serialize_load_pk, bm_env_bfv, zlib);
#endif
#ifdef SEAL_USE_ZSTD
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveCiphertextBFVZstd, bm_serialize_save_ct, bm_env_bfv, zstd);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadCiphertextBFVZstd, bm_serialize_load_ct, bm_env_bfv, zstd);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveCiphertextBGVZstd, bm_serialize_save_ct, bm_env_bgv, zstd);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadCiphertextBGVZstd, bm_serialize_load_ct, bm_env_bgv, zstd);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveCiphertextCKKSZstd, bm_serialize_save_ct, bm_env_ckks, zstd);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadCiphertextCKKSZstd, bm_serialize_load_ct, bm_env_ckks, zstd);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SavePublicKeyZstd, bm_serialize_save_pk, bm_env_bfv, zstd);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadPublicKeyZstd, bm_serialize_load_pk, bm_env_bfv, zstd);
#endif
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveCiphertextBFVBitPack, bm_serialize_save_ct, bm_env_bfv, bitpack);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadCiphertextBFVBitPack, bm_serialize_load_ct, bm_env_bfv, bitpack);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveCiphertextBGVBitPack, bm_serialize_save_ct, bm_env_bgv, bitpack);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadCiphertextBGVBitPack, bm_serialize_load_ct, bm_env_bgv, bitpack);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveCiphertextCKKSBitPack, bm_serialize_save_ct, bm_env_ckks, bitpack);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadCiphertextCKKSBitPack, bm_serialize_load_ct, bm_env_ckks, bitpack);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SavePublicKeyBitPack, bm_serialize_save_pk, bm_env_bfv, bitpack);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadPublicKeyBitPack, bm_serialize_load_pk, bm_env_bfv, bitpack);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveSecretKeyNone, bm_serialize_save_sk, bm_env_bfv, none);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadSecretKeyNone, bm_serialize_load_sk, bm_env_bfv, none);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveSeededCiphertextBFVNone, bm_serialize_save_seeded_ct, bm_env_bfv, none);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadSeededCiphertextBFVNone, bm_serialize_load_seeded_ct, bm_env_bfv, none);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveSeededCiphertextBGVNone, bm_serialize_save_seeded_ct, bm_env_bgv, none);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadSeededCiphertextBGVNone, bm_serialize_load_seeded_ct, bm_env_bgv, none);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveSeededCiphertextCKKSNone, bm_serialize_save_seeded_ct, bm_env_ckks, none);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadSeededCiphertextCKKSNone, bm_serialize_load_seeded_ct, bm_env_ckks, none);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveSeededPublicKeyNone, bm_serialize_save_seeded_pk, bm_env_bfv, none);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadSeededPublicKeyNone, bm_serialize_load_seeded_pk, bm_env_bfv, none);
#ifdef SEAL_USE_ZLIB
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveSecretKeyZlib, bm_serialize_save_sk, bm_env_bfv, zlib);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadSecretKeyZlib, bm_serialize_load_sk, bm_env_bfv, zlib);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveSeededCiphertextBFVZlib, bm_serialize_save_seeded_ct, bm_env_bfv, zlib);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadSeededCiphertextBFVZlib, bm_serialize_load_seeded_ct, bm_env_bfv, zlib);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveSeededCiphertextBGVZlib, bm_serialize_save_seeded_ct, bm_env_bgv, zlib);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadSeededCiphertextBGVZlib, bm_serialize_load_seeded_ct, bm_env_bgv, zlib);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveSeededCiphertextCKKSZlib, bm_serialize_save_seeded_ct, bm_env_ckks, zlib);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadSeededCiphertextCKKSZlib, bm_serialize_load_seeded_ct, bm_env_ckks, zlib);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveSeededPublicKeyZlib, bm_serialize_save_seeded_pk, bm_env_bfv, zlib);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadSeededPublicKeyZlib, bm_serialize_load_seeded_pk, bm_env_bfv, zlib);
#endif
#ifdef SEAL_USE_ZSTD
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveSecretKeyZstd, bm_serialize_save_sk, bm_env_bfv, zstd);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadSecretKeyZstd, bm_serialize_load_sk, bm_env_bfv, zstd);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveSeededCiphertextBFVZstd, bm_serialize_save_seeded_ct, bm_env_bfv, zstd);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadSeededCiphertextBFVZstd, bm_serialize_load_seeded_ct, bm_env_bfv, zstd);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveSeededCiphertextBGVZstd, bm_serialize_save_seeded_ct, bm_env_bgv, zstd);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadSeededCiphertextBGVZstd, bm_serialize_load_seeded_ct, bm_env_bgv, zstd);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveSeededCiphertextCKKSZstd, bm_serialize_save_seeded_ct, bm_env_ckks, zstd);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadSeededCiphertextCKKSZstd, bm_serialize_load_seeded_ct, bm_env_ckks, zstd);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveSeededPublicKeyZstd, bm_serialize_save_seeded_pk, bm_env_bfv, zstd);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadSeededPublicKeyZstd, bm_serialize_load_seeded_pk, bm_env_bfv, zstd);
#endif
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveSecretKeyBitPack, bm_serialize_save_sk, bm_env_bfv, bitpack);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadSecretKeyBitPack, bm_serialize_load_sk, bm_env_bfv, bitpack);
SEAL_BENCHMARK_REGISTER_SERIALIZE(
SaveSeededCiphertextBFVBitPack, bm_serialize_save_seeded_ct, bm_env_bfv, bitpack);
SEAL_BENCHMARK_REGISTER_SERIALIZE(
LoadSeededCiphertextBFVBitPack, bm_serialize_load_seeded_ct, bm_env_bfv, bitpack);
SEAL_BENCHMARK_REGISTER_SERIALIZE(
SaveSeededCiphertextBGVBitPack, bm_serialize_save_seeded_ct, bm_env_bgv, bitpack);
SEAL_BENCHMARK_REGISTER_SERIALIZE(
LoadSeededCiphertextBGVBitPack, bm_serialize_load_seeded_ct, bm_env_bgv, bitpack);
SEAL_BENCHMARK_REGISTER_SERIALIZE(
SaveSeededCiphertextCKKSBitPack, bm_serialize_save_seeded_ct, bm_env_ckks, bitpack);
SEAL_BENCHMARK_REGISTER_SERIALIZE(
LoadSeededCiphertextCKKSBitPack, bm_serialize_load_seeded_ct, bm_env_ckks, bitpack);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveSeededPublicKeyBitPack, bm_serialize_save_seeded_pk, bm_env_bfv, bitpack);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadSeededPublicKeyBitPack, bm_serialize_load_seeded_pk, bm_env_bfv, bitpack);
if (bm_env_bfv->context().using_keyswitching())
{
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveRelinKeysNone, bm_serialize_save_rlk, bm_env_bfv, none);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadRelinKeysNone, bm_serialize_load_rlk, bm_env_bfv, none);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveGaloisKeysNone, bm_serialize_save_glk, bm_env_bfv, none);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadGaloisKeysNone, bm_serialize_load_glk, bm_env_bfv, none);
#ifdef SEAL_USE_ZLIB
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveRelinKeysZlib, bm_serialize_save_rlk, bm_env_bfv, zlib);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadRelinKeysZlib, bm_serialize_load_rlk, bm_env_bfv, zlib);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveGaloisKeysZlib, bm_serialize_save_glk, bm_env_bfv, zlib);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadGaloisKeysZlib, bm_serialize_load_glk, bm_env_bfv, zlib);
#endif
#ifdef SEAL_USE_ZSTD
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveRelinKeysZstd, bm_serialize_save_rlk, bm_env_bfv, zstd);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadRelinKeysZstd, bm_serialize_load_rlk, bm_env_bfv, zstd);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveGaloisKeysZstd, bm_serialize_save_glk, bm_env_bfv, zstd);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadGaloisKeysZstd, bm_serialize_load_glk, bm_env_bfv, zstd);
#endif
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveRelinKeysBitPack, bm_serialize_save_rlk, bm_env_bfv, bitpack);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadRelinKeysBitPack, bm_serialize_load_rlk, bm_env_bfv, bitpack);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveGaloisKeysBitPack, bm_serialize_save_glk, bm_env_bfv, bitpack);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadGaloisKeysBitPack, bm_serialize_load_glk, bm_env_bfv, bitpack);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveSeededRelinKeysNone, bm_serialize_save_seeded_rlk, bm_env_bfv, none);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadSeededRelinKeysNone, bm_serialize_load_seeded_rlk, bm_env_bfv, none);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveSeededGaloisKeysNone, bm_serialize_save_seeded_glk, bm_env_bfv, none);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadSeededGaloisKeysNone, bm_serialize_load_seeded_glk, bm_env_bfv, none);
#ifdef SEAL_USE_ZLIB
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveSeededRelinKeysZlib, bm_serialize_save_seeded_rlk, bm_env_bfv, zlib);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadSeededRelinKeysZlib, bm_serialize_load_seeded_rlk, bm_env_bfv, zlib);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveSeededGaloisKeysZlib, bm_serialize_save_seeded_glk, bm_env_bfv, zlib);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadSeededGaloisKeysZlib, bm_serialize_load_seeded_glk, bm_env_bfv, zlib);
#endif
#ifdef SEAL_USE_ZSTD
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveSeededRelinKeysZstd, bm_serialize_save_seeded_rlk, bm_env_bfv, zstd);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadSeededRelinKeysZstd, bm_serialize_load_seeded_rlk, bm_env_bfv, zstd);
SEAL_BENCHMARK_REGISTER_SERIALIZE(SaveSeededGaloisKeysZstd, bm_serialize_save_seeded_glk, bm_env_bfv, zstd);
SEAL_BENCHMARK_REGISTER_SERIALIZE(LoadSeededGaloisKeysZstd, bm_serialize_load_seeded_glk, bm_env_bfv, zstd);
#endif
SEAL_BENCHMARK_REGISTER_SERIALIZE(
SaveSeededRelinKeysBitPack, bm_serialize_save_seeded_rlk, bm_env_bfv, bitpack);
SEAL_BENCHMARK_REGISTER_SERIALIZE(
LoadSeededRelinKeysBitPack, bm_serialize_load_seeded_rlk, bm_env_bfv, bitpack);
SEAL_BENCHMARK_REGISTER_SERIALIZE(
SaveSeededGaloisKeysBitPack, bm_serialize_save_seeded_glk, bm_env_bfv, bitpack);
SEAL_BENCHMARK_REGISTER_SERIALIZE(
LoadSeededGaloisKeysBitPack, bm_serialize_load_seeded_glk, bm_env_bfv, bitpack);
}
#undef SEAL_BENCHMARK_REGISTER_SERIALIZE
}

} // namespace sealbench
Expand Down
35 changes: 35 additions & 0 deletions native/bench/bench.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -425,4 +425,39 @@ namespace sealbench
void bm_ckks_rescale_inplace(benchmark::State &state, std::shared_ptr<BMEnv> bm_env);
void bm_ckks_relin_inplace(benchmark::State &state, std::shared_ptr<BMEnv> bm_env);
void bm_ckks_rotate(benchmark::State &state, std::shared_ptr<BMEnv> bm_env);

/**
Benchmark cases for serialization save/load under a given compression mode. Each case reports the
serialized size in bytes as the counter "size".
*/
void bm_serialize_save_ct(benchmark::State &state, std::shared_ptr<BMEnv> bm_env, seal::compr_mode_type compr_mode);
void bm_serialize_load_ct(benchmark::State &state, std::shared_ptr<BMEnv> bm_env, seal::compr_mode_type compr_mode);
void bm_serialize_save_pk(benchmark::State &state, std::shared_ptr<BMEnv> bm_env, seal::compr_mode_type compr_mode);
void bm_serialize_load_pk(benchmark::State &state, std::shared_ptr<BMEnv> bm_env, seal::compr_mode_type compr_mode);
void bm_serialize_save_rlk(
benchmark::State &state, std::shared_ptr<BMEnv> bm_env, seal::compr_mode_type compr_mode);
void bm_serialize_load_rlk(
benchmark::State &state, std::shared_ptr<BMEnv> bm_env, seal::compr_mode_type compr_mode);
void bm_serialize_save_glk(
benchmark::State &state, std::shared_ptr<BMEnv> bm_env, seal::compr_mode_type compr_mode);
void bm_serialize_load_glk(
benchmark::State &state, std::shared_ptr<BMEnv> bm_env, seal::compr_mode_type compr_mode);
void bm_serialize_save_sk(benchmark::State &state, std::shared_ptr<BMEnv> bm_env, seal::compr_mode_type compr_mode);
void bm_serialize_load_sk(benchmark::State &state, std::shared_ptr<BMEnv> bm_env, seal::compr_mode_type compr_mode);
void bm_serialize_save_seeded_ct(
benchmark::State &state, std::shared_ptr<BMEnv> bm_env, seal::compr_mode_type compr_mode);
void bm_serialize_load_seeded_ct(
benchmark::State &state, std::shared_ptr<BMEnv> bm_env, seal::compr_mode_type compr_mode);
void bm_serialize_save_seeded_pk(
benchmark::State &state, std::shared_ptr<BMEnv> bm_env, seal::compr_mode_type compr_mode);
void bm_serialize_load_seeded_pk(
benchmark::State &state, std::shared_ptr<BMEnv> bm_env, seal::compr_mode_type compr_mode);
void bm_serialize_save_seeded_rlk(
benchmark::State &state, std::shared_ptr<BMEnv> bm_env, seal::compr_mode_type compr_mode);
void bm_serialize_load_seeded_rlk(
benchmark::State &state, std::shared_ptr<BMEnv> bm_env, seal::compr_mode_type compr_mode);
void bm_serialize_save_seeded_glk(
benchmark::State &state, std::shared_ptr<BMEnv> bm_env, seal::compr_mode_type compr_mode);
void bm_serialize_load_seeded_glk(
benchmark::State &state, std::shared_ptr<BMEnv> bm_env, seal::compr_mode_type compr_mode);
} // namespace sealbench
Loading