new spacing and adding functions to concatate filename with index

duoram-online/Makefile

@@ -24,24 +24,21 @@
 CXX = g++
 CXXFLAGS = -g -march=native -std=c++17 -Wall -pedantic -fopenmp -O3 -Wno-ignored-attributes -pthread
 LIBS = -lbsd
-FLAGS =  -DBOOST_ERROR_CODE_HEADER_ONLY -DThreeParty
+FLAGS =  -DBOOST_ERROR_CODE_HEADER_ONLY -DThreeParty -DDEBUG -DVERBOSE
 
-all: setup duoram0 duoram1 p2
+all: duoram0 duoram1 p2
 
-setup: p2.cpp setup.cpp duoram-utils.h duoram-read.h duoram-write.h duoram-refresh.h
-	$(CXX) $(CXXFLAGS) -o  setup setup.cpp $(LIBS) -I.
-
-p2: p2.cpp duoram-utils.h duoram-read.h duoram-write.h duoram-refresh.h
+p2: p2.cpp duoram-utils.h duoram-read.h duoram-write.h duoram-refresh.h readvectors.h
 	$(CXX) $(CXXFLAGS) -o  p2 p2.cpp $(LIBS) $(FLAGS) -I.
 
-duoram1: duoram.cpp duoram-utils.h duoram-read.h duoram-write.h duoram-refresh.h
+duoram1: duoram.cpp duoram-utils.h duoram-read.h duoram-write.h duoram-refresh.h readvectors.h
 	$(CXX) $(CXXFLAGS) -o duoram1 duoram.cpp $(LIBS) $(FLAGS) -DPARTY=1 -I.
 
-duoram0: duoram.cpp duoram-utils.h duoram-read.h duoram-write.h duoram-refresh.h
+duoram0: duoram.cpp duoram-utils.h duoram-read.h duoram-write.h duoram-refresh.h readvectors.h
 	$(CXX) $(CXXFLAGS) -o duoram0 duoram.cpp $(LIBS) $(FLAGS) -DPARTY=0 -I.
 
 clean: 
-	 rm p2 duoram0 duoram1 setup
+	 rm p2 duoram0 duoram1
 
 docs:
 	doxygen Doxyfile

duoram-online/duoram-read.h

