somechanges to output

preprocessing/dpfgen.h

@@ -66,6 +66,8 @@ void compute_CW(cw_construction computecw_array, size_t ind, size_t layer,tcp::s
 
 	//exchange blinded shares for OSWAP.
   boost::asio::write(sout, boost::asio::buffer(&blinds_sent, sizeof(BlindsCW)));
+  communication_cost += sizeof(__m128i);
+
 	boost::asio::read(sout, boost::asio::buffer(&blinds_recv, sizeof(BlindsCW)));
 	
 	blinded_bit_read = blinds_recv.blinded_bit;
@@ -88,11 +90,11 @@ void compute_CW(cw_construction computecw_array, size_t ind, size_t layer,tcp::s
 
  boost::asio::write(sout, boost::asio::buffer(&cwsent, sizeof(cwsent)));
  boost::asio::read(sout, boost::asio::buffer(&cwrecv, sizeof(cwrecv)));
+ communication_cost += sizeof(__m128i);
  cwrecv.cw ^= cwsent.cw;
  cwrecv.cwbit[0] ^= (cwsent.cwbit[0] ^ 1);
  cwrecv.cwbit[1] ^= (cwsent.cwbit[1]);
  
- 
  cwt_L = cwrecv.cwbit[0];
  cwt_R = cwrecv.cwbit[1];
  CW = cwrecv.cw;
@@ -157,17 +159,16 @@ static inline void traverse(const prgkey_t & prgkey, const node_t & seed,	node_t
  * @param party Party
  * @param socket_no 
  */
-inline void create_dpfs ( bool reading,  size_t db_nitems, const AES_KEY& prgkey,  uint8_t target_share[64], std::vector<socket_t>& socketsPb, std::vector<socket_t>& socketsP2,
-						              const size_t from, const size_t to, __m128i * output, int8_t * _t, __m128i& final_correction_word,  
-						              cw_construction computecw_array, dpfP2 * dpf_instance, 
-                          bool party, size_t socket_no, size_t ind = 0)
-{
- 
- 	const size_t bits_per_leaf = std::is_same<leaf_t, bool>::value ? 1 : sizeof(leaf_t) * CHAR_BIT;
+inline void create_dpfs (bool reading,  size_t db_nitems, const AES_KEY& prgkey,  
+                         uint8_t target_share[64], std::vector<socket_t>& socketsPb, std::vector<socket_t>& socketsP2, const size_t from, const size_t to, __m128i * output, int8_t * _t, __m128i& final_correction_word,  
+						                   cw_construction computecw_array, dpfP2 * dpf_instance, 
+                         bool party, size_t socket_no, size_t ind = 0)
+{ 
+	const size_t bits_per_leaf = std::is_same<leaf_t, bool>::value ? 1 : sizeof(leaf_t) * CHAR_BIT;
 	const bool  is_packed = (sizeof(leaf_t) < sizeof(node_t));
 	const size_t nodes_per_leaf = is_packed ? 1 : std::ceil(static_cast<double>(bits_per_leaf) / (sizeof(node_t) * CHAR_BIT));
 
- 	const size_t depth = std::ceil(std::log2(db_nitems));
+ const size_t depth = std::ceil(std::log2(db_nitems));
 	const size_t nbits = std::ceil(std::log2(db_nitems));
 	const size_t nodes_in_interval = db_nitems-1; 
 	
@@ -175,7 +176,7 @@ inline void create_dpfs ( bool reading,  size_t db_nitems, const AES_KEY& prgkey
 
 	arc4random_buf(&root, sizeof(root));
 
- 	root =	set_lsb(root, party);
+ root =	set_lsb(root, party);
 
 	const size_t from_node = std::floor(static_cast<double>(from) / nodes_per_leaf);
 
@@ -238,7 +239,6 @@ inline void create_dpfs ( bool reading,  size_t db_nitems, const AES_KEY& prgkey
 						traverse(prgkey, s[1-curlayer][j], &s[curlayer][i]);
 						L ^= s[curlayer][i];
 						R ^= s[curlayer][i+1];
-			 
 				}
 			}
 

preprocessing/p2preprocessing.cpp

@@ -42,68 +42,15 @@ size_t bits_per_leaf = std::is_same<leaf_t, bool>::value ? 1 : sizeof(leaf_t) *
 bool is_packed = (sizeof(leaf_t) < sizeof(node_t));
 size_t leaves_per_node = is_packed ? sizeof(node_t) * CHAR_BIT / bits_per_leaf : 1;
 size_t __depth(const size_t nitems) { return std::ceil(std::log2(std::ceil(static_cast<double>(nitems) / leaves_per_node))); }
-
+size_t communication_cost = 0;
 #include "mpc.h"
 #include "dpfgen.h"
 #include "share-conversion.h"
 
-void mpc_gen(const size_t depth, AES_KEY& prgkey, const size_t db_nitems, const size_t n_threads, std::vector<socket_t>& sockets0, std::vector<socket_t>& sockets1, 
-             __m128i** output0, int8_t ** flags0, __m128i** output1, int8_t ** flags1, dpfP2 * dpf_instance0 , dpfP2 * dpf_instance1, size_t ind,
-             size_t socket_no = 0)
+void mpc_gen (const size_t depth, AES_KEY& prgkey, const size_t db_nitems, 
+              const size_t n_threads, std::vector<socket_t>& sockets0, std::vector<socket_t>& sockets1, __m128i** output0, int8_t ** flags0, __m128i** output1, int8_t ** flags1, dpfP2 * dpf_instance0 , 
+              dpfP2 * dpf_instance1, size_t ind,size_t socket_no = 0)
 {	
-
-    // struct cw_construction
-    // {
-    //   __m128i rand_b, gamma_b;
-    //   uint8_t bit_b;
-    // };
-    
-
-
-  for(size_t j = 0; j < depth; ++j)
-  {
-   
-    // __m128i rand0, rand1, gamma0, gamma1;
-
-    // arc4random_buf(&rand0, sizeof(__m128i));
-    // arc4random_buf(&rand1, sizeof(__m128i));
-    // uint8_t bit0, bit1; 
-    // bit0 = rand();
-    // bit0 = bit0 % 2;
-    // bit1 = rand();
-    // bit1 = bit1 %2;
-
-    // gamma0 = (bit1 == 1) ? rand0 : _mm_setzero_si128();
-    // gamma1 = (bit0 == 1) ? rand1 : _mm_setzero_si128();
-
-
-    // cw_construction computecw0, computecw1;
-    
-    // computecw0.rand_b   = rand0;
-    // computecw0.gamma_b  = gamma0;
-    // computecw0.bit_b    = bit0;
-
-    // computecw1.rand_b   = rand1;
-    // computecw1.gamma_b  = gamma1;
-    // computecw1.bit_b    = bit1;
-    
-    // boost::asio::write(sockets0[socket_no], boost::asio::buffer(&computecw0, sizeof(computecw0)));
-    // boost::asio::write(sockets1[socket_no], boost::asio::buffer(&computecw1, sizeof(computecw1)));
-
-    // #ifdef DEBUG
-    //  boost::asio::write(sockets0[socket_no], boost::asio::buffer(&rand0, sizeof(rand0)));
-    //  boost::asio::write(sockets0[socket_no], boost::asio::buffer(&gamma0, sizeof(gamma0)));
-    //  boost::asio::write(sockets0[socket_no], boost::asio::buffer(&bit0, sizeof(bit0)));
-
-    //  boost::asio::write(sockets1[socket_no], boost::asio::buffer(&rand1, sizeof(rand1)));
-    //  boost::asio::write(sockets1[socket_no], boost::asio::buffer(&gamma1, sizeof(gamma1)));
-    //  boost::asio::write(sockets1[socket_no], boost::asio::buffer(&bit1, sizeof(bit1)));
-    // #endif
-  } 
-  
-  // boost::asio::read(sockets0[socket_no+1], boost::asio::buffer(&dpf_instance0[ind], sizeof(dpfP2)));
-  // boost::asio::read(sockets1[socket_no+1], boost::asio::buffer(&dpf_instance1[ind], sizeof(dpfP2))); 
-
   evaluate_dpfs(db_nitems,  dpf_instance0[ind],   prgkey,  0, db_nitems-1,	output0[ind],  flags0[ind],  false,  ind);
   evaluate_dpfs(db_nitems,  dpf_instance1[ind],   prgkey,  0, db_nitems-1, output1[ind],  flags1[ind],  true ,  ind);
 

preprocessing/preprocessing.cpp

@@ -28,7 +28,7 @@ typedef __m128i node_t;
 constexpr size_t leaf_size = 1;
 typedef __m128i leaf_type;
 typedef std::array<leaf_type, leaf_size> leaf_t;
-
+size_t communication_cost = 0;
 #include "bitutils.h"
 #include "block.h" 
 #include "prg_aes_impl.h"
@@ -52,6 +52,7 @@ int main(int argc, char * argv[])
    const std::string host2 = (argc < 3) ? "127.0.0.1" : argv[2];
    const size_t n_threads = atoi(argv[3]);
    const size_t expo = atoi(argv[4]);
+   const size_t op = atoi(argv[5]);
    const size_t number_of_sockets = 5 * n_threads;
 
    std::vector<socket_t> socketsPb, socketsP2;
@@ -83,7 +84,7 @@ int main(int argc, char * argv[])
      flags[j]  = (int8_t *)std::aligned_alloc(sizeof(node_t), db_nitems * sizeof(uint8_t));
    }
      
-   boost::asio::thread_pool pool(n_threads);
+  
    boost::asio::thread_pool pool_share_conversion(n_threads);
     
 
@@ -107,6 +108,7 @@ int main(int argc, char * argv[])
 
    /* The function create_dpfs appears in dpf-gen.h*/
    bool reading = true;
+   boost::asio::thread_pool pool(n_threads);
    for(size_t j = 0; j < n_threads; ++j)
    {
      boost::asio::post(pool,  std::bind(create_dpfs, reading,  db_nitems,	std::ref(aeskey),  target_share_read[j],  std::ref(socketsPb), std::ref(socketsP2), 0, db_nitems-1, 
@@ -115,6 +117,19 @@ int main(int argc, char * argv[])
    
    pool.join();  
 
+   bool interleaved = false;
+   if(op == 1) interleaved = true;
+   if(interleaved)
+   {
+    boost::asio::thread_pool pool2(n_threads);
+    for(size_t j = 0; j < n_threads; ++j)
+    {
+      boost::asio::post(pool2,  std::bind(create_dpfs, reading,  db_nitems,	std::ref    (aeskey),  target_share_read[j],  std::ref(socketsPb), std::ref(socketsP2), 0, db_nitems-1, 
+                                          output[j],  flags[j], std::ref(final_correction_word[j]), computecw_array, std::ref(dpf_instance),  party, 5 * j, j));	 	  
+    }
+    
+    pool2.join();  
+   }
 
   boost::asio::write(socketsP2[0], boost::asio::buffer(dpf_instance, n_threads * sizeof(dpfP2))); // do this in parallel.
 
@@ -192,8 +207,8 @@ int main(int argc, char * argv[])
     
     end = std::chrono::steady_clock::now();
     elapsed_seconds = end-start;
-    std::cerr << "time to do filesio is: " << elapsed_seconds.count() << "s" << std::endl;;
-    
+
+    std::cerr << "communication cost = " << communication_cost << " bytes" << std::endl;
     #ifdef VERBOSE
      for(size_t j = 0; j < n_threads; ++j)
      {