Use the new protobuf arena allocator.

Run script now takes a parameter tool to for instance "benchmark"

1 files changed, 33 insertions, 34 deletions

diff --git a/node/node_node.cpp b/node/node_node.cpp
index d859da9..27e8042 100644
--- a/node/node_node.cpp
+++ b/node/node_node.cpp
@@ -2,7 +2,7 @@
 #include "node.hpp"
 
 template <typename T>
-cmix_proto::PrePre fill_precomputation_pre_message(CMixContext& ctx, T const& rs, T const& ms) {
+void fill_precomputation_pre_message(CMixContext& ctx, cmix_proto::PrePre& prepre, T const& rs, T const& ms) {
 	if(start_mix(&ctx, rs.size()) != no_error) {
 		exit(-1);
 	}
@@ -18,8 +18,6 @@ cmix_proto::PrePre fill_precomputation_pre_message(CMixContext& ctx, T const& rs
 	}
 	BOOST_LOG_TRIVIAL(trace) << ss.str();
 	
-	cmix_proto::PrePre prepre;
-	
 	size_t len = get_group_element_array_size(&ctx);
 	std::vector<char*> r_ers(ms.size(), nullptr);
 	std::vector<char*> m_ers(ms.size(), nullptr);
@@ -48,14 +46,10 @@ cmix_proto::PrePre fill_precomputation_pre_message(CMixContext& ctx, T const& rs
 	) != no_error) {
 		exit(-1);
 	}
-	
-	return prepre;
 }
 
 template <typename T>
