github/MP-SPDZ
1
1
Fork 0
mirror of https://github.com/data61/MP-SPDZ.git synced 2026-01-09 13:37:58 -05:00
Code Issues Packages Projects Releases Wiki Activity

Snake case everywhere (hopefully)

Browse Source
This commit is contained in:
Vincent Ehrmanntraut
2024-12-14 00:37:05 +01:00
parent 5050dc4c51
commit f27f15f864
7 changed files with 45 additions and 96 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Processor/Processor.hpp
View File

@@ -928,7 +928,7 @@ void SubProcessor<T>::apply_shuffle(const Instruction& instruction,
shuffles[i] = Proc->read_Ci(args[6 * i + 4]);
reverse[i] = args[6 * i + 5];
}
shuffler.applyMultiple(S, sizes, destinations, sources, unit_sizes, shuffles, reverse, shuffle_store);
shuffler.apply_multiple(S, sizes, destinations, sources, unit_sizes, shuffles, reverse, shuffle_store);
maybe_check();
}

7
Protocols/Rep3Shuffler.h
View File

@@ -28,12 +28,9 @@ public:
int generate(int n_shuffle, store_type& store);
// void apply(StackedVector<T>& a, size_t n, int unit_size, size_t output_base,
// size_t input_base, shuffle_type& shuffle, bool reverse);
void applyMultiple(StackedVector<T>& a, vector<size_t>& sizes, vector<size_t>& destinations, vector<size_t>& sources,
void apply_multiple(StackedVector<T>& a, vector<size_t>& sizes, vector<size_t>& destinations, vector<size_t>& sources,
vector<size_t>& unit_sizes, vector<size_t>& handles, vector<bool>& reverse, store_type& store);
void applyMultiple(StackedVector<T>& a, vector<size_t>& sizes, vector<size_t>& destinations, vector<size_t>& sources,
void apply_multiple(StackedVector<T>& a, vector<size_t>& sizes, vector<size_t>& destinations, vector<size_t>& sources,
vector<size_t>& unit_sizes, vector<shuffle_type>& shuffles, vector<bool>& reverse);
void inverse_permutation(StackedVector<T>& stack, size_t n, size_t output_base,

21
Protocols/Rep3Shuffler.hpp
View File

@@ -20,7 +20,7 @@ Rep3Shuffler<T>::Rep3Shuffler(StackedVector<T> &a, size_t n, int unit_size,
vector<size_t> sources{input_base};
vector<shuffle_type> shuffles{store.get(handle)};
vector<bool> reverses{true};
this->applyMultiple(a, sizes, destinations, sources, unit_sizes, shuffles, reverses);
this->apply_multiple(a, sizes, destinations, sources, unit_sizes, shuffles, reverses);
}
template<class T>
@@ -43,21 +43,8 @@ int Rep3Shuffler<T>::generate(int n_shuffle, store_type &store) {
return res;
}
// template<class T>
// void Rep3Shuffler<T>::apply(StackedVector<T> &a, size_t n, int unit_size,
// size_t output_base, size_t input_base, shuffle_type &shuffle,
// bool reverse) {
// vector<size_t> sizes{n};
// vector<size_t> unit_sizes{static_cast<size_t>(unit_size)};
// vector<size_t> destinations{output_base};
// vector<size_t> sources{input_base};
// vector<shuffle_type> shuffles{shuffle};
// vector<bool> reverses{reverse};
// this->applyMultiple(a, sizes, unit_sizes, destinations, sources, shuffles, reverses);
// }
template<class T>
void Rep3Shuffler<T>::applyMultiple(StackedVector<T> &a, vector<size_t> &sizes, vector<size_t> &destinations,
void Rep3Shuffler<T>::apply_multiple(StackedVector<T> &a, vector<size_t> &sizes, vector<size_t> &destinations,
vector<size_t> &sources,
vector<size_t> &unit_sizes, vector<size_t> &handles, vector<bool> &reverses,
store_type &store) {
@@ -67,11 +54,11 @@ void Rep3Shuffler<T>::applyMultiple(StackedVector<T> &a, vector<size_t> &sizes,
shuffles.push_back(shuffle);
}
applyMultiple(a, sizes, destinations, sources, unit_sizes, shuffles, reverses);
apply_multiple(a, sizes, destinations, sources, unit_sizes, shuffles, reverses);
}
template<class T>
void Rep3Shuffler<T>::applyMultiple(StackedVector<T> &a, vector<size_t> &sizes, vector<size_t> &destinations,
void Rep3Shuffler<T>::apply_multiple(StackedVector<T> &a, vector<size_t> &sizes, vector<size_t> &destinations,
vector<size_t> &sources, vector<size_t> &unit_sizes, vector<shuffle_type> &shuffles,
vector<bool> &reverses) {
const auto n_shuffles = sizes.size();

8
Protocols/SecureShuffle.h
View File

@@ -63,8 +63,8 @@ private:
*/
vector<vector<T>> configure(int config_player, vector<int>* perm, int n);
int prep_multiple(StackedVector<T>& a, vector<size_t> &sizes, vector<size_t> &sources, vector<size_t> &unit_sizes, vector<vector<T>>& toShuffle, vector<bool> &exact);
void finalize_multiple(StackedVector<T>& a, vector<size_t>& sizes, vector<size_t>& unit_sizes, vector<size_t>& destinations, vector<bool>& isExact, vector<vector<T>>& toShuffle);
int prep_multiple(StackedVector<T>& a, vector<size_t> &sizes, vector<size_t> &sources, vector<size_t> &unit_sizes, vector<vector<T>>& to_shuffle, vector<bool> &exact);
void finalize_multiple(StackedVector<T>& a, vector<size_t>& sizes, vector<size_t>& unit_sizes, vector<size_t>& destinations, vector<bool>& isExact, vector<vector<T>>& to_shuffle);
void parallel_waksman_round(size_t pass, int depth, bool inwards, vector<vector<T>>& toShuffle, vector<size_t>& unit_sizes, vector<bool>& reverse, vector<shuffle_type>& shuffles);
vector<array<int, 5>> waksman_round_init(vector<T>& toShuffle, size_t shuffle_unit_size, int depth, vector<vector<T>>& iter_waksman_config, bool inwards, bool reverse);
@@ -80,9 +80,9 @@ public:
int generate(int n_shuffle, store_type& store);
void applyMultiple(StackedVector<T>& a, vector<size_t>& sizes, vector<size_t>& destinations, vector<size_t>& sources,
void apply_multiple(StackedVector<T>& a, vector<size_t>& sizes, vector<size_t>& destinations, vector<size_t>& sources,
vector<size_t>& unit_sizes, vector<size_t>& handles, vector<bool>& reverse, store_type& store);
void applyMultiple(StackedVector<T>& a, vector<size_t>& sizes, vector<size_t>& destinations, vector<size_t>& sources,
void apply_multiple(StackedVector<T>& a, vector<size_t>& sizes, vector<size_t>& destinations, vector<size_t>& sources,
vector<size_t>& unit_sizes, vector<shuffle_type>& shuffles, vector<bool>& reverse);
/**

54
Protocols/SecureShuffle.hpp
View File

@@ -71,21 +71,21 @@ SecureShuffle<T>::SecureShuffle(StackedVector<T>& a, size_t n, int unit_size,
vector<size_t> sources{input_base};
vector<shuffle_type> shuffles{store.get(handle)};
vector<bool> reverses{true};
this->applyMultiple(a, sizes, destinations, sources, unit_sizes, shuffles, reverses);
this->apply_multiple(a, sizes, destinations, sources, unit_sizes, shuffles, reverses);
}
template<class T>
void SecureShuffle<T>::applyMultiple(StackedVector<T>& a, vector<size_t>& sizes, vector<size_t>& destinations, vector<size_t>& sources,
void SecureShuffle<T>::apply_multiple(StackedVector<T>& a, vector<size_t>& sizes, vector<size_t>& destinations, vector<size_t>& sources,
vector<size_t>& unit_sizes, vector<size_t>& handles, vector<bool>& reverse, store_type& store) {
vector<shuffle_type> shuffles;
for (size_t &handle : handles)
shuffles.push_back(store.get(handle));
this->applyMultiple(a, sizes, destinations, sources, unit_sizes, shuffles, reverse);
this->apply_multiple(a, sizes, destinations, sources, unit_sizes, shuffles, reverse);
}
template<class T>
void SecureShuffle<T>::applyMultiple(StackedVector<T> &a, vector<size_t> &sizes, vector<size_t> &destinations,
void SecureShuffle<T>::apply_multiple(StackedVector<T> &a, vector<size_t> &sizes, vector<size_t> &destinations,
vector<size_t> &sources, vector<size_t> &unit_sizes, vector<shuffle_type> &shuffles, vector<bool> &reverse) {
const auto n_shuffles = sizes.size();
assert(sources.size() == n_shuffles);
@@ -100,21 +100,21 @@ void SecureShuffle<T>::applyMultiple(StackedVector<T> &a, vector<size_t> &sizes,
const auto n_passes = proc.protocol.get_relevant_players().size();
// Initialize the shuffles.
vector isExact(n_shuffles, false);
vector<vector<T>> toShuffle;
int max_depth = prep_multiple(a, sizes, sources, unit_sizes, toShuffle, isExact);
vector is_exact(n_shuffles, false);
vector<vector<T>> to_shuffle;
int max_depth = prep_multiple(a, sizes, sources, unit_sizes, to_shuffle, is_exact);
// Apply the shuffles.
for (size_t pass = 0; pass < n_passes; pass++)
{
for (int depth = 0; depth < max_depth; depth++)
parallel_waksman_round(pass, depth, true, toShuffle, unit_sizes, reverse, shuffles);
parallel_waksman_round(pass, depth, true, to_shuffle, unit_sizes, reverse, shuffles);
for (int depth = max_depth - 1; depth >= 0; depth--)
parallel_waksman_round(pass, depth, false, toShuffle, unit_sizes, reverse, shuffles);
parallel_waksman_round(pass, depth, false, to_shuffle, unit_sizes, reverse, shuffles);
}
// Write the shuffled results into memory.
finalize_multiple(a, sizes, unit_sizes, destinations, isExact, toShuffle);
finalize_multiple(a, sizes, unit_sizes, destinations, is_exact, to_shuffle);
}
@@ -139,12 +139,12 @@ void SecureShuffle<T>::inverse_permutation(StackedVector<T> &stack, size_t n, si
vector<size_t> destinations { output_base };
vector<size_t> sources { input_base };
vector<bool> reverse { true };
vector<vector<T>> toShuffle;
vector<bool> isExact(1, false);
vector<vector<T>> to_shuffle;
vector<bool> is_exact(1, false);
prep_multiple(stack, sizes, sources, unit_sizes, toShuffle, isExact);
prep_multiple(stack, sizes, sources, unit_sizes, to_shuffle, is_exact);
size_t shuffle_size = toShuffle[0].size() / unit_sizes[0];
size_t shuffle_size = to_shuffle[0].size() / unit_sizes[0];
// Alice generates stack local permutation and shares the waksman configuration bits secretly to Bob.
vector<int> perm_alice(shuffle_size);
if (P.my_num() == alice) {
@@ -156,12 +156,12 @@ void SecureShuffle<T>::inverse_permutation(StackedVector<T> &stack, size_t n, si
// Apply perm_alice to perm_alice to get perm_bob,
// stack permutation that we can reveal to Bob without Bob learning anything about perm_alice (since it is masked by perm_a)
for (int depth = 0; depth < log2(shuffle_size); depth++)
parallel_waksman_round(0, depth, true, toShuffle, unit_sizes, reverse, shuffles);
parallel_waksman_round(0, depth, true, to_shuffle, unit_sizes, reverse, shuffles);
for (int depth = log2(shuffle_size); depth >= 0; depth--)
parallel_waksman_round(0, depth, false, toShuffle, unit_sizes, reverse, shuffles);
parallel_waksman_round(0, depth, false, to_shuffle, unit_sizes, reverse, shuffles);
// Store perm_bob at stack[output_base]
finalize_multiple(stack, sizes, unit_sizes, destinations, isExact, toShuffle);
finalize_multiple(stack, sizes, unit_sizes, destinations, is_exact, to_shuffle);
// Reveal permutation perm_bob = perm_a * perm_alice
// Since this permutation is masked by perm_a, Bob learns nothing about perm
@@ -199,24 +199,24 @@ void SecureShuffle<T>::inverse_permutation(StackedVector<T> &stack, size_t n, si
stack[output_base + i] = input.finalize(alice);
// The two parties now jointly compute perm_a * perm_bob_inv to obtain perm_inv
toShuffle.clear();
prep_multiple(stack, sizes, destinations, unit_sizes, toShuffle, isExact);
to_shuffle.clear();
prep_multiple(stack, sizes, destinations, unit_sizes, to_shuffle, is_exact);
config = configure(bob, &perm_bob_inv, n);
shuffles[0] = { config, config };
for (int i = 0; i < log2(shuffle_size); i++)
parallel_waksman_round(0, i, true, toShuffle, unit_sizes, reverse, shuffles);
parallel_waksman_round(0, i, true, to_shuffle, unit_sizes, reverse, shuffles);
for (int i = log2(shuffle_size) - 2; i >= 0; i--)
parallel_waksman_round(0, i, false, toShuffle, unit_sizes, reverse, shuffles);
parallel_waksman_round(0, i, false, to_shuffle, unit_sizes, reverse, shuffles);
// Store perm_bob at stack[output_base]
finalize_multiple(stack, sizes, unit_sizes, destinations, isExact, toShuffle);
finalize_multiple(stack, sizes, unit_sizes, destinations, is_exact, to_shuffle);
}
template<class T>
int SecureShuffle<T>::prep_multiple(StackedVector<T> &a, vector<size_t> &sizes,
vector<size_t> &sources, vector<size_t> &unit_sizes, vector<vector<T>> &toShuffle, vector<bool> &isExact) {
vector<size_t> &sources, vector<size_t> &unit_sizes, vector<vector<T>> &to_shuffle, vector<bool> &is_exact) {
int max_depth = 0;
const size_t n_shuffles = sizes.size();
@@ -255,8 +255,8 @@ int SecureShuffle<T>::prep_multiple(StackedVector<T> &a, vector<size_t> &sizes,
unit_sizes[currentShuffle] = shuffle_unit_size;
}
toShuffle.push_back(tmp);
isExact[currentShuffle] = exact;
to_shuffle.push_back(tmp);
is_exact[currentShuffle] = exact;
const int shuffle_depth = tmp.size() / unit_size;
if (shuffle_depth > max_depth)
@@ -268,14 +268,14 @@ int SecureShuffle<T>::prep_multiple(StackedVector<T> &a, vector<size_t> &sizes,
template<class T>
void SecureShuffle<T>::finalize_multiple(StackedVector<T> &a, vector<size_t> &sizes, vector<size_t> &unit_sizes,
vector<size_t> &destinations, vector<bool> &isExact, vector<vector<T>> &toShuffle) {
vector<size_t> &destinations, vector<bool> &isExact, vector<vector<T>> &to_shuffle) {
const size_t n_shuffles = sizes.size();
for (size_t currentShuffle = 0; currentShuffle < n_shuffles; currentShuffle++) {
const size_t n = sizes[currentShuffle];
const size_t shuffled_unit_size = unit_sizes[currentShuffle];
const size_t output_base = destinations[currentShuffle];
const vector<T>& shuffledData = toShuffle[currentShuffle];
const vector<T>& shuffledData = to_shuffle[currentShuffle];
if (isExact[currentShuffle])
for (size_t i = 0; i < n; i++)

7
Protocols/SpdzWiseRep3Shuffler.h
View File

@@ -30,12 +30,9 @@ public:
int generate(int n_shuffle, store_type& store);
// void apply(StackedVector<T>& a, size_t n, int unit_size, size_t output_base,
// size_t input_base, shuffle_type& shuffle, bool reverse);
void applyMultiple(StackedVector<T>& a, vector<size_t>& sizes, vector<size_t>& destinations, vector<size_t>& sources,
void apply_multiple(StackedVector<T>& a, vector<size_t>& sizes, vector<size_t>& destinations, vector<size_t>& sources,
vector<size_t>& unit_sizes, vector<size_t>& handles, vector<bool>& reverse, store_type& store);
void applyMultiple(StackedVector<T>& a, vector<size_t>& sizes, vector<size_t>& destinations, vector<size_t>& sources,
void apply_multiple(StackedVector<T>& a, vector<size_t>& sizes, vector<size_t>& destinations, vector<size_t>& sources,
vector<size_t>& unit_sizes, vector<shuffle_type>& shuffles, vector<bool>& reverse);
void inverse_permutation(StackedVector<T>& stack, size_t n, size_t output_base,

42
Protocols/SpdzWiseRep3Shuffler.hpp
View File

@@ -20,7 +20,7 @@ SpdzWiseRep3Shuffler<T>::SpdzWiseRep3Shuffler(StackedVector<T>& a, size_t n,
vector<size_t> sources{input_base};
vector<shuffle_type> shuffles{store.get(handle)};
vector<bool> reverses{true};
this->applyMultiple(a, sizes, destinations, sources, unit_sizes, shuffles, reverses);
this->apply_multiple(a, sizes, destinations, sources, unit_sizes, shuffles, reverses);
}
template<class T>
@@ -35,40 +35,8 @@ int SpdzWiseRep3Shuffler<T>::generate(int n_shuffle, store_type& store)
return internal.generate(n_shuffle, store);
}
// template<class T>
// void SpdzWiseRep3Shuffler<T>::apply(StackedVector<T>& a, size_t n,
// int unit_size, size_t output_base, size_t input_base,
// shuffle_type& shuffle, bool reverse)
// {
// stats[n / unit_size] += unit_size;
//
// StackedVector<typename T::part_type::Honest> to_shuffle;
// to_shuffle.reserve(2 * n);
//
// for (size_t i = 0; i < n; i++)
// {
// auto& x = a[input_base + i];
// to_shuffle.push_back(x.get_share());
// to_shuffle.push_back(x.get_mac());
// }
//
// internal.apply(to_shuffle, 2 * n, 2 * unit_size, 0, 0, shuffle, reverse);
//
//
// for (size_t i = 0; i < n; i++)
// {
// auto& x = a[output_base + i];
// x.set_share(to_shuffle[2 * i]);
// x.set_mac(to_shuffle[2 * i + 1]);
// proc.protocol.add_to_check(x);
// }
//
// proc.protocol.maybe_check();
// }
template<class T>
void SpdzWiseRep3Shuffler<T>::applyMultiple(StackedVector<T>& a, vector<size_t>& sizes, vector<size_t>& destinations, vector<size_t>& sources,
void SpdzWiseRep3Shuffler<T>::apply_multiple(StackedVector<T>& a, vector<size_t>& sizes, vector<size_t>& destinations, vector<size_t>& sources,
vector<size_t>& unit_sizes, vector<size_t>& handles, vector<bool>& reverses, store_type& store) {
vector<shuffle_type> shuffles;
for (size_t &handle : handles) {
@@ -76,12 +44,12 @@ void SpdzWiseRep3Shuffler<T>::applyMultiple(StackedVector<T>& a, vector<size_t>&
shuffles.push_back(shuffle);
}
applyMultiple(a, sizes, destinations, sources, unit_sizes, shuffles, reverses);
apply_multiple(a, sizes, destinations, sources, unit_sizes, shuffles, reverses);
}
template<class T>
void SpdzWiseRep3Shuffler<T>::applyMultiple(StackedVector<T> &a, vector<size_t> &sizes, vector<size_t> &destinations,
void SpdzWiseRep3Shuffler<T>::apply_multiple(StackedVector<T> &a, vector<size_t> &sizes, vector<size_t> &destinations,
vector<size_t> &sources, vector<size_t> &unit_sizes, vector<shuffle_type> &shuffles, vector<bool> &reverse) {
const size_t n_shuffles = sizes.size();
@@ -111,7 +79,7 @@ void SpdzWiseRep3Shuffler<T>::applyMultiple(StackedVector<T> &a, vector<size_t>
}
}
internal.applyMultiple(temporary_memory, mapped_sizes, mapped_positions, mapped_positions, mapped_unit_sizes, shuffles, reverse);
internal.apply_multiple(temporary_memory, mapped_sizes, mapped_positions, mapped_positions, mapped_unit_sizes, shuffles, reverse);
for (size_t current_shuffle = 0; current_shuffle < n_shuffles; current_shuffle++)
{