duoram/share-conversion.h

void convert_shares(__m128i ** output, int8_t ** flags, size_t n_threads, size_t db_nitems, __m128i * final_correction_word, tcp::socket& sb, bool party)
{
	
	for(size_t j = 0; j < db_nitems; ++j)
	{		
		for(size_t k = 0; k < n_threads; ++k)
		{
			if(party)
			{
				//output[k][j] = -output[k][j];
				flags[k][j]  =  -flags[k][j]; 
			}
		}

		#ifdef DEBUG
			int8_t out = flags[0][j];
			int8_t out_rec; 

			boost::asio::write(sb, boost::asio::buffer(&out, sizeof(out)));
			boost::asio::read(sb, boost::asio::buffer(&out_rec, sizeof(out_rec)));
			out_rec = out_rec + out;



			__m128i out2 = output[0][j];
			__m128i out_rec2;	

			boost::asio::write(sb, boost::asio::buffer(&out2, sizeof(out2)));
			boost::asio::read(sb, boost::asio::buffer(&out_rec2, sizeof(out_rec2)));
			out_rec2 = out_rec2 + out2;
		#endif		
	}

for(size_t i = 0; i < n_threads; ++i)
{
	int64_t pm = 0;
	int64_t rb;
	arc4random_buf(&rb, sizeof(rb));
	for(size_t j = 0; j < db_nitems; ++j)
	{
		if(party)
		{
		  if(flags[i][j] != 0)	pm -= 1;
		}
		if(!party)
		{
		 if(flags[i][j] != 0)	pm += 1; 
		}
	}



	int64_t rb_reconstruction; 
	boost::asio::write(sb, boost::asio::buffer(&rb, sizeof(rb)));
	boost::asio::read(sb, boost::asio::buffer(&rb_reconstruction, sizeof(rb_reconstruction)));
	rb_reconstruction = rb_reconstruction + rb;


	int64_t pm_reconstruction; 
	boost::asio::write(sb, boost::asio::buffer(&pm, sizeof(pm)));
	boost::asio::read(sb, boost::asio::buffer(&pm_reconstruction, sizeof(pm_reconstruction)));
	pm_reconstruction = pm_reconstruction + pm;

 
 	int64_t finalcw_rec = 0;
 	boost::asio::write(sb, boost::asio::buffer(&final_correction_word[i][0], sizeof(final_correction_word[i][0])));
	boost::asio::read(sb, boost::asio::buffer(&finalcw_rec, sizeof(finalcw_rec)));
	finalcw_rec = finalcw_rec + final_correction_word[i][0];


	int64_t rbpm_fcw = (final_correction_word[i][0]) * pm_reconstruction;
	int64_t PM = pm + rb;
	int64_t PM_recv;
	boost::asio::write(sb, boost::asio::buffer(&PM, sizeof(PM)));
	boost::asio::read(sb, boost::asio::buffer(&PM_recv, sizeof(PM_recv)));
    
    int64_t * flags_  = (int64_t *)std::aligned_alloc(sizeof(node_t), db_nitems * sizeof(int64_t));
	for(size_t j = 0; j < db_nitems; ++j)
	{
		flags_[j] = (flags[i][j] * pm) + (flags[i][j] * PM_recv) + (flags[i][j] * rb);
	
		#ifdef DEBUG
			int64_t flags_rec;
			boost::asio::write(sb, boost::asio::buffer(&flags_[j], sizeof(flags_[j])));
			boost::asio::read(sb, boost::asio::buffer(&flags_rec, sizeof(flags_rec)));
			flags_rec = flags_rec + flags_[j];
		#endif
	}
 
	
		for(size_t j = 0; j < db_nitems; ++j)
		{
			flags_[j] += output[i][j][0]; 

			if(!party)
			{	
				if(flags[i][j] != 0) flags_[j] -= (rb_reconstruction) + rbpm_fcw;
			}
			if(party)
			{ 
				if(flags[i][j] != 0) flags_[j] += (rb_reconstruction) + rbpm_fcw;
			}

			#ifdef DEBUG
			int64_t flags_rec;
			boost::asio::write(sb, boost::asio::buffer(&flags_[j], sizeof(flags_[j])));
			boost::asio::read(sb, boost::asio::buffer(&flags_rec, sizeof(flags_rec)));
			flags_rec = flags_rec + flags_[j];

			if(flags_rec != 0)
			{
				std::cout << j << "---> flag_reconstruction  = " << flags_rec << std::endl;
		    }
		    #endif
		}
	
}

}