-cmix_proto::PreMix fill_precomputation_mix_message(CMixContext const& ctx, T const& rs, T const& ms) {
-	cmix_proto::PreMix premix;
-	
+void fill_precomputation_mix_message(CMixContext const& ctx, cmix_proto::PreMix& premix, T const& rs, T const& ms) {
 	size_t el_len = get_group_element_array_size(&ctx);
 	std::vector<char*> r_epirs(ms.size(), nullptr);
 	std::vector<char*> m_epirs(ms.size(), nullptr);
@@ -81,13 +75,10 @@ cmix_proto::PreMix fill_precomputation_mix_message(CMixContext const& ctx, T con
 		rsv.data(),
 		msv.data()
 	);
-	return premix;
 }
 
 template <typename T>
-cmix_proto::PrePost fill_precomputation_post_message(CMixContext& ctx, T const& rs, T const& ms) {
-	cmix_proto::PrePost prepost;
-	
+void fill_precomputation_post_message(CMixContext& ctx, cmix_proto::PrePost& prepost, T const& rs, T const& ms) {
 	size_t len = get_group_element_array_size(&ctx);
 	
 	std::vector<char*> r_epirs(ms.size(), nullptr);
@@ -114,14 +105,10 @@ cmix_proto::PrePost fill_precomputation_post_message(CMixContext& ctx, T const&
 		rsv.data(),
 		msv.data()
 	);
-	
-	return prepost;
 }
 
 template <typename T>
-cmix_proto::RealPre fill_realtime_pre_message(CMixContext& ctx, T const& hs, T const& ms, Node::ClientData const& data) {
-	cmix_proto::RealPre realpre;
-	
+void fill_realtime_pre_message(CMixContext& ctx, cmix_proto::RealPre& realpre, T const& hs, T const& ms, Node::ClientData const& data) {
 	size_t len = get_group_element_array_size(&ctx);
 	
 	std::vector<char*> msv1(ms.size(), nullptr);
@@ -146,14 +133,10 @@ cmix_proto::RealPre fill_realtime_pre_message(CMixContext& ctx, T const& hs, T c
 		msv2.data(),
 		gs.data()
 	);
-	
-	return realpre;
 }
 
 template <typename T>
-cmix_proto::RealMix fill_realtime_mix_message(CMixContext& ctx, T const& ms) {
-	cmix_proto::RealMix realmix;
-	
+void fill_realtime_mix_message(CMixContext& ctx, cmix_proto::RealMix& realmix, T const& ms) {
 	size_t len = get_group_element_array_size(&ctx);
 	std::vector<char*> mv(ms.size(), nullptr);
 	std::vector<char const*> msv(ms.size(), nullptr);
@@ -170,8 +153,6 @@ cmix_proto::RealMix fill_realtime_mix_message(CMixContext& ctx, T const& ms) {
 		mv.data(),
 		msv.data()
 	);
-	
-	return realmix;
 }
 
 void Node::handle_node_initialization(const cmix_proto::Initialization& init)
@@ -209,20 +190,28 @@ void Node::handle_node_secretkey(cmix_proto::SecretKey const& secret)
 
 void Node::handle_node_prepre(cmix_proto::PrePre const& pre) {
 	if(network_settings.is_first) {
-		cmix_proto::PreMix premix = fill_precomputation_mix_message(cmix_ctx, pre.r_er(), pre.m_er());
+		ArenaMessage<cmix_proto::PreMix> arena;
+		auto& premix = arena.get();
+		fill_precomputation_mix_message(cmix_ctx, premix, pre.r_er(), pre.m_er());
 		next_node.async_send(premix);
 	} else {
-		cmix_proto::PrePre prepre = fill_precomputation_pre_message(cmix_ctx, pre.r_er(), pre.m_er());
+		ArenaMessage<cmix_proto::PrePre> arena;
+		auto& prepre = arena.get();
+		fill_precomputation_pre_message(cmix_ctx, prepre, pre.r_er(), pre.m_er());
 		next_node.async_send(prepre);
 	}
 }
 
 void Node::handle_node_premix(cmix_proto::PreMix const& premix) {
 	if(network_settings.is_first) {
-		cmix_proto::PrePost prepost = fill_precomputation_post_message(cmix_ctx, premix.r_epirs(), premix.m_epirs());
+		ArenaMessage<cmix_proto::PrePost> arena;
+		auto& prepost = arena.get();
+		fill_precomputation_post_message(cmix_ctx, prepost, premix.r_epirs(), premix.m_epirs());
 		next_node.async_send(prepost);	
 	} else {
-		cmix_proto::PreMix n_premix = fill_precomputation_mix_message(cmix_ctx, premix.r_epirs(), premix.m_epirs());
+		ArenaMessage<cmix_proto::PreMix> arena;
+		auto& n_premix = arena.get();
+		fill_precomputation_mix_message(cmix_ctx, n_premix, premix.r_epirs(), premix.m_epirs());
 		next_node.async_send(n_premix);
 	}
 }
@@ -231,17 +220,23 @@ void Node::handle_node_prepost(cmix_proto::PrePost const& prepost) {
 	if(network_settings.is_first) {
 		start_realtime_phase();
 	} else {
-		cmix_proto::PrePost n_prepost = fill_precomputation_post_message(cmix_ctx, prepost.r_epirs(), prepost.m_epirs());
+		ArenaMessage<cmix_proto::PrePost> arena;
+		auto& n_prepost = arena.get();
+		fill_precomputation_post_message(cmix_ctx, n_prepost, prepost.r_epirs(), prepost.m_epirs());
 		next_node.async_send(n_prepost);
 	}
 }
 
 void Node::handle_node_realpre(cmix_proto::RealPre const& realpre) {
 	if(network_settings.is_first) {
-		cmix_proto::RealMix n_realmix = fill_realtime_mix_message(cmix_ctx, realpre.m());
-		next_node.async_send(n_realmix);
+		ArenaMessage<cmix_proto::RealMix> arena;
+		auto& realmix = arena.get();
+		fill_realtime_mix_message(cmix_ctx, realmix, realpre.m());
+		next_node.async_send(realmix);
 	} else {
-		cmix_proto::RealPre n_realpre = fill_realtime_pre_message(cmix_ctx, realpre.h(), realpre.m(), data);
+		ArenaMessage<cmix_proto::RealPre> arena;
+		auto& n_realpre = arena.get();
+		fill_realtime_pre_message(cmix_ctx, n_realpre, realpre.h(), realpre.m(), data);
 		next_node.async_send(n_realpre);
 	}
 }
@@ -250,7 +245,9 @@ void Node::handle_node_realmix(cmix_proto::RealMix const& realmix) {
 	if(network_settings.is_last) {
 		BOOST_LOG_TRIVIAL(trace) << "Doing the last step:";
 		
-		cmix_proto::RealMix n_realmix = fill_realtime_mix_message(cmix_ctx, realmix.m());
+		ArenaMessage<cmix_proto::RealMix> arena;
+		auto& n_realmix = arena.get();
+		fill_realtime_mix_message(cmix_ctx, n_realmix, realmix.m());
 		
 		size_t len = get_group_element_array_size(&cmix_ctx);
 		std::string str;
@@ -284,7 +281,9 @@ void Node::handle_node_realmix(cmix_proto::RealMix const& realmix) {
 			free(payload);
 		}
 	} else {
-		cmix_proto::RealMix n_realmix = fill_realtime_mix_message(cmix_ctx, realmix.m());
+		ArenaMessage<cmix_proto::RealMix> arena;
+		auto& n_realmix = arena.get();
+		fill_realtime_mix_message(cmix_ctx, n_realmix, realmix.m());
 		next_node.async_send(n_realmix);
 	}
 }