Semi-honest replicated sharing now has parallel shuffling

Processor/Processor.hpp

@@ -896,7 +896,7 @@ void SubProcessor<T>::apply_shuffle(const Instruction& instruction,
     const auto& args = instruction.get_start();
 
     const auto n_shuffles = args.size() / 5;
-    vector<int> sizes(n_shuffles, 0);
+    vector<size_t> sizes(n_shuffles, 0);
     vector<int> destinations(n_shuffles, 0);
     vector<int> sources(n_shuffles, 0);
     vector<int> unit_sizes(n_shuffles, 0);

Programs/Source/test_permute.mpc

@@ -55,4 +55,5 @@ def test_allocator():
     arr3.secure_permute(p3)
 
 # test_allocator()
-test_case([5, 10, 20], 10)
+test_case([5, 10, 20], 10)
+test_case([5, 10, 15, 20], 20)

Protocols/Rep3Shuffler.h

@@ -29,7 +29,7 @@ public:
     void apply(vector<T>& a, size_t n, int unit_size, size_t output_base,
             size_t input_base, shuffle_type& shuffle, bool reverse);
 
-    void applyMultiple(vector<T>& a, vector<int>& sizes, vector<int>& destinations, vector<int>& sources,
+    void applyMultiple(vector<T>& a, vector<size_t>& sizes, vector<int>& destinations, vector<int>& sources,
                        vector<int>& unit_sizes, vector<int>& handles, vector<bool>& reverse, store_type& store);
 
     void inverse_permutation(vector<T>& stack, size_t n, size_t output_base,

Protocols/Rep3Shuffler.hpp

@@ -120,17 +120,112 @@ void Rep3Shuffler<T>::apply(vector<T>& a, size_t n, int unit_size,
 }
 
 template<class T>
-void Rep3Shuffler<T>::applyMultiple(vector<T>& a, vector<int>& sizes, vector<int>& destinations, vector<int>& sources,
+void Rep3Shuffler<T>::applyMultiple(vector<T>& a, vector<size_t>& sizes, vector<int>& destinations, vector<int>& sources,
-                                    vector<int>& unit_sizes, vector<int>& handles, vector<bool>& reverse, store_type& store) {
+                                    vector<int>& unit_sizes, vector<int>& handles, vector<bool>& reverses, store_type& store) {
     const auto n_shuffles = sizes.size();
     assert(sources.size() == n_shuffles);
     assert(destinations.size() == n_shuffles);
     assert(unit_sizes.size() == n_shuffles);
     assert(handles.size() == n_shuffles);
-    assert(reverse.size() == n_shuffles);
+    assert(reverses.size() == n_shuffles);
 
-    for (size_t i = 0; i < n_shuffles; i++) {
+    assert(proc.P.num_players() == 3);
-        this->apply(a, sizes[i], unit_sizes[i], destinations[i], sources[i], store.get(handles[i]), reverse[i]);
+    assert(not T::malicious);
+    assert(not T::dishonest_majority);
+
+    // for (size_t i = 0; i < n_shuffles; i++) {
+        // this->apply(a, sizes[i], unit_sizes[i], destinations[i], sources[i], store.get(handles[i]), reverses[i]);
+    // }
+
+    vector<vector<T>> to_shuffle;
+    for (size_t current_shuffle = 0; current_shuffle < n_shuffles; current_shuffle++) {
+        assert(sizes[current_shuffle] % unit_sizes[current_shuffle] == 0);
+        vector<T> x;
+        for (size_t j = 0; j < sizes[current_shuffle]; j++)
+            x.push_back(a[sources[current_shuffle] + j]);
+        to_shuffle.push_back(x);
+
+        const auto shuffle = store.get(handles[current_shuffle]);
+        if (shuffle.empty())
+            throw runtime_error("shuffle has been deleted");
+    }
+
+
+    typename T::Input input(proc);
+
+    for (int pass = 0; pass < 3; pass++)
+    {
+    input.reset_all(proc.P);
+
+    for (size_t current_shuffle = 0; current_shuffle < n_shuffles; current_shuffle++) {
+        const auto n = sizes[current_shuffle];
+        const auto unit_size = unit_sizes[current_shuffle];
+        const auto shuffle = store.get(handles[current_shuffle]);
+        const auto reverse = reverses[current_shuffle];
+        const auto current_to_shuffle = to_shuffle[current_shuffle];
+
+        vector<typename T::clear> to_share(n);
+        int i;
+        if (reverse)
+            i = 2 - pass;
+        else
+            i = pass;
+
+        if (proc.P.get_player(i) == 0) {
+            for (size_t j = 0; j < n / unit_size; j++)
+                for (int k = 0; k < unit_size; k++)
+                    if (reverse)
+                        to_share.at(j * unit_size + k) = current_to_shuffle.at(
+                            shuffle[0].at(j) * unit_size + k).sum();
+                    else
+                        to_share.at(shuffle[0].at(j) * unit_size + k) =
+                                current_to_shuffle.at(j * unit_size + k).sum();
+        }
+        else if (proc.P.get_player(i) == 1)
+        {
+            for (size_t j = 0; j < n / unit_size; j++)
+                for (int k = 0; k < unit_size; k++)
+                    if (reverse)
+                        to_share[j * unit_size + k] = current_to_shuffle[shuffle[1][j] * unit_size + k][0];
+                    else
+                        to_share[shuffle[1][j] * unit_size + k] = current_to_shuffle[j * unit_size + k][0];
+        }
+
+        if (proc.P.get_player(i) < 2)
+            for (auto& x : to_share)
+                input.add_mine(x);
+        for (int k = 0; k < 2; k++)
+            input.add_other((-i + 3 + k) % 3);
+    }
+
+        input.exchange();
+        to_shuffle.clear();
+
+        for (size_t current_shuffle = 0; current_shuffle < n_shuffles; current_shuffle++) {
+            const auto n = sizes[current_shuffle];
+            const auto reverse = reverses[current_shuffle];
+
+            int i;
+            if (reverse)
+                i = 2 - pass;
+            else
+                i = pass;
+
+            vector<T> tmp;
+            for (size_t j = 0; j < n; j++)
+            {
+                T x = input.finalize((-i + 3) % 3) + input.finalize((-i + 4) % 3);
+                tmp.push_back(x);
+            }
+            to_shuffle.push_back(tmp);
+        }
+    }
+
+    for (size_t current_shuffle = 0; current_shuffle < n_shuffles; current_shuffle++) {
+        const auto n = sizes[current_shuffle];
+
+        for (size_t i = 0; i < n; i++)
+            a[destinations[current_shuffle] + i] = to_shuffle[current_shuffle][i];
     }
 }
 

Protocols/SecureShuffle.h

@@ -104,7 +104,7 @@ public:
     void apply(vector<T>& a, size_t n, int unit_size, size_t output_base,
             size_t input_base, shuffle_type& shuffle, bool reverse);
 
-    void applyMultiple(vector<T>& a, vector<int>& sizes, vector<int>& destinations, vector<int>& sources,
+    void applyMultiple(vector<T>& a, vector<size_t>& sizes, vector<int>& destinations, vector<int>& sources,
                        vector<int>& unit_sizes, vector<int>& handles, vector<bool>& reverse, store_type& store);
 
     /**

Protocols/SecureShuffle.hpp

@@ -98,7 +98,7 @@ void SecureShuffle<T>::apply(vector<T>& a, size_t n, int unit_size, size_t outpu
 
 
 template<class T>
-void SecureShuffle<T>::applyMultiple(vector<T>& a, vector<int>& sizes, vector<int>& destinations, vector<int>& sources,
+void SecureShuffle<T>::applyMultiple(vector<T>& a, vector<size_t>& sizes, vector<int>& destinations, vector<int>& sources,
                                     vector<int>& unit_sizes, vector<int>& handles, vector<bool>& reverse, store_type& store) {
     const auto n_shuffles = sizes.size();
     assert(sources.size() == n_shuffles);