github/concrete
1
1
Fork 0
mirror of https://github.com/zama-ai/concrete.git synced 2026-02-09 12:15:09 -05:00
Code Issues Packages Projects Releases Wiki Activity

style(test): Formatting

Browse Source
This commit is contained in:
Quentin Bourgerie
2022-02-11 14:43:35 +01:00
committed by Quentin Bourgerie
parent de66044374
commit 0439ef47da
3 changed files with 67 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files

77
compiler/tests/Support/support_unit_test.cpp
View File

@@ -8,57 +8,52 @@ namespace CL = mlir::concretelang;
TEST(Support, client_parameters_json_serde) {
mlir::concretelang::ClientParameters params0;
params0.secretKeys = {
{mlir::concretelang::SMALL_KEY, {/*.size = */ 12}},
{mlir::concretelang::BIG_KEY, {/*.size = */ 14}},
{mlir::concretelang::SMALL_KEY, {/*.size = */ 12}},
{mlir::concretelang::BIG_KEY, {/*.size = */ 14}},
};
params0.bootstrapKeys = {
{
"bsk_v0", {
/*.inputSecretKeyID = */ mlir::concretelang::SMALL_KEY,
{"bsk_v0",
{/*.inputSecretKeyID = */ mlir::concretelang::SMALL_KEY,
/*.outputSecretKeyID = */ mlir::concretelang::BIG_KEY,
/*.level = */ 1,
/*.baseLog = */ 2,
/*.k = */ 3,
/*.variance = */ 0.001
}
},{
"wtf_bsk_v0", {
/*.inputSecretKeyID = */ mlir::concretelang::BIG_KEY,
/*.outputSecretKeyID = */ mlir::concretelang::SMALL_KEY,
/*.level = */ 3,
/*.baseLog = */ 2,
/*.k = */ 1,
/*.variance = */ 0.0001,
}
},
/*.glweDimension = */ 3,
/*.variance = */ 0.001}},
{"wtf_bsk_v0",
{
/*.inputSecretKeyID = */ mlir::concretelang::BIG_KEY,
/*.outputSecretKeyID = */ mlir::concretelang::SMALL_KEY,
/*.level = */ 3,
/*.baseLog = */ 2,
/*.glweDimension = */ 1,
/*.variance = */ 0.0001,
}},
};
params0.keyswitchKeys = {
{
"ksk_v0", {
/*.inputSecretKeyID = */ mlir::concretelang::BIG_KEY,
/*.outputSecretKeyID = */ mlir::concretelang::SMALL_KEY,
/*.level = */ 1,
/*.baseLog = */ 2,
/*.variance = */ 3,
}
}
};
{"ksk_v0",
{
/*.inputSecretKeyID = */ mlir::concretelang::BIG_KEY,
/*.outputSecretKeyID = */ mlir::concretelang::SMALL_KEY,
/*.level = */ 1,
/*.baseLog = */ 2,
/*.variance = */ 3,
}}};
params0.inputs = {
{
/*.encryption = */ {{CL::SMALL_KEY, 0.01, {4}}},
/*.shape = */ {32, {1, 2, 3, 4}, 1 * 2 * 3 * 4},
},
{
/*.encryption = */ {{CL::SMALL_KEY, 0.03, {5}}},
/*.shape = */ {8, {4, 4, 4, 4}, 4 * 4 * 4 * 4},
},
{
/*.encryption = */ {{CL::SMALL_KEY, 0.01, {4}}},
/*.shape = */ {32, {1, 2, 3, 4}, 1 * 2 * 3 * 4},
},
{
/*.encryption = */ {{CL::SMALL_KEY, 0.03, {5}}},
/*.shape = */ {8, {4, 4, 4, 4}, 4 * 4 * 4 * 4},
},
};
params0.outputs = {
{
/*.encryption = */ {{CL::SMALL_KEY, 0.03, {5}}},
/*.shape = */ {8, {4, 4, 4, 4}, 4 * 4 * 4 * 4},
},
};
{
/*.encryption = */ {{CL::SMALL_KEY, 0.03, {5}}},
/*.shape = */ {8, {4, 4, 4, 4}, 4 * 4 * 4 * 4},
},
};
auto json = mlir::concretelang::toJSON(params0);
std::string jsonStr;
llvm::raw_string_ostream os(jsonStr);

63
compiler/tests/unittest/end_to_end_jit_fhelinalg.cc
View File