@@ -1,3 +1,4 @@
+
 auto DuoramRead(bool party, size_t db_nitems, int64_t ri, int64_t where_to_read, tcp::socket&s2, tcp::socket& s2_b, tcp::socket& sb)
 {
     read_flags_for_reading(party, db_nitems);

duoram-online/duoram-utils.h

@@ -9,12 +9,10 @@ size_t duoram_progress[step::num_steps] = { 0 };
  
 
  
-// const size_t expo =  5;
-// const size_t db_nitems			  = 1ULL << expo;
 const size_t number_of_writes = 2;
 
 
-// const size_t number_of_ind_reads  = 5;
+ 
 
 typedef  int64_t DB_t;
 
@@ -51,7 +49,7 @@ DB_t * b;
 DB_t * c;
 DB_t * d;
 
-DB_t one_shareA, one_shareB, one_shareC;
+ 
  
 
 int8_t * reading_b;
@@ -62,130 +60,7 @@ int8_t * writing_b;
 int8_t * writing_c;
 int8_t * writing_d; 
 
-void generate_flags_and_standard_basis_vectors2(bool party, size_t db_nitems)
-{
-  for(size_t j = 0; j < db_nitems; ++j)
-  { 
-    reading_b[j] = 0;
-    reading_c[j] = 0;
-    reading_d[j] = 0;
-    
-    if(j > 5 && j < 42)
-    {  
-      reading_b[j] = 1;
-      reading_c[j] = 1;
-      reading_d[j] = 1;
-    }    
-    
-    if(j > 75 && (j % 3) == 0)
-    {
-      reading_b[j] = 1;
-      reading_c[j] = 1;
-      reading_d[j] = 1;
-    }  
-  } 
-    
-    if(party)
-    {
-     reading_b[target_index] = 1;
-     reading_c[target_index] = 1;
-     reading_d[target_index] = 1;
-   }
-
-      if(!party)
-      {
-            for(size_t j = 0; j < db_nitems; ++j)
-         {
-          reading_b[j] = -reading_b[j];
-          reading_c[j] = -reading_c[j];
-           reading_d[j] = -reading_d[j];
-         }
-   } 
-
-
-
-
-
-     for(size_t j = 0; j < db_nitems; ++j)
-    {
-      b[j] = j;
-      c[j] = j;
-      d[j] = j;
-
-        writing_b[j] = 0;
-      writing_c[j] = 0;
-      writing_d[j] = 0;
- 
-       if(j > 5 && j < 42)
-       {
-         writing_b[j] = 1;
-         writing_c[j] = 1;
-         writing_d[j] = 1;
-       }
-
-         if(j > 75 && (j % 3) == 0)
-       {
-         writing_b[j] = 1;
-         writing_c[j] = 1;
-         writing_d[j] = 1;
-       }
-    }
-
  
-     
-      if(party)
-      {
-            writing_b[target_index] = 1;
-         writing_c[target_index] = 1;
-         writing_d[target_index] = 1;
-       }
-
-      
-      if(party) 
-    {
-      // printf("PARTY 1\n");
-      // for(size_t j = 0; j < db_nitems; ++j)
-      // {
-      //    if(writing_b[j]) pm0 += 1;
-      //    if(writing_c[j]) pm1 += 1;
-      //    if(writing_d[j]) pm2 += 1;
-      // }
-    }
-    else
-     {
-      //    printf("PARTY 0\n");
-      //    for(size_t j = 0; j < db_nitems; ++j)
-      // {
-      //       if(writing_b[j]) pm0 -= 1;
-      //    if(writing_c[j]) pm1 -= 1;
-      //    if(writing_d[j]) pm2 -= 1;
-      // }
-
-      for(size_t j = 0; j < db_nitems; ++j)
-      {         
-         writing_b[j] = -writing_b[j]; 
-         writing_c[j] = -writing_c[j]; 
-         writing_d[j] = -writing_d[j];
-
-         b[j] = -b[j];
-         c[j] = -c[j];
-         d[j] = -d[j];      
-      }
-     }
-
-     if(party)
-     {
-      b[target_index] = -47920;
-      c[target_index] = -47920;
-      d[target_index] = -47920;     
-   }
-   else
-   {
-      b[target_index] = 0;
-      c[target_index] = 0;
-      d[target_index] = 0; 
-   }
-}
  void setup(DB_t * DB, DB_t * updated_DB, DB_t * blinded_DB_recv, DB_t * blinds, DB_t * updated_blinds, DB_t * updated_blinded_DB_recv, size_t db_nitems, bool party)
  {
  	for(size_t j = 0; j < db_nitems; ++j)
@@ -253,430 +128,35 @@ DB_t print_reconstruction(tcp::socket& sb, DB_t output)
 
 int read_database_shares(bool party, size_t db_nitems)
 {
-	if(party)
-	{
-		int const in { open( "DB1", O_RDONLY ) };
-		size_t r = read(in, DB,  db_nitems * sizeof(DB_t));
-		  
-	  if(r < 0) {
-  			perror("Read error");
-  			close(in);
-  			return 1;
-			}
-
-	}
-	
-	if(!party)
-	{
-		int const in { open( "DB0", O_RDONLY ) };
-		size_t r = read(in, DB,  db_nitems * sizeof(DB_t));
-		
-		if(r < 0) {
-    		 perror("Read error");
-    		 close(in);
-  		    return 1;
- 		 }
-	}
+    if(party)
+    {
+      int const in { open( "DB1", O_RDONLY ) };
+      size_t r = read(in, DB,  db_nitems * sizeof(DB_t));
+        
+      if(r < 0) {
+          perror("Read error");
+          close(in);
+          return 1;
+        }
 
+    }
+    if(!party)
+    {
+      int const in { open( "DB0", O_RDONLY ) };
+      size_t r = read(in, DB,  db_nitems * sizeof(DB_t));
+      
+      if(r < 0) {
+          perror("Read error");
+          close(in);
+            return 1;
+      }
+    }
 	return 0;
 }
 
 
 
 
-
-
-
-int read_flags(bool party, size_t db_nitems)
-{
-		if(!party)
-  	{
-	 	 int const in0 { open( "party0_read_flags_b", O_RDONLY ) };
-	   size_t r = read(in0, reading_b,  db_nitems * sizeof(reading_b[0]));	
- 		 if(r < 0) {
-     perror("Read error");
-     close(in0);
-     return 1;
- 		 }
-  
-     int const in1 { open( "party0_read_flags_c", O_RDONLY ) };
-		 r = read(in1, reading_c,  db_nitems * sizeof(reading_c[0]));
-		 if(r < 0) {
-     perror("Read error");
-     close(in1);
-     return 1;
- 		 }
-
-	   int const in2 { open( "party0_read_flags_d", O_RDONLY ) };
-		 r = read(in2, reading_d,  db_nitems * sizeof(reading_d[0]));	
-		 if(r < 0) {
-     perror("Read error");
-     close(in2);
-     return 1;
- 		 }
-
-
-
-		 int const in0_w { open( "party0_write_flags_b", O_RDONLY ) };
-	 	 r = read(in0_w, writing_b,  db_nitems * sizeof(writing_b[0]));	
-	 	 if(r < 0) {
-     perror("Read error");
-     close(in0_w);
-     return 1;
- 		 }
- 	   int const in1_w { open( "party0_write_flags_c", O_RDONLY ) };
-		 r = read(in1_w, writing_c,  db_nitems * sizeof(writing_c[0]));
-		 if(r < 0) {
-     perror("Read error");
-     close(in1_w);
-     return 1;
- 		 }
-		 int const in2_w { open( "party0_write_flags_d", O_RDONLY ) };
-		 r = read(in2_w, writing_d,  db_nitems * sizeof(writing_d[0]));	
-		 if(r < 0) {
-     perror("Read error");
-     close(in2_w);
-     return 1;
- 		 }
-
-
-
-		 int const in0_w_ { open( "party0_write_b", O_RDONLY ) };
-	 	 r = read(in0_w_, b,  db_nitems * sizeof(b[0]));	
-	 	 if(r < 0) {
-     perror("Read error");
-     close(in0_w_);
-     return 1;
- 		 }
- 	   int const in1_w_ { open( "party0_write_c", O_RDONLY ) };
-		 r = read(in1_w_, c,  db_nitems * sizeof(c[0]));
-		 if(r < 0) {
-     perror("Read error");
-     close(in1_w_);
-     return 1;
- 		 }
-		 int const in2_w_ { open( "party0_write_d", O_RDONLY ) };
-		 r = read(in2_w_, d,  db_nitems * sizeof(d[0]));	
-		 if(r < 0) {
-     perror("Read error");
-     close(in2_w_);
-     return 1;
- 		 }
-	}
-
-	if(party)
-	{
-		 int const in0 { open( "party1_read_flags_b", O_RDONLY ) };
-	 	 size_t r = read(in0, reading_b,  db_nitems * sizeof(reading_b[0]));	
-	 	 if(r < 0) {
-     perror("Read error");
-     close(in0);
-     return 1;
- 		 }
- 	   int const in1 { open( "party1_read_flags_c", O_RDONLY ) };
-		 r = read(in1, reading_c,  db_nitems * sizeof(reading_c[0]));
-		 if(r < 0) {
-     perror("Read error");
-     close(in1);
-     return 1;
- 		 }
-		 int const in2 { open( "party1_read_flags_d", O_RDONLY ) };
-		 r = read(in2, reading_d,  db_nitems * sizeof(reading_d[0]));	
-		 if(r < 0) {
-     perror("Read error");
-     close(in2);
-     return 1;
- 		 }
-
-
- 		 int const in0_w { open( "party1_write_flags_b", O_RDONLY ) };
-	 	 r = read(in0_w, writing_b,  db_nitems * sizeof(writing_b[0]));	
-	 	 if(r < 0) {
-     perror("Read error");
-     close(in0_w);
-     return 1;
- 		 }
- 	   int const in1_w { open( "party1_write_flags_c", O_RDONLY ) };
-		 r = read(in1_w, writing_c,  db_nitems * sizeof(writing_c[0]));
-		 if(r < 0) {
-     perror("Read error");
-     close(in1_w);
-     return 1;
- 		 }
-		 int const in2_w { open( "party1_write_flags_d", O_RDONLY ) };
-		 r = read(in2_w, writing_d,  db_nitems * sizeof(writing_d[0]));	
-		 if(r < 0) {
-     perror("Read error");
-     close(in2_w);
-     return 1;
- 		 }
-
-
- 		 int const in0_w_ { open( "party1_write_b", O_RDONLY ) };
-	 	 r = read(in0_w_, b,  db_nitems * sizeof(b[0]));	
-	 	 if(r < 0) {
-     perror("Read error");
-     close(in0_w);
-     return 1;
- 		 }
- 	   int const in1_w_ { open( "party1_write_c", O_RDONLY ) };
-		 r = read(in1_w_, c,  db_nitems * sizeof(c[0]));
-		 if(r < 0) {
-     perror("Read error");
-     close(in1_w);
-     return 1;
- 		 }
-		 int const in2_w_ { open( "party1_write_d", O_RDONLY ) };
-		 r = read(in2_w_, d,  db_nitems * sizeof(d[0]));	
-		 if(r < 0) {
-     perror("Read error");
-     close(in2_w);
-     return 1;
- 		 }
-	}
-
- 
-	return 0;	
-}
-
-
-int read_flags_for_reading(bool party, size_t db_nitems)
-{
-		if(!party)
-	{
-		int const in0 { open( "party0_read_flags_b", O_RDONLY ) };
-	 	size_t r = read(in0, reading_b,  db_nitems * sizeof(reading_b[0]));	
- 		 if(r < 0) {
-     perror("Read error");
-     close(in0);
-     return 1;
- 		 }
-  
-     int const in1 { open( "party0_read_flags_c", O_RDONLY ) };
-		 r = read(in1, reading_c,  db_nitems * sizeof(reading_c[0]));
-		 if(r < 0) {
-     perror("Read error");
-     close(in1);
-     return 1;
- 		 }
-
-	   int const in2 { open( "party0_read_flags_d", O_RDONLY ) };
-		 r = read(in2, reading_d,  db_nitems * sizeof(reading_d[0]));	
-		 if(r < 0) {
-     perror("Read error");
-     close(in2);
-     return 1;
-     }
-	}
-
-	if(party)
-	{
-		 int const in0 { open( "party1_read_flags_b", O_RDONLY ) };
-	 	 size_t r = read(in0, reading_b,  db_nitems * sizeof(reading_b[0]));	
-	 	 if(r < 0) {
-     perror("Read error");
-     close(in0);
-     return 1;
- 		 }
- 	   int const in1 { open( "party1_read_flags_c", O_RDONLY ) };
-		 r = read(in1, reading_c,  db_nitems * sizeof(reading_c[0]));
-		 if(r < 0) {
-     perror("Read error");
-     close(in1);
-     return 1;
- 		 }
-		 int const in2 { open( "party1_read_flags_d", O_RDONLY ) };
-		 r = read(in2, reading_d,  db_nitems * sizeof(reading_d[0]));	
-		 if(r < 0) {
-     perror("Read error");
-     close(in2);
-     return 1;
- 		 }
-
- 
-	}
-
- 
-	return 0;	
-}
-
-int read_flags_for_writing(bool party, size_t db_nitems)
-{
-		if(!party)
-	{
-
-		 int const in0_w { open( "party0_write_flags_b", O_RDONLY ) };
-	   size_t r = read(in0_w, writing_b,  db_nitems * sizeof(writing_b[0]));	
-	 	 if(r < 0) {
-     perror("Read error");
-     close(in0_w);
-     return 1;
- 		 }
- 	   int const in1_w { open( "party0_write_flags_c", O_RDONLY ) };
-		 r = read(in1_w, writing_c,  db_nitems * sizeof(writing_c[0]));
-		 if(r < 0) {
-     perror("Read error");
-     close(in1_w);
-     return 1;
- 		 }
-		 int const in2_w { open( "party0_write_flags_d", O_RDONLY ) };
-		 r = read(in2_w, writing_d,  db_nitems * sizeof(writing_d[0]));	
-		 if(r < 0) {
-     perror("Read error");
-     close(in2_w);
-     return 1;
- 		 }
-
- 
-	}
-
-	if(party)
-	{
- 		 int const in0_w { open( "party1_write_flags_b", O_RDONLY ) };
-	 	 size_t r = read(in0_w, writing_b,  db_nitems * sizeof(writing_b[0]));	
-	 	 if(r < 0) {
-     perror("Read error");
-     close(in0_w);
-     return 1;
- 		 }
- 	   int const in1_w { open( "party1_write_flags_c", O_RDONLY ) };
-		 r = read(in1_w, writing_c,  db_nitems * sizeof(writing_c[0]));
-		 if(r < 0) {
-     perror("Read error");
-     close(in1_w);
-     return 1;
- 		 }
-		 int const in2_w { open( "party1_write_flags_d", O_RDONLY ) };
-		 r = read(in2_w, writing_d,  db_nitems * sizeof(writing_d[0]));	
-		 if(r < 0) {
-     perror("Read error");
-     close(in2_w);
-     return 1;
- 		 }
-
-
- 
-	}
-
- 
-	return 0;	
-}
-
-
-int read_flags_for_updating(bool party, size_t db_nitems)
-{
-	if(!party)
-	{
-		 int const in0_w_ { open( "party0_write_b", O_RDONLY ) };
-	 	 size_t r = read(in0_w_, b,  db_nitems * sizeof(b[0]));	
-	 	 if(r < 0) {
-     perror("Read error");
-     close(in0_w_);
-     return 1;
- 		 }
- 	   int const in1_w_ { open( "party0_write_c", O_RDONLY ) };
-		 r = read(in1_w_, c,  db_nitems * sizeof(c[0]));
-		 if(r < 0) {
-     perror("Read error");
-     close(in1_w_);
-     return 1;
- 		 }
-		 int const in2_w_ { open( "party0_write_d", O_RDONLY ) };
-		 r = read(in2_w_, d,  db_nitems * sizeof(d[0]));	
-		 if(r < 0) {
-     perror("Read error");
-     close(in2_w_);
-     return 1;
- 		 }
-	}
-
-	if(party)
-	{
- 		 int const in0_w_ { open( "party1_write_b", O_RDONLY ) };
-	 	 size_t r = read(in0_w_, b,  db_nitems * sizeof(b[0]));	
-	 	 if(r < 0) {
-     perror("Read error");
-     close(in0_w_);
-     return 1;
- 		 }
- 	   int const in1_w_ { open( "party1_write_c", O_RDONLY ) };
-		 r = read(in1_w_, c,  db_nitems * sizeof(c[0]));
-		 if(r < 0) {
-     perror("Read error");
-     close(in1_w_);
-     return 1;
- 		 }
-		 int const in2_w_ { open( "party1_write_d", O_RDONLY ) };
-		 r = read(in2_w_, d,  db_nitems * sizeof(d[0]));	
-		 if(r < 0) {
-     perror("Read error");
-     close(in2_w_);
-     return 1;
- 		 }
-	}
-
- 
-	return 0;	
-}
-
- int read_flags_for_refreshing(size_t db_nitems)
- {
-        int const in1_w { open( "party0_write_flags_c", O_RDONLY ) };
-        size_t r = read(in1_w, writing_c,  db_nitems * sizeof(writing_c[0]));
-        if(r < 0) {
-        perror("Read error");
-        close(in1_w);
-        return 1;
-        }
-        
-        int const in2_w { open( "party1_write_flags_d", O_RDONLY ) };
-        r = read(in2_w, writing_d,  db_nitems * sizeof(writing_d[0])); 
-        if(r < 0) {
-        perror("Read error");
-        close(in2_w);
-        return 1;
-        }
-
-        int const in1_w_ { open( "party0_write_c", O_RDONLY ) };
-        r = read(in1_w_, c,  db_nitems * sizeof(c[0]));
-        if(r < 0) {
-        perror("Read error");
-        close(in1_w_);
-        return 1;
-        }
-        
-        int const in2_w_ { open( "party1_write_d", O_RDONLY ) };
-        r = read(in2_w_, d,  db_nitems * sizeof(d[0]));  
-        if(r < 0) {
-        perror("Read error");
-        close(in2_w_);
-        return 1;
-        }
-
-        return 0;
- }
-
-int read_flags_for_generating_cancellation_terms(size_t db_nitems)
-{
-     int const in2 { open( "party1_read_flags_d", O_RDONLY ) };
-     size_t r = read(in2, reading_d,  db_nitems * sizeof(reading_d[0])); 
-     if(r < 0) {
-     perror("Read error");
-     close(in2);
-     return 1;
-     }
-
-     int const in2_ { open( "party0_read_flags_c", O_RDONLY ) };
-     r = read(in2_, reading_c,  db_nitems * sizeof(reading_c[0])); 
-     if(r < 0) {
-     perror("Read error");
-     close(in2_);
-     return 1;
-     }
-   
-    return 0;
-}
-
 void generate_random_distinguished_points(bool party)
 {
 	if(party)
@@ -696,22 +176,22 @@ void generate_random_distinguished_points(bool party)
 }
 
 
+/* This function is never called*/
+template<typename T1> 
+void rotate_all( T1 * orginal_vector1, T1 * rotated_vector1,
+								 T1 * orginal_vector3, T1 * rotated_vector3,
+							   T1 * orginal_vector5, T1 * rotated_vector5, 
+								size_t rotate_by, size_t db_nitems)
+{
 
-// template<typename T1> 
-// void rotate_all( T1 * orginal_vector1, T1 * rotated_vector1,
-// 								 T1 * orginal_vector3, T1 * rotated_vector3,
-// 							   T1 * orginal_vector5, T1 * rotated_vector5, 
-// 								size_t rotate_by, size_t db_nitems)
-// {
-
-//  			 for(size_t j = 0; j < db_nitems; ++j)
-// 			 {
+ 			 for(size_t j = 0; j < db_nitems; ++j)
+			 {
 				
-// 			 	 rotated_vector1[(j + rotate_by) % db_nitems] = orginal_vector1[j];
-// 			 	 rotated_vector3[(j + rotate_by) % db_nitems] = orginal_vector3[j];
-// 			 	 rotated_vector5[(j + rotate_by) % db_nitems] = orginal_vector5[j];			 	 
-// 			 }
-// }
+			 	 rotated_vector1[(j + rotate_by) % db_nitems] = orginal_vector1[j];
+			 	 rotated_vector3[(j + rotate_by) % db_nitems] = orginal_vector3[j];
+			 	 rotated_vector5[(j + rotate_by) % db_nitems] = orginal_vector5[j];			 	 
+			 }
+}
 
 DB_t dot_product_with_bool(DB_t D[], int8_t flags[], size_t db_nitems, size_t rotate_by = 0)
 {

duoram-online/duoram.cpp

@@ -27,16 +27,17 @@ using socket_t = boost::asio::ip::tcp::socket;
 #include "prg_aes_impl.h"
 #include "block.h"  
 #include "duoram-utils.h"
+#include "readvectors.h"
 #include "duoram-read.h"
 #include "duoram-refresh.h"
 #include "duoram-write.h"
-#include "readvectors.h"
+
 
 
  
 void accept_conncections_from_Pb(boost::asio::io_context&io_context, std::vector<socket_t>& sockets_, int port, size_t j)
 {
- 	 tcp::acceptor acceptor_a(io_context, tcp::endpoint(tcp::v4(), port));
+  tcp::acceptor acceptor_a(io_context, tcp::endpoint(tcp::v4(), port));
 	 tcp::socket sb_a(acceptor_a.accept());
 	 sockets_[j] = std::move(sb_a);    
 }
@@ -46,34 +47,34 @@ void accept_conncections_from_Pb(boost::asio::io_context&io_context, std::vector
 int main(const int argc, const char * argv[])
 {
 	
-   size_t expo =  atoi(argv[3]);
-   size_t db_nitems = 1ULL << expo;
-   size_t number_of_writes	   =  atoi(argv[4]);
-   size_t number_of_ind_reads  =  atoi(argv[5]); 
-   size_t number_of_dep_reads  =  atoi(argv[6]);
-   size_t number_of_accesses   =  atoi(argv[7]);
+  size_t expo =  atoi(argv[3]);
+  size_t db_nitems = 1ULL << expo;
+  size_t number_of_writes	    =  atoi(argv[4]);
+  size_t number_of_ind_reads  =  atoi(argv[5]); 
+  size_t number_of_dep_reads  =  atoi(argv[6]);
+  size_t number_of_accesses   =  atoi(argv[7]);
    
-   reading_temp = (DB_t *) std::aligned_alloc(sizeof(__m256i), db_nitems * sizeof(DB_t));
-   DB = (DB_t *) std::aligned_alloc(sizeof(__m256i), db_nitems * sizeof(DB_t));
-   updated_DB = (DB_t *) std::aligned_alloc(sizeof(__m256i), db_nitems * sizeof(DB_t));
-   blinded_DB = (DB_t *) std::aligned_alloc(sizeof(__m256i), db_nitems * sizeof(DB_t));
+  reading_temp = (DB_t *) std::aligned_alloc(sizeof(__m256i), db_nitems * sizeof(DB_t));
+  DB = (DB_t *) std::aligned_alloc(sizeof(__m256i), db_nitems * sizeof(DB_t));
+  updated_DB = (DB_t *) std::aligned_alloc(sizeof(__m256i), db_nitems * sizeof(DB_t));
+  blinded_DB = (DB_t *) std::aligned_alloc(sizeof(__m256i), db_nitems * sizeof(DB_t));
   	
-    blinded_DB_recv = (DB_t *) std::aligned_alloc(sizeof(__m256i), db_nitems * sizeof(DB_t));
-    updated_blinded_DB_recv = (DB_t *) std::aligned_alloc(sizeof(__m256i), db_nitems * sizeof(DB_t));
-	b = (DB_t *) std::aligned_alloc(sizeof(__m256i), db_nitems * sizeof(DB_t));
-    c = (DB_t *) std::aligned_alloc(sizeof(__m256i), db_nitems * sizeof(DB_t));
-    d = (DB_t *) std::aligned_alloc(sizeof(__m256i), db_nitems * sizeof(DB_t));
+  blinded_DB_recv = (DB_t *) std::aligned_alloc(sizeof(__m256i), db_nitems * sizeof(DB_t));
+  updated_blinded_DB_recv = (DB_t *) std::aligned_alloc(sizeof(__m256i), db_nitems * sizeof(DB_t));
+	 
+  b = (DB_t *) std::aligned_alloc(sizeof(__m256i), db_nitems * sizeof(DB_t));
+  c = (DB_t *) std::aligned_alloc(sizeof(__m256i), db_nitems * sizeof(DB_t));
+  d = (DB_t *) std::aligned_alloc(sizeof(__m256i), db_nitems * sizeof(DB_t));
 		
-	reading_b = (int8_t *) malloc(db_nitems * sizeof(int8_t));
-	reading_c = (int8_t *) malloc(db_nitems * sizeof(int8_t));
-	reading_d = (int8_t *) malloc(db_nitems * sizeof(int8_t));
-	writing_b = (int8_t *) malloc(db_nitems * sizeof(int8_t));
-	writing_c = (int8_t *) malloc(db_nitems * sizeof(int8_t));
-	writing_d = (int8_t *) malloc(db_nitems * sizeof(int8_t));
+	 reading_b = (int8_t *) malloc(db_nitems * sizeof(int8_t));
+	 reading_c = (int8_t *) malloc(db_nitems * sizeof(int8_t));
+	 reading_d = (int8_t *) malloc(db_nitems * sizeof(int8_t));
+	 writing_b = (int8_t *) malloc(db_nitems * sizeof(int8_t));
+	 writing_c = (int8_t *) malloc(db_nitems * sizeof(int8_t));
+	 writing_d = (int8_t *) malloc(db_nitems * sizeof(int8_t));
 
  
- 
- size_t * rotate_by_ = new size_t[number_of_writes];
+  size_t * rotate_by_ = new size_t[number_of_writes];
 
 
   boost::asio::io_context io_context;
@@ -84,32 +85,32 @@ int main(const int argc, const char * argv[])
   const std::string host2 = (argc < 3) ? "127.0.0.1" : argv[2];
 
   
-   bool party;
-   const size_t number_of_sockets = 40;
-   std::vector<socket_t> sockets_;
-   for(size_t j = 0; j < number_of_sockets + 1; ++j)
-   {
- 		tcp::socket emptysocket(io_context);
- 		sockets_.emplace_back(std::move(emptysocket));
-  	}
-	sockets_.reserve(number_of_sockets + 1);
+  bool party;
+  const size_t number_of_sockets = 40;
+  std::vector<socket_t> sockets_;
+  for(size_t j = 0; j < number_of_sockets + 1; ++j)
+  {
+ 	 	tcp::socket emptysocket(io_context);
+ 		 sockets_.emplace_back(std::move(emptysocket));
+  }
+	 sockets_.reserve(number_of_sockets + 1);
  	printf("number_of_sockets = %zu\n", number_of_sockets);
 
-	std::vector<socket_t> sockets_2;
+	 std::vector<socket_t> sockets_2;
 
-	std::vector<int> ports;
-	for(size_t j = 0; j < number_of_sockets; ++j) 
-	{
-		int port = 6000;
-		ports.push_back(port + j);
-	}
+	 std::vector<int> ports;
+	 for(size_t j = 0; j < number_of_sockets; ++j) 
+	 {
+	 	int port = 6000;
+		 ports.push_back(port + j);
+ 	}
 	
-	std::vector<int> ports2_0;
-	for(size_t j = 0; j < number_of_sockets; ++j) 
-	{
-		int port = 8000;
-		ports2_0.push_back(port + j);
-	}
+	 std::vector<int> ports2_0;
+	 for(size_t j = 0; j < number_of_sockets; ++j) 
+	 {
+		 int port = 8000;
+		 ports2_0.push_back(port + j);
+	 }
 
 	std::vector<int> ports2_1;
 	for(size_t j = 0; j < number_of_sockets; ++j) 
@@ -120,11 +121,11 @@ int main(const int argc, const char * argv[])
 
 
 
-   #if (PARTY == 0)    
+#if (PARTY == 0)    
   	 
-  	party = false;
+ 	party = false;
 
-	#ifdef ThreeParty	
+ 	#ifdef ThreeParty	
 		for(size_t j = 0; j < number_of_sockets; ++j)
 		{
 			tcp::socket sb_a(io_context);
@@ -132,41 +133,40 @@ int main(const int argc, const char * argv[])
 			sockets_2.emplace_back(std::move(sb_a)); 
 		}
 	#endif
- 
-    for(size_t j = 0; j < number_of_sockets; ++j)
-    {
-  	  tcp::socket sb_a(io_context);
-      boost::asio::connect(sb_a, resolver.resolve({host1, std::to_string(ports[j])}));
- 	    sockets_[j] = std::move(sb_a); 
-    }
+  for(size_t j = 0; j < number_of_sockets; ++j)
+  {
+   tcp::socket sb_a(io_context);
+    boost::asio::connect(sb_a, resolver.resolve({host1, std::to_string(ports[j])}));
+    sockets_[j] = std::move(sb_a); 
+  }
  #else	
 
 	party = true;	
  	
 	#ifdef ThreeParty	
-	  for(size_t j = 0; j < number_of_sockets; ++j)
-      {
-  	  	 tcp::socket sb_a(io_context);
-     	boost::asio::connect(sb_a, resolver.resolve({host2, std::to_string(ports2_1[j])}));
-   		sockets_2.emplace_back(std::move(sb_a)); 
-	  }
+	 for(size_t j = 0; j < number_of_sockets; ++j)
+  {
+ 	 tcp::socket sb_a(io_context);
+  	boost::asio::connect(sb_a, resolver.resolve({host2, std::to_string(ports2_1[j])}));
+  	sockets_2.emplace_back(std::move(sb_a)); 
+	 }
 	#endif
    
-   boost::asio::thread_pool pool2(number_of_sockets); 
-   for(size_t j = 0; j < number_of_sockets; ++j)
-   {
-		boost::asio::post(pool2, std::bind(accept_conncections_from_Pb,  std::ref(io_context), std::ref(sockets_), ports[j],  j));
-   } 
-   pool2.join();
+  boost::asio::thread_pool pool2(number_of_sockets); 
+  for(size_t j = 0; j < number_of_sockets; ++j)
+  {
+	   boost::asio::post(pool2, std::bind(accept_conncections_from_Pb,  std::ref(io_context), std::ref(sockets_), ports[j],  j));
+  } 
+  pool2.join();
 
 #endif
  
  
 	generate_random_distinguished_points(party);
   
-    AES_KEY aeskey;	  
-    blinds =	(DB_t *) std::aligned_alloc(sizeof(__m256i), db_nitems * sizeof(DB_t));	
-    updated_blinds =	(DB_t *) std::aligned_alloc(sizeof(__m256i), db_nitems * sizeof(DB_t));
+ AES_KEY aeskey;	  
+ blinds =	(DB_t *) std::aligned_alloc(sizeof(__m256i), db_nitems * sizeof(DB_t));	
+ updated_blinds =	(DB_t *) std::aligned_alloc(sizeof(__m256i), db_nitems * sizeof(DB_t));
 
 	size_t * where_to_write = new size_t[number_of_writes];
 	size_t * where_to_read_dependent = new size_t[number_of_dep_reads];
@@ -198,14 +198,14 @@ int main(const int argc, const char * argv[])
 			updated_blinded_DB_recv[j] = blinded_DB_recv[j];
 		}
 
-	  	int64_t ri, ri_recv;
-	  	arc4random_buf(&ri, sizeof(ri));
-	  	ri = ri % db_nitems;
-	  	boost::asio::write(sockets_[0], boost::asio::buffer(&ri, sizeof(ri)));
-	  	boost::asio::read(sockets_[0], boost::asio::buffer(&ri_recv, sizeof(ri_recv)));
+		int64_t ri, ri_recv;
+		arc4random_buf(&ri, sizeof(ri));
+		ri = ri % db_nitems;
+		boost::asio::write(sockets_[0], boost::asio::buffer(&ri, sizeof(ri)));
+		boost::asio::read(sockets_[0], boost::asio::buffer(&ri_recv, sizeof(ri_recv)));
 		
-	  	std::cout << "ri = " << ri << std::endl;
-      	if(party) ri = 2 - ri_recv;
+	std::cout << "ri = " << ri << std::endl;
+ if(party) ri = 2 - ri_recv;
 
 		#ifdef VERBOSE
 			boost::asio::write(sockets_[0], boost::asio::buffer(&ri, sizeof(ri)));
@@ -252,7 +252,7 @@ int main(const int argc, const char * argv[])
 				rotate_by_[w] = WritePb_[w].shift + WritePb_recv[w].shift;		 			
 
 				#ifdef VERBOSE 		
-					std::cout << "print database: " << std::endl;
+					std::cout << "print database (prints the non-zero database entries): " << std::endl;
 					/* The definition of reconstruct_database appears in duoram-utils.h */							
 					reconstruct_database(sockets_[0],  DB, db_nitems);
 				#endif
@@ -295,18 +295,18 @@ int main(const int argc, const char * argv[])
 		#endif
 
 		for(size_t w = 0; w < number_of_writes; ++w)
- 		{	
+ 	{	
 			
 			/*The definition of DuoramUpdate appears in duoram-write.h*/  	 
 		  	DuoramUpdate(party,  db_nitems,  rotate_by_[w],  DB, updated_DB, writing_b, b,  CW[w],  update_message[w],  writing_c, writing_d, c, d);
 			
-			#ifdef DEBUG		
-				#ifdef ThreeParty
+		 	#ifdef DEBUG		
+				 #ifdef ThreeParty
 					/*The definition debug_ appears in duoram-utils.h*/  
 					debug_(sockets_2[0], sockets_[0], db_nitems);
-				#endif
-			#endif
- 	 	}  
+			 	#endif
+		 	#endif
+ 	}  
 
    	auto end_writes = std::chrono::steady_clock::now();
    	std::chrono::duration<double> elapsed_seconds_writes = end_writes - start_writes;
@@ -358,11 +358,11 @@ int main(const int argc, const char * argv[])
   	auto end_ind_reads = std::chrono::steady_clock::now();
    	std::chrono::duration<double> elapsed_seconds_ind_reads = end_ind_reads - start_ind_reads;
     printf("elapsed_seconds_ind_reads = %f\n",elapsed_seconds_ind_reads.count());
-	printf("\n\n================================= INDEPENDENT READS END  =================================\n\n\n");	
-
+	std::cout << std::endl << std::endl << "============== INDEPENDENT READS END  ==============" << std::endl << std::endl;
 	auto start_dep_reads = std::chrono::steady_clock::now();
 	
-	printf("\n\n================================= DEPENDENT READS START  =================================\n\n\n");	
+ 
+	std::cout << std::endl << std::endl << "============== DEPENDENT READS START  ==============" << std::endl << std::endl;
 	DB_t * read_out_dependent_reads = new DB_t[number_of_dep_reads];
 	 for(size_t r = 0; r < number_of_dep_reads; ++r)
 	 {
@@ -374,20 +374,19 @@ int main(const int argc, const char * argv[])
 		  #endif
 	  }
 		
-		auto end_dep_reads = std::chrono::steady_clock::now();
-  		std::chrono::duration<double> elapsed_seconds_dep_reads = end_dep_reads - start_dep_reads;
- 		printf("elapsed_seconds_dep_reads = %f\n",elapsed_seconds_dep_reads.count());
-		printf("\n\n================================= DEPENDENT READS END  =================================n\n");
-
+	auto end_dep_reads = std::chrono::steady_clock::now();
+	std::chrono::duration<double> elapsed_seconds_dep_reads = end_dep_reads - start_dep_reads;
+	printf("elapsed_seconds_dep_reads = %f\n",elapsed_seconds_dep_reads.count()); 
+	std::cout << std::endl << std::endl << "============== DEPENDENT READS END  ==============" << std::endl << std::endl;
 
-		printf("\n\n\n\n\n-----------------------------------------------------------------------------------------------------------\n\n\n\n\n\n");
+	 
 #endif
 }  
-   auto end_total = std::chrono::steady_clock::now();
-   std::chrono::duration<double> elapsed_seconds_total = end_total - start_total;
-   printf("elapsed_seconds_total = %f\n",elapsed_seconds_total.count());
+ auto end_total = std::chrono::steady_clock::now();
+ std::chrono::duration<double> elapsed_seconds_total = end_total - start_total;
+ printf("elapsed_seconds_total = %f\n",elapsed_seconds_total.count());
 
-   free(reading_temp);
+free(reading_temp);
 
 	return 0;
 }

duoram-online/p2.cpp

@@ -12,45 +12,36 @@
 #include <cstring>      // std::memcpy
 #include <bsd/stdlib.h> // arc4random_buf
 #include <x86intrin.h>  // SSE and AVX intrinsics
-#include "prg.h"
-#include "prg_aes_impl.h" 
-#include "block.h"
 #include <chrono>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <fstream> 
-#include <../boost/asio.hpp>
 #include <mutex>
+#include <../boost/asio.hpp>
 #include <../boost/lexical_cast.hpp>
  
- 
- 
 using boost::asio::ip::tcp;
-//#include "network.h"
 
+#include "prg.h"
+#include "prg_aes_impl.h" 
+#include "block.h" 
 #include "duoram-utils.h"
- 
-using boost::asio::ip::tcp;
+#include "readvectors.h"  
 
- 
- 
- 
 
 DB_t * X0;
-DB_t * X1;
- 
+DB_t * X1; 
 DB_t alpha;
 
- 
 typedef __m128i leaf_t;
 typedef __m128i node_t;
-__m128i seed0_, seed1_, seed2_;
+ 
   
 const size_t target = 22;
 const leaf_t val =   _mm_set1_epi8(0x01);
 
- using socket_t = boost::asio::ip::tcp::socket;
+using socket_t = boost::asio::ip::tcp::socket;
  
 
 using namespace std;
@@ -81,24 +72,22 @@ void refresh_blinds(int8_t writing_c[], int8_t writing_d[],
  
 
 
- void accept_conncections_from_Pb(boost::asio::io_context&io_context, std::vector<socket_t>& sockets_0, int port, size_t j)
+void accept_conncections_from_Pb(boost::asio::io_context&io_context, std::vector<socket_t>& sockets_0, int port, size_t j)
 {
   tcp::acceptor acceptor2_(io_context, tcp::endpoint(tcp::v4(), port));
   tcp::socket s2(acceptor2_.accept());
-  sockets_0[j] = std::move(s2);
-  // sockets_0.emplace_back(std::move(s2)); 
+  sockets_0[j] = std::move(s2); 
 }
 
 int main(int argc, char* argv[])
 { 
-  
-
   size_t expo =  atoi(argv[3]);
-  size_t db_nitems        = 1ULL << expo;
+  size_t db_nitems            = 1ULL << expo;
   size_t number_of_ind_writes = atoi(argv[4]);;
   size_t number_of_ind_reads  = atoi(argv[5]);;
   size_t number_of_dep_reads  = atoi(argv[6]);;
   size_t number_of_accesses   =  atoi(argv[7]);
+  
   b = (DB_t *) std::aligned_alloc(sizeof(__m256i), db_nitems * sizeof(DB_t));
   c = (DB_t *) std::aligned_alloc(sizeof(__m256i), db_nitems * sizeof(DB_t));
   d = (DB_t *) std::aligned_alloc(sizeof(__m256i), db_nitems * sizeof(DB_t));
@@ -110,22 +99,19 @@ int main(int argc, char* argv[])
   writing_c = (int8_t *) malloc(db_nitems * sizeof(int8_t));
   writing_d = (int8_t *) malloc(db_nitems * sizeof(int8_t));
    
-   boost::asio::io_context io_context;
+  boost::asio::io_context io_context;
     
-   AES_KEY aeskey;
-    
-   arc4random_buf(&seed0_, sizeof(__m128i));
-   arc4random_buf(&seed1_, sizeof(__m128i));
-   arc4random_buf(&seed2_, sizeof(__m128i));
-      
-   const size_t number_of_sockets = 40;
+  AES_KEY aeskey;
+       
+  const size_t number_of_sockets = 40;
 
-   std::vector<int> ports2_0;
-   for(size_t j = 0; j < number_of_sockets; ++j) 
-   {
-     int port = 8000;
-     ports2_0.push_back(port + j);
-   }
+  std::vector<int> ports2_0;
+  
+  for(size_t j = 0; j < number_of_sockets; ++j) 
+  {
+    int port = 8000;
+    ports2_0.push_back(port + j);
+  }
 
    std::vector<int> ports2_1;
    
@@ -135,128 +121,124 @@ int main(int argc, char* argv[])
      ports2_1.push_back(port + j);
    }
 
+   std::vector<socket_t> sockets_0;
+   std::vector<socket_t> sockets_1;
+   sockets_0.reserve(number_of_sockets + 1);
+   sockets_1.reserve(number_of_sockets + 1);
 
-      std::vector<socket_t> sockets_0;
-      std::vector<socket_t> sockets_1;
-      sockets_0.reserve(number_of_sockets + 1);
-      sockets_1.reserve(number_of_sockets + 1);
+   boost::asio::thread_pool pool2(number_of_sockets * 2); 
 
-      boost::asio::thread_pool pool2(number_of_sockets * 2); 
+   for(size_t j = 0; j < number_of_sockets; ++j)
+   {
+     boost::asio::post(pool2, std::bind(accept_conncections_from_Pb,  std::ref(io_context), std::ref(sockets_1), ports2_1[j],  j));
+   }
 
-      for(size_t j = 0; j < number_of_sockets; ++j)
-      {
-        boost::asio::post(pool2, std::bind(accept_conncections_from_Pb,  std::ref(io_context), std::ref(sockets_1), ports2_1[j],  j));
-      }
 
-   
-      for(size_t j = 0; j < number_of_sockets; ++j)
-      {
-        boost::asio::post(pool2, std::bind(accept_conncections_from_Pb,  std::ref(io_context), std::ref(sockets_0), ports2_0[j],  j));
-      }
-
-      pool2.join();
+   for(size_t j = 0; j < number_of_sockets; ++j)
+   {
+     boost::asio::post(pool2, std::bind(accept_conncections_from_Pb,  std::ref(io_context), std::ref(sockets_0), ports2_0[j],  j));
+   }
 
+   pool2.join();
 
- 
-  X0 = (DB_t *) std::aligned_alloc(sizeof(__m256i), db_nitems * sizeof(DB_t));
-  X1 = (DB_t *) std::aligned_alloc(sizeof(__m256i), db_nitems * sizeof(DB_t));
+   X0 = (DB_t *) std::aligned_alloc(sizeof(__m256i), db_nitems * sizeof(DB_t));
+   X1 = (DB_t *) std::aligned_alloc(sizeof(__m256i), db_nitems * sizeof(DB_t));
     
- for(size_t j = 0; j < db_nitems; ++j)
- {
+  for(size_t j = 0; j < db_nitems; ++j)
+  {
    X0[j] = 0;
    X1[j] = 0; 
- }
+  }
 
+  
+  DuORAM_Write * WriteP0_recv = new DuORAM_Write[number_of_ind_writes];
+  DuORAM_Write * WriteP1_recv = new DuORAM_Write[number_of_ind_writes];
+
+  DB_t * Gamma0_ = new DB_t[number_of_ind_writes];
+  DB_t * Gamma1_ = new DB_t[number_of_ind_writes];
+  DB_t * update_message0 = new DB_t[number_of_ind_writes];
+  DB_t * update_message1 = new DB_t[number_of_ind_writes];
+  DB_t * FCW = new DB_t[number_of_ind_writes];
  
- DuORAM_Write * WriteP0_recv = new DuORAM_Write[number_of_ind_writes];
- DuORAM_Write * WriteP1_recv = new DuORAM_Write[number_of_ind_writes];
-
- DB_t * Gamma0_ = new DB_t[number_of_ind_writes];
- DB_t * Gamma1_ = new DB_t[number_of_ind_writes];
- DB_t * update_message0 = new DB_t[number_of_ind_writes];
- DB_t * update_message1 = new DB_t[number_of_ind_writes];
- DB_t * FCW = new DB_t[number_of_ind_writes];
- 
- for(size_t i = 0; i < number_of_accesses; ++i)
- {
-    for(size_t w = 0; w < number_of_ind_writes; ++w)
-    {
-      read_flags_for_refreshing(db_nitems);
+  for(size_t i = 0; i < number_of_accesses; ++i)
+  {
+     for(size_t w = 0; w < number_of_ind_writes; ++w)
+     {
+       read_flags_for_refreshing(db_nitems);
 
-      size_t rotate_by_ = WriteP0_recv[w].shift + WriteP1_recv[w].shift;
+       size_t rotate_by_ = WriteP0_recv[w].shift + WriteP1_recv[w].shift;
      
-      auto [Gamma0, Gamma1] = generate_cancelation_terms(writing_c, writing_d, db_nitems, rotate_by_);
-      Gamma0_[w] = Gamma0;
-      Gamma1_[w] = Gamma1; 
- 
-      boost::asio::read(sockets_0[0], boost::asio::buffer(&WriteP0_recv[w],  sizeof(DuORAM_Write)));
-      boost::asio::read(sockets_1[0], boost::asio::buffer(&WriteP1_recv[w],  sizeof(DuORAM_Write)));
-      boost::asio::write(sockets_0[1], boost::asio::buffer(&Gamma0_[w], sizeof(DB_t))); 
-      boost::asio::write(sockets_1[1], boost::asio::buffer(&Gamma1_[w], sizeof(DB_t)));
-
-      boost::asio::read(sockets_0[2], boost::asio::buffer(&update_message0[w],  sizeof(DB_t))); 
-      boost::asio::read(sockets_1[2], boost::asio::buffer(&update_message1[w],  sizeof(DB_t)));
-      FCW[w] = update_message0[w] + update_message1[w];      
-    }
-
-    for(size_t w = 0; w < number_of_ind_writes; ++w)
-    {
-      size_t rotate_by_ = WriteP0_recv[w].shift + WriteP1_recv[w].shift;
-      refresh_blinds(writing_c, writing_d, c, d, FCW[w], FCW[w], db_nitems, -rotate_by_);
+       auto [Gamma0, Gamma1] = generate_cancelation_terms(writing_c, writing_d, db_nitems, rotate_by_);
+       Gamma0_[w] = Gamma0;
+       Gamma1_[w] = Gamma1; 
+ 
+       boost::asio::read(sockets_0[0], boost::asio::buffer(&WriteP0_recv[w],  sizeof(DuORAM_Write)));
+       boost::asio::read(sockets_1[0], boost::asio::buffer(&WriteP1_recv[w],  sizeof(DuORAM_Write)));
+       boost::asio::write(sockets_0[1], boost::asio::buffer(&Gamma0_[w], sizeof(DB_t))); 
+       boost::asio::write(sockets_1[1], boost::asio::buffer(&Gamma1_[w], sizeof(DB_t)));
+       boost::asio::read(sockets_0[2], boost::asio::buffer(&update_message0[w],  sizeof(DB_t))); 
+       boost::asio::read(sockets_1[2], boost::asio::buffer(&update_message1[w],  sizeof(DB_t)));
+       
+       FCW[w] = update_message0[w] + update_message1[w];      
+     }
+
+     for(size_t w = 0; w < number_of_ind_writes; ++w)
+     {
+       size_t rotate_by_ = WriteP0_recv[w].shift + WriteP1_recv[w].shift;
+       refresh_blinds(writing_c, writing_d, c, d, FCW[w], FCW[w], db_nitems, -rotate_by_);
    
-      #ifdef DEBUG
-      for(size_t j = 0; j < db_nitems; ++j)
-      {
-        boost::asio::write(sockets_0[0], boost::asio::buffer(&X0[j], sizeof(X0[j]))); //DEBUG
-        boost::asio::write(sockets_1[0], boost::asio::buffer(&X1[j], sizeof(X1[j]))); //DUBUG
-      }
-      #endif
-    }
-
-    DB_t * Gamma0_reads = new DB_t[number_of_ind_reads];
-    DB_t * Gamma1_reads = new DB_t[number_of_ind_reads];
+       #ifdef DEBUG
+       for(size_t j = 0; j < db_nitems; ++j)
+       {
+         boost::asio::write(sockets_0[0], boost::asio::buffer(&X0[j], sizeof(X0[j]))); //DEBUG
+         boost::asio::write(sockets_1[0], boost::asio::buffer(&X1[j], sizeof(X1[j]))); //DUBUG
+       }
+       #endif
+     }
+
+     DB_t * Gamma0_reads = new DB_t[number_of_ind_reads];
+     DB_t * Gamma1_reads = new DB_t[number_of_ind_reads];
 
-    
-    size_t * reads_shift_from_P0 = new size_t[number_of_ind_reads];
-    size_t * reads_shift_from_P1 = new size_t[number_of_ind_reads];
-    size_t *  rotate              = new size_t[number_of_ind_reads];
-    
-    boost::asio::read(sockets_0[3], boost::asio::buffer(reads_shift_from_P0, number_of_ind_reads * sizeof(size_t))); 
-    boost::asio::read(sockets_1[3], boost::asio::buffer(reads_shift_from_P1, number_of_ind_reads * sizeof(size_t)));
-
-    for(size_t r = 0; r < number_of_ind_reads; ++r)
-    {  
-      #ifdef DEBUG
-        std::cout << "rotate[r] " << rotate[r] << std::endl;
-      #endif
-      rotate[r] = reads_shift_from_P0[r] + reads_shift_from_P1[r];
-
-      read_flags_for_generating_cancellation_terms(db_nitems); 
-      
-      auto [Gamma0, Gamma1] =   generate_cancelation_terms(reading_c, reading_d, db_nitems, rotate[r]);
      
-      Gamma0_reads[r] = Gamma0;
-      Gamma1_reads[r] = Gamma1;
-    }
-
-    boost::asio::write(sockets_0[4], boost::asio::buffer(Gamma0_reads, number_of_ind_reads * sizeof(DB_t)));  
-    boost::asio::write(sockets_1[4], boost::asio::buffer(Gamma1_reads, number_of_ind_reads * sizeof(DB_t)));
-
-    for(size_t d = 0; d < number_of_dep_reads; ++d)
-    {  
+     size_t * reads_shift_from_P0 = new size_t[number_of_ind_reads];
+     size_t * reads_shift_from_P1 = new size_t[number_of_ind_reads];
+     size_t *  rotate              = new size_t[number_of_ind_reads];
+     
+     boost::asio::read(sockets_0[3], boost::asio::buffer(reads_shift_from_P0, number_of_ind_reads * sizeof(size_t))); 
+     boost::asio::read(sockets_1[3], boost::asio::buffer(reads_shift_from_P1, number_of_ind_reads * sizeof(size_t)));
+
+     for(size_t r = 0; r < number_of_ind_reads; ++r)
+     {  
+       #ifdef VERBOSE
+         std::cout << "rotate[r] " << rotate[r] << std::endl;
+       #endif
+       rotate[r] = reads_shift_from_P0[r] + reads_shift_from_P1[r];
+       read_flags_for_generating_cancellation_terms(db_nitems); 
+       auto [Gamma0, Gamma1] =   generate_cancelation_terms(reading_c, reading_d, db_nitems, rotate[r]);     
+       Gamma0_reads[r] = Gamma0;
+       Gamma1_reads[r] = Gamma1;
+     }
+
+     boost::asio::write(sockets_0[4], boost::asio::buffer(Gamma0_reads, number_of_ind_reads * sizeof(DB_t)));  
+     boost::asio::write(sockets_1[4], boost::asio::buffer(Gamma1_reads, number_of_ind_reads * sizeof(DB_t)));
+
+     for(size_t d = 0; d < number_of_dep_reads; ++d)
+     {  
        size_t shifts0, shifts1, rotate;
        boost::asio::read(sockets_0[5], boost::asio::buffer(&shifts0, sizeof(shifts0)));
        boost::asio::read(sockets_1[5], boost::asio::buffer(&shifts1, sizeof(shifts1)));
        rotate = shifts0 + shifts1;
-        
+         
        read_flags_for_generating_cancellation_terms(db_nitems);
-        
+         
        auto [Gamma0, Gamma1] =   generate_cancelation_terms(reading_c, reading_d, db_nitems, rotate);
        boost::asio::write(sockets_0[6], boost::asio::buffer(&Gamma0, sizeof(Gamma0)));  
        boost::asio::write(sockets_1[6], boost::asio::buffer(&Gamma1, sizeof(Gamma1)));
-    }
-}
+     }
+  }
+
   return 0;
+
 }
 
  

duoram-online/readvectors.h

@@ -1,29 +1,196 @@
-
+void concatanate_index(char const * filename, char tmp[100], size_t index)
+{
+	 strcpy(tmp, filename);
+  strcat(tmp, std::to_string(index).c_str());
+}
 
 
 int read_final_correction_word(bool party, DB_t& FCW_read)
 {
-    		if(!party)
+  if(!party)
 		{
-			int const in0 { open( "FCW0", O_RDONLY ) };
-	 		size_t r = read(in0, &FCW_read,   sizeof(FCW_read));	
- 		 	if(r < 0) {
-     		perror("Read error");
-    	 	close(in0);
-	     	return 1;
- 		 	}
+   char tmp[100];
+   concatanate_index("preprocflags/FCW0", tmp, 0);
+			int const in0 { open(tmp, O_RDONLY ) };
+	 	size_t r = read(in0, &FCW_read,   sizeof(FCW_read));	
+   if(r < 0) perror("Read error");
 		}
-		if(party)
+		
+  if(party)
 		{
-			int const in0 { open( "FCW1", O_RDONLY ) };
-	 		size_t r = read(in0, &FCW_read,   sizeof(FCW_read));	
- 		 	if(r < 0) {
-     		perror("Read error");
-    	 	close(in0);
-	     	return 1;
- 		 	}
+   char tmp[100];
+   concatanate_index("preprocflags/FCW1", tmp, 0);
+		 int const in0 { open(tmp, O_RDONLY ) };
+	 	size_t r = read(in0, &FCW_read,   sizeof(FCW_read));	
+ 		if(r < 0) perror("Read error");
 		}
 
-        return 0;
+  return 0;
+}
+
+int read_flags_for_reading(bool party, size_t db_nitems)
+{
+	if(!party)
+	{
+   char tmp[100];
+   concatanate_index("preprocflags/party0_read_flags_b", tmp, 0);
+	 	int const in0 { open(tmp, O_RDONLY ) };
+	 	size_t r = read(in0, reading_b,  db_nitems * sizeof(reading_b[0]));	
+   if(r < 0) perror("Read error");
+  
+   concatanate_index("preprocflags/party0_read_flags_c", tmp, 0);
+   int const in1 { open( tmp, O_RDONLY ) };
+	 	r = read(in1, reading_c,  db_nitems * sizeof(reading_c[0]));
+   if(r < 0) perror("Read error");
+
+   concatanate_index("preprocflags/party0_read_flags_d", tmp, 0);
+	  int const in2 { open( tmp, O_RDONLY ) };
+	  r = read(in2, reading_d,  db_nitems * sizeof(reading_d[0]));	
+   if(r < 0) perror("Read error");
+	}
+
+	if(party)
+	{
+   char tmp[100];
+  
+   concatanate_index("preprocflags/party1_read_flags_b", tmp, 0);
+		 int const in0 { open(tmp, O_RDONLY ) };
+	 	size_t r = read(in0, reading_b,  db_nitems * sizeof(reading_b[0]));	
+	 	if(r < 0) perror("Read error");
+
+   concatanate_index("preprocflags/party1_read_flags_c", tmp, 0);
+ 	 int const in1 { open(tmp, O_RDONLY ) };
+		 r = read(in1, reading_c,  db_nitems * sizeof(reading_c[0]));
+		 if(r < 0) perror("Read error");
+    
+   concatanate_index("preprocflags/party1_read_flags_d", tmp, 0);
+		 int const in2 { open(tmp, O_RDONLY ) };
+		 r = read(in2, reading_d,  db_nitems * sizeof(reading_d[0]));	
+   if(r < 0) perror("Read error");
+}
+
+ 
+	return 0;	
+}
+
+int read_flags_for_writing(bool party, size_t db_nitems)
+{
+	if(!party)
+	{
+    char tmp[100];
+    concatanate_index("preprocflags/party0_write_flags_b", tmp, 0);
+	   int const in0_w { open(tmp, O_RDONLY ) };
+    size_t r = read(in0_w, writing_b,  db_nitems * sizeof(writing_b[0]));	
+    if(r < 0) perror("Read error");
+
+    concatanate_index("preprocflags/party0_write_flags_c", tmp, 0);	   
+	   int const in1_w { open( tmp, O_RDONLY ) };
+    r = read(in1_w, writing_c,  db_nitems * sizeof(writing_c[0]));
+    if(r < 0) perror("Read error");
+	
+    concatanate_index("preprocflags/party0_write_flags_d", tmp, 0);
+	   int const in2_w { open( tmp, O_RDONLY ) };
+   	r = read(in2_w, writing_d,  db_nitems * sizeof(writing_d[0]));	
+    if(r < 0) perror("Read error");
+	}
+
+	if(party)
+	{
+   char tmp[100];
+   concatanate_index("preprocflags/party1_write_flags_b", tmp, 0);
+ 		int const in0_w { open( tmp, O_RDONLY ) };
+	 	size_t r = read(in0_w, writing_b,  db_nitems * sizeof(writing_b[0]));	
+	 	if(r < 0) perror("Read error");
+
+   concatanate_index("preprocflags/party1_write_flags_c", tmp, 0);
+   int const in1_w { open(tmp, O_RDONLY ) };
+		 r = read(in1_w, writing_c,  db_nitems * sizeof(writing_c[0]));
+   if(r < 0) perror("Read error");
+
+		 concatanate_index("preprocflags/party1_write_flags_d", tmp, 0);
+		 int const in2_w { open( tmp, O_RDONLY ) };
+		 r = read(in2_w, writing_d,  db_nitems * sizeof(writing_d[0]));	
+	  if(r < 0) perror("Read error");
+	}
+
+	 return 0;	
+}
+
+ int read_flags_for_refreshing(size_t db_nitems)
+ {
+   char tmp[100];
+   concatanate_index("preprocflags/P2_party0_write_flags_c", tmp, 0);
+   int const in1_w { open(tmp, O_RDONLY ) };
+   size_t r = read(in1_w, writing_c,  db_nitems * sizeof(writing_c[0]));
+   if(r < 0) perror("Read error");
+   
+   concatanate_index("preprocflags/P2_party1_write_flags_d", tmp, 0);
+   int const in2_w { open(tmp, O_RDONLY ) };
+   r = read(in2_w, writing_d,  db_nitems * sizeof(writing_d[0])); 
+   if(r < 0) perror("Read error");
+
+   concatanate_index("preprocflags/P2_party0_write_c", tmp, 0);
+   int const in1_w_ { open(tmp, O_RDONLY ) };
+   r = read(in1_w_, c,  db_nitems * sizeof(c[0]));
+   if(r < 0) perror("Read error");
+   
+   concatanate_index("preprocflags/P2_party1_write_d", tmp, 0);
+   int const in2_w_ { open(tmp, O_RDONLY ) };
+   r = read(in2_w_, d,  db_nitems * sizeof(d[0]));  
+   if(r < 0) perror("Read error");
+
+   return 0;
+ }
+
+int read_flags_for_generating_cancellation_terms(size_t db_nitems)
+{
+    char tmp[100];
+    concatanate_index("preprocflags/P2_party1_read_flags_d", tmp, 0);
+    int const in2 { open(tmp, O_RDONLY ) };
+    size_t r = read(in2, reading_d,  db_nitems * sizeof(reading_d[0])); 
+    if(r < 0) perror("Read error");
+
+    concatanate_index("preprocflags/P2_party0_read_flags_c", tmp, 0);
+    int const in2_ { open(tmp, O_RDONLY ) };
+    r = read(in2_, reading_c,  db_nitems * sizeof(reading_c[0])); 
+    if(r < 0) perror("Read error");
+   
+   return 0;
+}
+
+
+int read_flags_for_updating(bool party, size_t db_nitems)
+{
+	if(!party)
+	{
+		 int const in0_w_ { open( "preprocflags/party0_write_b0", O_RDONLY ) };
+		 size_t r = read(in0_w_, b,  db_nitems * sizeof(b[0]));	
+	  if(r < 0) perror("Read error");
+ 	
+   int const in1_w_ { open( "preprocflags/party0_write_c0", O_RDONLY ) };
+		 r = read(in1_w_, c,  db_nitems * sizeof(c[0]));
+   if(r < 0) perror("Read error");
+		 
+   int const in2_w_ { open( "preprocflags/party0_write_d0", O_RDONLY ) };
+		 r = read(in2_w_, d,  db_nitems * sizeof(d[0]));	
+   if(r < 0) perror("Read error");
+	}
+
+	if(party)
+	{
+ 	int const in0_w_ { open( "preprocflags/party1_write_b0", O_RDONLY ) };
+	 size_t r = read(in0_w_, b,  db_nitems * sizeof(b[0]));	
+  if(r < 0) perror("Read error");
+ 	
+  int const in1_w_ { open( "preprocflags/party1_write_c0", O_RDONLY ) };
+		r = read(in1_w_, c,  db_nitems * sizeof(c[0]));
+  if(r < 0) perror("Read error");
+		
+  int const in2_w_ { open( "preprocflags/party1_write_d0", O_RDONLY ) };
+		 r = read(in2_w_, d,  db_nitems * sizeof(d[0]));	
+  if(r < 0) perror("Read error");
+	}
 
+ 
+	return 0;	
 }