@@ -68,10 +68,11 @@ TEST(End2EndJit_FHELinalg, add_eint_int_term_to_term_ret_lambda_argument) {
ASSERT_EXPECTED_SUCCESS(res);
mlir::concretelang::TensorLambdaArgument<mlir::concretelang::IntLambdaArgument<>>
&resp = (*res)
->cast<mlir::concretelang::TensorLambdaArgument<
mlir::concretelang::IntLambdaArgument<>>>();
mlir::concretelang::TensorLambdaArgument<
mlir::concretelang::IntLambdaArgument<>> &resp =
(*res)
->cast<mlir::concretelang::TensorLambdaArgument<
mlir::concretelang::IntLambdaArgument<>>>();
ASSERT_EQ(resp.getDimensions().size(), (size_t)1);
ASSERT_EQ(resp.getDimensions().at(0), 4);
@@ -112,10 +113,11 @@ TEST(End2EndJit_FHELinalg,
ASSERT_EXPECTED_SUCCESS(res);
mlir::concretelang::TensorLambdaArgument<mlir::concretelang::IntLambdaArgument<>>
&resp = (*res)
->cast<mlir::concretelang::TensorLambdaArgument<
mlir::concretelang::IntLambdaArgument<>>>();
mlir::concretelang::TensorLambdaArgument<
mlir::concretelang::IntLambdaArgument<>> &resp =
(*res)
->cast<mlir::concretelang::TensorLambdaArgument<
mlir::concretelang::IntLambdaArgument<>>>();
ASSERT_EQ(resp.getDimensions().size(), (size_t)3);
ASSERT_EQ(resp.getDimensions().at(0), 4);
@@ -1052,8 +1054,7 @@ TEST(End2EndJit_FHELinalg, apply_lookup_table) {
}
///////////////////////////////////////////////////////////////////////////////
// FHELinalg apply_multi_lookup_table
// /////////////////////////////////////////////
// FHELinalg apply_multi_lookup_table /////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
TEST(End2EndJit_FHELinalg, apply_multi_lookup_table) {
@@ -1154,7 +1155,7 @@ TEST(End2EndJit_FHELinalg, apply_multi_lookup_table_with_boradcast) {
}
///////////////////////////////////////////////////////////////////////////////
// FHELinalg apply_mapped_lookup_table /////////////////////////////////////////////
// FHELinalg apply_mapped_lookup_table ////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
TEST(End2EndJit_FHELinalg, apply_mapped_lookup_table_sequential) {
@@ -1173,9 +1174,8 @@ TEST(End2EndJit_FHELinalg, apply_mapped_lookup_table_sequential) {
{2, 3, 0},
};
uint64_t luts[9][4]{
{3, 0, 0, 0}, {0, 3, 0, 0}, {0, 0, 3, 0},
{0, 0, 0, 3}, {3, 0, 0, 0}, {0, 3, 0, 0},
{0, 0, 3, 0}, {0, 0, 0, 3}, {3, 0, 0, 0},
{3, 0, 0, 0}, {0, 3, 0, 0}, {0, 0, 3, 0}, {0, 0, 0, 3}, {3, 0, 0, 0},
{0, 3, 0, 0}, {0, 0, 3, 0}, {0, 0, 0, 3}, {3, 0, 0, 0},
};
uint64_t map[3][3]{
{0, 1, 2},
@@ -1192,8 +1192,7 @@ TEST(End2EndJit_FHELinalg, apply_mapped_lookup_table_sequential) {
tensorArgTy<uint64_t> lutsArg(luts), mapArg(map);
llvm::Expected<std::vector<uint64_t>> res =
lambda.operator()<std::vector<uint64_t>>(
{&tArg, &lutsArg, &mapArg});
lambda.operator()<std::vector<uint64_t>>({&tArg, &lutsArg, &mapArg});
ASSERT_EXPECTED_SUCCESS(res);
@@ -1223,9 +1222,8 @@ TEST(End2EndJit_FHELinalg, apply_mapped_lookup_table_same_lut) {
{2, 3, 0},
};
uint64_t luts[9][4]{
{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0},
{0, 0, 0, 0}, {1, 2, 3, 1}, {0, 0, 0, 0},
{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0},
{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {1, 2, 3, 1},
{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0},
};
uint64_t map[3][3]{
{4, 4, 4},
@@ -1242,8 +1240,7 @@ TEST(End2EndJit_FHELinalg, apply_mapped_lookup_table_same_lut) {
tensorArgTy<uint64_t> lutsArg(luts), mapArg(map);
llvm::Expected<std::vector<uint64_t>> res =
lambda.operator()<std::vector<uint64_t>>(
{&tArg, &lutsArg, &mapArg});
lambda.operator()<std::vector<uint64_t>>({&tArg, &lutsArg, &mapArg});
ASSERT_EXPECTED_SUCCESS(res);
@@ -1281,7 +1278,7 @@ func @main(%arg0: tensor<4x!FHE.eint<7>>,
}
///////////////////////////////////////////////////////////////////////////////
// FHELinalg neg_eint /////////////////////////////////////////////
// FHELinalg neg_eint /////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
TEST(End2EndJit_FHELinalg, neg_eint) {
@@ -1447,7 +1444,7 @@ TEST(End2EndJit_Linalg, tensor_collapse_shape) {
mlir::concretelang::JitCompilerEngine::Lambda lambda = checkedJit(R"XXX(
func @main(%a: tensor<2x2x4x!FHE.eint<6>>) -> tensor<2x8x!FHE.eint<6>> {
%0 = linalg.tensor_collapse_shape %a [[0],[1,2]] : tensor<2x2x4x!FHE.eint<6>> into tensor<2x8x!FHE.eint<6>>
%0 = linalg.tensor_collapse_shape %a [[0],[1,2]] : tensor<2x2x4x!FHE.eint<6>> into tensor<2x8x!FHE.eint<6>>
return %0 : tensor<2x8x!FHE.eint<6>>
}
)XXX");
@@ -1470,10 +1467,11 @@ func @main(%a: tensor<2x2x4x!FHE.eint<6>>) -> tensor<2x8x!FHE.eint<6>> {
ASSERT_EXPECTED_SUCCESS(res);
mlir::concretelang::TensorLambdaArgument<mlir::concretelang::IntLambdaArgument<>>
&resp = (*res)
->cast<mlir::concretelang::TensorLambdaArgument<
mlir::concretelang::IntLambdaArgument<>>>();
mlir::concretelang::TensorLambdaArgument<
mlir::concretelang::IntLambdaArgument<>> &resp =
(*res)
->cast<mlir::concretelang::TensorLambdaArgument<
mlir::concretelang::IntLambdaArgument<>>>();
ASSERT_EQ(resp.getDimensions().size(), (size_t)2);
ASSERT_EQ(resp.getDimensions().at(0), 2);
@@ -1496,7 +1494,7 @@ TEST(End2EndJit_Linalg, tensor_expand_shape) {
mlir::concretelang::JitCompilerEngine::Lambda lambda = checkedJit(R"XXX(
func @main(%a: tensor<2x8x!FHE.eint<6>>) -> tensor<2x2x4x!FHE.eint<6>> {
%0 = linalg.tensor_expand_shape %a [[0],[1,2]] : tensor<2x8x!FHE.eint<6>> into tensor<2x2x4x!FHE.eint<6>>
%0 = linalg.tensor_expand_shape %a [[0],[1,2]] : tensor<2x8x!FHE.eint<6>> into tensor<2x2x4x!FHE.eint<6>>
return %0 : tensor<2x2x4x!FHE.eint<6>>
}
)XXX");
@@ -1520,10 +1518,11 @@ func @main(%a: tensor<2x8x!FHE.eint<6>>) -> tensor<2x2x4x!FHE.eint<6>> {
ASSERT_EXPECTED_SUCCESS(res);
mlir::concretelang::TensorLambdaArgument<mlir::concretelang::IntLambdaArgument<>>
&resp = (*res)
->cast<mlir::concretelang::TensorLambdaArgument<
mlir::concretelang::IntLambdaArgument<>>>();
mlir::concretelang::TensorLambdaArgument<
mlir::concretelang::IntLambdaArgument<>> &resp =
(*res)
->cast<mlir::concretelang::TensorLambdaArgument<
mlir::concretelang::IntLambdaArgument<>>>();
ASSERT_EQ(resp.getDimensions().size(), (size_t)3);
ASSERT_EQ(resp.getDimensions().at(0), 2);

2
compiler/tests/unittest/end_to_end_jit_lambda.cc
View File

@@ -2,8 +2,6 @@
#include "end_to_end_jit_test.h"
const mlir::concretelang::V0FHEConstraint defaultV0Constraints{10, 7};
using Lambda = mlir::concretelang::JitCompilerEngine::Lambda;