2014 network limit 1.1 +utils +toc -doc -drmonero

Update of the PR with network limits

works very well for all speeds
(but remember that low download speed can stop upload
because we then slow down downloading of blockchain
requests too)

more debug options

fixed pedantic warnings in our code
should work again on Mac OS X and FreeBSD
fixed warning about size_t
tested on Debian, Ubuntu, Windows(testing now)

TCP options and ToS (QoS) flag
FIXED peer number limit
FIXED some spikes in ingress/download
FIXED problems when other up and down limit

9 files changed, 293 insertions, 183 deletions

diff --git a/src/p2p/connection_basic.cpp b/src/p2p/connection_basic.cpp
index 35b0d4c8e..0e2fd5942 100644
--- a/src/p2p/connection_basic.cpp
+++ b/src/p2p/connection_basic.cpp
@@ -78,6 +78,7 @@
 #include "../../contrib/epee/include/net/abstract_tcp_server2.h"
 
 #include "../../contrib/otshell_utils/utils.hpp"
+#include "data_logger.hpp"
 using namespace nOT::nUtils;
 
 // TODO:
@@ -146,31 +147,31 @@ connection_basic::connection_basic(boost::asio::io_service& io_service, std::ato
 { 
 	++ref_sock_count; // increase the global counter
 	mI->m_peer_number = sock_number.fetch_add(1); // use, and increase the generated number
-	_note("Spawned connection p2p#"<<mI->m_peer_number<<" currently we have sockets count:" << m_ref_sock_count);
+
+	string remote_addr_str = "?";
+	try { remote_addr_str = socket_.remote_endpoint().address().to_string(); } catch(...){} ;
+
+	_note("Spawned connection p2p#"<<mI->m_peer_number<<" to " << remote_addr_str << " currently we have sockets count:" << m_ref_sock_count);
 	boost::filesystem::create_directories("log/dr-monero/net/");
-	/*boost::asio::SettableSocketOption option;// = new boost::asio::SettableSocketOption();
-	option.level(IPPROTO_IP);
-	option.name(IP_TOS);
-	option.value(&tos);
-	option.size = sizeof(tos);
-	socket_.set_option(option);*/
-	// TODO socket options
 }
 
 connection_basic::~connection_basic() {
-	_note("Destructing connection p2p#"<<mI->m_peer_number);
+	string remote_addr_str = "?";
+	try { remote_addr_str = socket_.remote_endpoint().address().to_string(); } catch(...){} ;
+	_note("Destructing connection p2p#"<<mI->m_peer_number << " to " << remote_addr_str);
 }
 
 void connection_basic::set_rate_up_limit(uint64_t limit) {
-	save_limit_to_file(limit);
+	
+	// TODO remove __SCALING_FACTOR...
+	const double SCALING_FACTOR = 2.1; // to acheve the best performance
+	limit *= SCALING_FACTOR;
 	{
-		// TODO remove __SCALING_FACTOR...
-		const double SCALING_FACTOR = 2.25; // to acheve the best performance
-		limit *= SCALING_FACTOR;
 		CRITICAL_REGION_LOCAL(	network_throttle_manager::m_lock_get_global_throttle_out );
 		network_throttle_manager::get_global_throttle_out().set_target_speed(limit);
+		network_throttle_manager::get_global_throttle_out().set_real_target_speed(limit / SCALING_FACTOR);
 	}
-	//	connection_basic_pimpl::m_throttle_global.m_out.set_target_speed(limit);
+	save_limit_to_file(limit);
 }
 
 void connection_basic::set_rate_down_limit(uint64_t limit) {
@@ -186,36 +187,30 @@ void connection_basic::set_rate_down_limit(uint64_t limit) {
     save_limit_to_file(limit);
 }
 
-void connection_basic::set_rate_limit(uint64_t limit) {
-	// TODO
-}
-void connection_basic::set_kill_limit (uint64_t limit) {
-       {
-         CRITICAL_REGION_LOCAL(        network_throttle_manager::m_lock_get_global_throttle_in );
-               network_throttle_manager::get_global_throttle_in().set_target_kill(limit);
-       }
-
-       {
-         CRITICAL_REGION_LOCAL(        network_throttle_manager::m_lock_get_global_throttle_out );
-               network_throttle_manager::get_global_throttle_out().set_target_kill(limit);
-       }
-
-       {
-         CRITICAL_REGION_LOCAL(        network_throttle_manager::m_lock_get_global_throttle_inreq );
-               network_throttle_manager::get_global_throttle_inreq().set_target_kill(limit);
-       }
-}
 
 void connection_basic::save_limit_to_file(int limit) {
     // saving limit to file
-    std::ofstream file;
-    file.open("log/dr-monero/limit.info");
-    file << limit;
-}
-
-void connection_basic::set_rate_autodetect(uint64_t limit) {
-	// TODO
-	LOG_PRINT_L0("inside connection_basic we set autodetect (this is additional notification)..");
+    if (!epee::net_utils::data_logger::m_save_graph)
+		return;
+    std::ofstream file_up, file_down;
+    file_up.open("log/dr-monero/limit_up.info", std::ofstream::out | std::ofstream::app);
+    file_up.precision(8);
+    file_down.open("log/dr-monero/limit_down.info", std::ofstream::out | std::ofstream::app);
+    file_down.precision(8);
+    using namespace boost::chrono;
+	auto point = steady_clock::now();
+	auto time_from_epoh = point.time_since_epoch();
+	auto s = duration_cast< seconds >( time_from_epoh ).count();
+
+    {
+         CRITICAL_REGION_LOCAL(        network_throttle_manager::m_lock_get_global_throttle_out );
+               file_up << s << " " << network_throttle_manager::get_global_throttle_out().get_terget_speed() / 1024 << "\n";
+	}
+	
+    {
+         CRITICAL_REGION_LOCAL(        network_throttle_manager::m_lock_get_global_throttle_in );
+               file_down << s << " " << network_throttle_manager::get_global_throttle_in().get_terget_speed() / 1024 << "\n";
+	}
 }
  
 void connection_basic::set_tos_flag(int tos) {
@@ -230,39 +225,30 @@ void connection_basic::sleep_before_packet(size_t packet_size, int phase,  int q
 	double delay=0; // will be calculated
 	do
 	{ // rate limiting
-		//XXX 
-		/*if (::cryptonote::core::get_is_stopping()) { 
-			_dbg1("We are stopping - so abort sleep");
-			return;
-		}*/
 		if (m_was_shutdown) { 
 			_dbg2("m_was_shutdown - so abort sleep");
 			return;
 		}
 
 		{ 
-	  	CRITICAL_REGION_LOCAL(	network_throttle_manager::m_lock_get_global_throttle_out );
+			CRITICAL_REGION_LOCAL(	network_throttle_manager::m_lock_get_global_throttle_out );
 			delay = network_throttle_manager::get_global_throttle_out().get_sleep_time_after_tick( packet_size ); // decission from global
 		}
 
-		
 		delay *= 0.50;
-		delay = 0; // XXX
 		if (delay > 0) {
-			//delay += rand2*0.1;
-            		long int ms = (long int)(delay * 1000);
-			_info_c("net/sleep", "Sleeping in " << __FUNCTION__ << " for " << ms << " ms before packet_size="<<packet_size); // XXX debug sleep
+            long int ms = (long int)(delay * 1000);
+			_info_c("net/sleep", "Sleeping in " << __FUNCTION__ << " for " << ms << " ms before packet_size="<<packet_size); // debug sleep
 			_dbg1("sleep in sleep_before_packet");
-			boost::this_thread::sleep(boost::posix_time::milliseconds( ms ) ); // TODO randomize sleeps
+			epee::net_utils::data_logger::get_instance().add_data("sleep_up", ms);
+			boost::this_thread::sleep(boost::posix_time::milliseconds( ms ) );
 		}
 	} while(delay > 0);
 
 // XXX LATER XXX
 	{
 	  CRITICAL_REGION_LOCAL(	network_throttle_manager::m_lock_get_global_throttle_out );
-		network_throttle_manager::get_global_throttle_out().handle_trafic_tcp( packet_size ); // increase counter - global
-		//epee::critical_region_t<decltype(m_throttle_global_lock)> guard(m_throttle_global_lock); // *** critical *** 
-		//m_throttle_global.m_out.handle_trafic_tcp( packet_size ); // increase counter - global
+		network_throttle_manager::get_global_throttle_out().handle_trafic_exact( packet_size * 700); // increase counter - global
 	}
 
 }
@@ -271,34 +257,12 @@ void connection_basic::set_start_time() {
 	m_start_time = network_throttle_manager::get_global_throttle_out().get_time_seconds();
 }
 
-void connection_basic::do_send_handler_start(const void* ptr , size_t cb ) {
-	_fact_c("net/out/size", "*** do_sen() called for packet="<<cb<<" B");
-    sleep_before_packet(cb,1,-1);
-	// set_start_time();
-}
-
-void connection_basic::do_send_handler_delayed(const void* ptr , size_t cb ) {
-	// CRITICAL_REGION_LOCAL(network_throttle_manager::m_lock_get_global_throttle_out);
-	// auto sending_time = network_throttle_manager::get_global_throttle_out().get_time_seconds() - m_start_time; // wrong? --r
-}
-
 void connection_basic::do_send_handler_write(const void* ptr , size_t cb ) {
 	sleep_before_packet(cb,1,-1);
 	_info_c("net/out/size", "handler_write (direct) - before ASIO write, for packet="<<cb<<" B (after sleep)");
 	set_start_time();
 }
 
-void connection_basic::do_send_handler_stop(const void* ptr , size_t cb ) {
-}
-
-void connection_basic::do_send_handler_after_write(const boost::system::error_code& e, size_t cb) {
-	// CRITICAL_REGION_LOCAL(network_throttle_manager::m_lock_get_global_throttle_out);
-	// auto sending_time = network_throttle_manager::get_global_throttle_out().get_time_seconds() - m_start_time;
-	// lag: if current sending time > max sending time
-	//if (sending_time > 0.1) network_throttle_manager::get_global_throttle_out().set_overheat(sending_time); // TODO
-
-}
-
 void connection_basic::do_send_handler_write_from_queue( const boost::system::error_code& e, size_t cb, int q_len ) {
 	sleep_before_packet(cb,2,q_len);
 	_info_c("net/out/size", "handler_write (after write, from queue="<<q_len<<") - before ASIO write, for packet="<<cb<<" B (after sleep)");
@@ -306,49 +270,14 @@ void connection_basic::do_send_handler_write_from_queue( const boost::system::er
 	set_start_time();
 }
 
-void connection_basic::do_read_handler_start(const boost::system::error_code& e, std::size_t bytes_transferred) { // from read, after read completion
-	const size_t packet_size = bytes_transferred;
-	{
-	  CRITICAL_REGION_LOCAL(	network_throttle_manager::m_lock_get_global_throttle_in );
-	 // sleep_before_packet(packet_size * __SCALING_FACTOR, 1, -1); // TODO remove __SCALING_FACTOR
-		network_throttle_manager::get_global_throttle_in().handle_trafic_tcp( packet_size ); // increase counter - global
-		// epee::critical_region_t<decltype(mI->m_throttle_global_lock)> guard(mI->m_throttle_global_lock); // *** critical *** 
-		// mI->m_throttle_global.m_in.handle_trafic_tcp( packet_size ); // increase counter - global	
-	}
-}
-
-void connection_basic::logger_handle_net_peer(size_t size, bool io) { // network data written
-        // TODO OPTIMIZE! do NOT reopen idiotically :)
-        std::ostringstream oss;
-    std::string filename;
-    if (io) { // write
-        double time = network_throttle_manager::get_global_throttle_in().get_time_seconds() ;
-        oss << "log/dr-monero/net/in-peer-" << (mI->m_peer_number) << ".dat" << std::ends;
-        filename = oss.str();
-        network_throttle_manager::get_global_throttle_out().logger_handle_net(filename,time,size);
-    }
-    else { // read
-        double time = network_throttle_manager::get_global_throttle_out().get_time_seconds() ;
-        oss << "log/dr-monero/net/out-peer-" << (mI->m_peer_number) << ".dat" << std::ends;
-        filename = oss.str();
-        network_throttle_manager::get_global_throttle_in().logger_handle_net(filename,time,size);
-    }
-}
-
 void connection_basic::logger_handle_net_read(size_t size) { // network data read
-    std::string filename = "log/dr-monero/net/in-all.data";
-
-    double time = network_throttle_manager::get_global_throttle_in().get_time_seconds() ;
-    network_throttle_manager::get_global_throttle_in().logger_handle_net(filename, time, size);
-    logger_handle_net_peer(size,0);
+    size /= 1024;
+    epee::net_utils::data_logger::get_instance().add_data("download", size);
 }
 
 void connection_basic::logger_handle_net_write(size_t size) {
-    std::string filename = "log/dr-monero/net/out-all.data";
-    double time = network_throttle_manager::get_global_throttle_out().get_time_seconds() ;
-    network_throttle_manager::get_global_throttle_out().logger_handle_net(filename, time, size);
-    logger_handle_net_peer(size,1);
-
+    size /= 1024;
+    epee::net_utils::data_logger::get_instance().add_data("upload", size);	
 }
 
 double connection_basic::get_sleep_time(size_t cb) {
@@ -356,6 +285,10 @@ double connection_basic::get_sleep_time(size_t cb) {
     return t;
 }
 
+void connection_basic::set_save_graph(bool save_graph) {
+	epee::net_utils::data_logger::m_save_graph = save_graph;
+}
+
 
 } // namespace
 } // namespace
diff --git a/src/p2p/connection_basic.hpp b/src/p2p/connection_basic.hpp
index 1b5a2c8ad..e9fdc3add 100644
--- a/src/p2p/connection_basic.hpp
+++ b/src/p2p/connection_basic.hpp
@@ -99,17 +99,11 @@ class connection_basic { // not-templated base class for rapid developmet of som
 		virtual ~connection_basic();
 
 		// various handlers to be called from connection class:
-		void do_send_handler_start(const void * ptr , size_t cb);
-		void do_send_handler_delayed(const void * ptr , size_t cb);
 		void do_send_handler_write(const void * ptr , size_t cb);
-		void do_send_handler_stop(const void * ptr , size_t cb);
-		void do_send_handler_after_write( const boost::system::error_code& e, size_t cb ); // from handle_write
 		void do_send_handler_write_from_queue(const boost::system::error_code& e, size_t cb , int q_len); // from handle_write, sending next part
-		void do_read_handler_start(const boost::system::error_code& e, std::size_t bytes_transferred); // from read, after read completion
 
 		void logger_handle_net_write(size_t size); // network data written
 		void logger_handle_net_read(size_t size); // network data read
-		void logger_handle_net_peer(size_t size, bool io);
 
 		void set_start_time();
 
@@ -117,9 +111,6 @@ class connection_basic { // not-templated base class for rapid developmet of som
 		
 		static void set_rate_up_limit(uint64_t limit);
 		static void set_rate_down_limit(uint64_t limit);
-		static void set_rate_limit(uint64_t limit);
-		static void set_rate_autodetect(uint64_t limit);
-		static void set_kill_limit (uint64_t limit);
 
 		// config misc
 		static void set_tos_flag(int tos); // ToS / QoS flag
@@ -129,6 +120,8 @@ class connection_basic { // not-templated base class for rapid developmet of som
 		void sleep_before_packet(size_t packet_size, int phase, int q_len); // execute a sleep ; phase is not really used now(?)
 		static void save_limit_to_file(int limit); ///< for dr-monero
 		static double get_sleep_time(size_t cb);
+		
+		static void set_save_graph(bool save_graph);
 };
 
 } // nameserver
diff --git a/src/p2p/data_logger.cpp b/src/p2p/data_logger.cpp
new file mode 100644
index 000000000..6a8eb25be
--- /dev/null
+++ b/src/p2p/data_logger.cpp
@@ -0,0 +1,81 @@
+#include "data_logger.hpp"
+
+#include <boost/chrono.hpp>
+#include <chrono>
+
+namespace epee
+{
+namespace net_utils
+{
+	data_logger &data_logger::get_instance()
+	{
+		static data_logger instance;
+		return instance;
+	}
+	
+	data_logger::data_logger()
+	{
+		//create timer
+		std::shared_ptr<std::thread> logger_thread(new std::thread([&]()
+		{
+			while (true)
+			{
+				std::this_thread::sleep_for(std::chrono::seconds(1));
+				saveToFile();
+			}
+		}));
+		logger_thread->detach();
+		
+		mFilesMap["peers"] = data_logger::fileData("log/dr-monero/peers.data");
+		mFilesMap["download"] = data_logger::fileData("log/dr-monero/net/in-all.data");
+		mFilesMap["upload"] = data_logger::fileData("log/dr-monero/net/out-all.data");
+		mFilesMap["request"] = data_logger::fileData("log/dr-monero/net/req-all.data");
+		mFilesMap["sleep_down"] = data_logger::fileData("log/dr-monero/down_sleep_log.data");
+		mFilesMap["sleep_up"] = data_logger::fileData("log/dr-monero/up_sleep_log.data");
+		
+	}
+	
+	void data_logger::add_data(std::string filename, unsigned int data)
+	{
+		if (mFilesMap.find(filename) == mFilesMap.end())
+			return; // TODO: exception
+			
+		mFilesMap[filename].mDataToSave += data;
+	}
+	
+	double data_logger::fileData::get_current_time()
+	{
+		using namespace boost::chrono;
+		auto point = steady_clock::now();
+		auto time_from_epoh = point.time_since_epoch();
+		auto ms = duration_cast< milliseconds >( time_from_epoh ).count();
+		double ms_f = ms;
+		return ms_f / 1000.;
+	}
+	
+	data_logger::fileData::fileData(std::string pFile)
+	{
+		mFile = std::make_shared<std::ofstream> (pFile);
+	}
+	
+	void data_logger::fileData::save()
+	{
+		if (!data_logger::m_save_graph)
+			return;
+		*mFile << static_cast<int>(get_current_time()) << " " << mDataToSave << std::endl;
+	}
+	
+	void data_logger::saveToFile()
+	{
+		 std::lock_guard<std::mutex> lock(mSaveMutex);
+		 for (auto &element : mFilesMap)
+		 {
+			 element.second.save();
+			 element.second.mDataToSave = 0;
+		 }
+	}
+	
+std::atomic<bool> data_logger::m_save_graph(false);
+
+} // namespace
+} // namespace
diff --git a/src/p2p/data_logger.hpp b/src/p2p/data_logger.hpp
new file mode 100644
index 000000000..2b8503df3
--- /dev/null
+++ b/src/p2p/data_logger.hpp
@@ -0,0 +1,46 @@
+#ifndef INCLUDED_p2p_data_logger_hpp
+#define INCLUDED_p2p_data_logger_hpp
+
+#include <string>
+#include <map>
+#include <fstream>
+#include <memory>
+#include <thread>
+#include <mutex>
+#include <atomic>
+
+namespace epee
+{
+namespace net_utils
+{
+	
+	class data_logger {
+		public:
+			static data_logger &get_instance();
+			data_logger(const data_logger &ob) = delete;
+			data_logger(data_logger &&ob) = delete;
+			void add_data(std::string filename, unsigned int data);
+			static std::atomic<bool> m_save_graph;
+		private:
+			data_logger();
+			class fileData
+			{
+				public:
+					fileData(){}
+					fileData(std::string pFile);
+					
+					std::shared_ptr<std::ofstream> mFile;
+					long int mDataToSave = 0;
+					static double get_current_time();
+					void save();
+			};
+			
+			std::map <std::string, fileData> mFilesMap;
+			std::mutex mSaveMutex;
+			void saveToFile();
+	};
+	
+} // namespace
+} // namespace
+
+#endif
diff --git a/src/p2p/net_node.h b/src/p2p/net_node.h
index 48737193e..ea7d5c383 100644
--- a/src/p2p/net_node.h
+++ b/src/p2p/net_node.h
@@ -86,7 +86,10 @@ namespace nodetool
 		m_no_igd(false),
 		m_hide_my_port(false),
 		m_network_id(std::move(network_id))
-    {}
+    {
+		m_number_of_out_peers = 0;
+		m_save_graph = false;
+	}
 
     static void init_options(boost::program_options::options_description& desc);
 
@@ -225,6 +228,12 @@ namespace nodetool
 
 	public:
     config m_config; // TODO was private, add getters?
+    std::atomic<unsigned int> m_number_of_out_peers;
+	void set_save_graph(bool save_graph)
+	{
+		m_save_graph = save_graph;
+		epee::net_utils::connection_basic::set_save_graph(save_graph);
+	}
 
 	private:
     std::string m_config_folder;
@@ -237,6 +246,7 @@ namespace nodetool
     bool m_allow_local_ip;
     bool m_hide_my_port;
     bool m_no_igd;
+    std::atomic<bool> m_save_graph;
 
     //critical_section m_connections_lock;
     //connections_indexed_container m_connections;
diff --git a/src/p2p/net_node.inl b/src/p2p/net_node.inl
index ce70e241a..60eed1f36 100644
--- a/src/p2p/net_node.inl
+++ b/src/p2p/net_node.inl
@@ -46,6 +46,7 @@
 #include "net/local_ip.h"
 #include "crypto/crypto.h"
 #include "storages/levin_abstract_invoke2.h"
+#include "data_logger.hpp"
 
 // We have to look for miniupnpc headers in different places, dependent on if its compiled or external
 #ifdef UPNP_STATIC
@@ -85,8 +86,8 @@ namespace nodetool
     const command_line::arg_descriptor<std::vector<std::string> > arg_p2p_seed_node   = {"seed-node", "Connect to a node to retrieve peer addresses, and disconnect"};
     const command_line::arg_descriptor<bool> arg_p2p_hide_my_port   =    {"hide-my-port", "Do not announce yourself as peerlist candidate", false, true};
     
-    const command_line::arg_descriptor<bool>        arg_no_igd = {"no-igd", "Disable UPnP port mapping"};
-    const command_line::arg_descriptor<int64_t>     arg_out_peers = {"out-peers", "set max limit of out peers", -1};
+    const command_line::arg_descriptor<bool>        arg_no_igd				= {"no-igd", "Disable UPnP port mapping"};
+    const command_line::arg_descriptor<int64_t>     arg_out_peers 			= {"out-peers", "set max limit of out peers", -1};
     const command_line::arg_descriptor<int>    		arg_tos_flag      		= {"tos-flag", "set TOS flag", -1};
     
     const command_line::arg_descriptor<int64_t>    	arg_limit_rate_up      	= {"limit-rate-up", "set limit-rate-up [kB/s]", -1};
@@ -289,6 +290,31 @@ namespace nodetool
       
       std::vector<std::vector<std::string>> dns_results;
       dns_results.resize(m_seed_nodes_list.size());
+      
+      std::shared_ptr<std::thread> peersLoggerThread (new std::thread([&]()
+      {
+		unsigned int number_of_peers;
+		while (1)
+		{
+			if (m_save_graph)
+			{
+				//number_of_peers = m_net_server.get_config_object().get_connections_count();
+				number_of_peers = 0;
+				m_net_server.get_config_object().foreach_connection([&](const p2p_connection_context& cntxt)
+				{
+					if(!cntxt.m_is_income)
+						++number_of_peers;
+					return true;
+				}); // lambda
+				
+				m_number_of_out_peers = number_of_peers;
+				epee::net_utils::data_logger::get_instance().add_data("peers", number_of_peers);
+			}
+			std::this_thread::sleep_for(std::chrono::seconds(1));
+		}
+      })); // lambda
+      
+      peersLoggerThread->detach();
 
       std::list<boost::thread*> dns_threads;
       uint64_t result_index = 0;
@@ -487,6 +513,7 @@ namespace nodetool
   {
     m_peerlist.deinit();
     m_net_server.deinit_server();
+    
     return store_config();
   }
   //-----------------------------------------------------------------------------------
@@ -697,6 +724,16 @@ namespace nodetool
   template<class t_payload_net_handler>
   bool node_server<t_payload_net_handler>::try_to_connect_and_handshake_with_new_peer(const net_address& na, bool just_take_peerlist, uint64_t last_seen_stamp, bool white)
   {
+	if (m_number_of_out_peers == m_config.m_net_config.connections_count) // out peers limit
+	{
+		return false;
+	}
+	else if (m_number_of_out_peers > m_config.m_net_config.connections_count)
+	{
+		m_net_server.get_config_object().del_out_connections(1);
+		m_number_of_out_peers --; // atomic variable, update time = 1s
+		return false;
+	}
     LOG_PRINT_L1("Connecting to " << epee::string_tools::get_ip_string_from_int32(na.ip)  << ":"
         << epee::string_tools::num_to_string_fast(na.port) << "(white=" << white << ", last_seen: "
         << (last_seen_stamp ? epee::misc_utils::get_time_interval_string(time(NULL) - last_seen_stamp):"never")
@@ -784,16 +821,22 @@ namespace nodetool
 
       ++try_count;
 
-      if(is_peer_used(pe))
+			_note("Considering connecting (out) to peer: " << pe.id << " " << epee::string_tools::get_ip_string_from_int32(pe.adr.ip)  << ":" << boost::lexical_cast<std::string>(pe.adr.port));
+
+      if(is_peer_used(pe)) {
+				_note("Peer is used");
         continue;
+			}
 
       LOG_PRINT_L1("Selected peer: " << pe.id << " " << epee::string_tools::get_ip_string_from_int32(pe.adr.ip)
                     << ":" << boost::lexical_cast<std::string>(pe.adr.port)
                     << "[white=" << use_white_list
                     << "] last_seen: " << (pe.last_seen ? epee::misc_utils::get_time_interval_string(time(NULL) - pe.last_seen) : "never"));
       
-      if(!try_to_connect_and_handshake_with_new_peer(pe.adr, false, pe.last_seen, use_white_list))
+      if(!try_to_connect_and_handshake_with_new_peer(pe.adr, false, pe.last_seen, use_white_list)) {
+				_note("Handshake failed");
         continue;
+			}
 
       return true;
     }
@@ -1336,20 +1379,31 @@ namespace nodetool
   template<class t_payload_net_handler>
   bool node_server<t_payload_net_handler>::set_max_out_peers(const boost::program_options::variables_map& vm, int64_t max)
 	{
+	    using namespace std::chrono;
+		auto point = steady_clock::now();
+		auto time_from_epoh = point.time_since_epoch();
+		auto ms = duration_cast< milliseconds >( time_from_epoh ).count();
+		double ms_f = ms;
+		ms_f /= 1000.;
+		
+		std::ofstream limitFile("log/dr-monero/peers_limit.info", std::ios::app);
+		limitFile.precision(7);
 		if(max == -1) {
 			m_config.m_net_config.connections_count = P2P_DEFAULT_CONNECTIONS_COUNT;
+			if (m_save_graph)
+				limitFile << static_cast<int>(ms_f) << " " << P2P_DEFAULT_CONNECTIONS_COUNT << std::endl;
 			return true;
 		}
 		
 		m_config.m_net_config.connections_count = max;
-		LOG_PRINT_RED_L0("connections_count:  " << m_config.m_net_config.connections_count);
+		limitFile << static_cast<int>(ms_f) << " " << max << std::endl;
 		return true;
 	}
 	
   template<class t_payload_net_handler>
   void node_server<t_payload_net_handler>::delete_connections(size_t count)
   {
-		m_net_server.get_config_object().del_connections(count);
+		m_net_server.get_config_object().del_out_connections(count);
   }
   
   	  template<class t_payload_net_handler>
diff --git a/src/p2p/network_throttle-detail.cpp b/src/p2p/network_throttle-detail.cpp
index 6ea3076a9..6b2ee698e 100644
--- a/src/p2p/network_throttle-detail.cpp
+++ b/src/p2p/network_throttle-detail.cpp
@@ -78,6 +78,7 @@
 #include "../../src/p2p/network_throttle-detail.hpp"
 
 #include "../../contrib/otshell_utils/utils.hpp"
+#include "data_logger.hpp"
 using namespace nOT::nUtils;
 
 // ################################################################################################
@@ -152,8 +153,6 @@ network_throttle::network_throttle(const std::string &nameshort, const std::stri
 	m_any_packet_yet = false;
 	m_slot_size = 1.0; // hard coded in few places
 	m_target_speed = 16 * 1024; // other defaults are probably defined in the command-line parsing code when this class is used e.g. as main global throttle
-	m_target_MB = 0;
-
 }
 
 void network_throttle::set_name(const std::string &name) 
@@ -163,16 +162,20 @@ void network_throttle::set_name(const std::string &name)
 
 void network_throttle::set_target_speed( network_speed_kbps target ) 
 {
-    m_target_speed = target;
+    m_target_speed = target * 1024;
 	_note_c("net/"+m_nameshort, "Setting LIMIT: " << target << " kbps");
+	set_real_target_speed(target);
 }
 
-void network_throttle::set_target_kill( network_MB target )
+void network_throttle::set_real_target_speed( network_speed_kbps real_target )
 {
-	_note_c("net/"+m_nameshort, "Setting KILL: " << target << " MB hard limit");
-	m_target_MB = target;
+	m_real_target_speed = real_target * 1024;
 }
 
+network_speed_kbps network_throttle::get_terget_speed()
+{
+	return m_real_target_speed / 1024;
+}
 			
 void network_throttle::tick()
 {
@@ -187,7 +190,7 @@ void network_throttle::tick()
 	// TODO optimize when moving few slots at once
 	while ( (!m_any_packet_yet) || (last_sample_time_slot < current_sample_time_slot))
 	{
-		LOG_PRINT_L4("Moving counter buffer by 1 second " << last_sample_time_slot << " < " << current_sample_time_slot << " (last time " << m_last_sample_time<<")");
+		_dbg3("Moving counter buffer by 1 second " << last_sample_time_slot << " < " << current_sample_time_slot << " (last time " << m_last_sample_time<<")");
 		// rotate buffer 
 		for (size_t i=m_history.size()-1; i>=1; --i) m_history[i] = m_history[i-1];
 		m_history[0] = packet_info();
@@ -217,7 +220,6 @@ void network_throttle::_handle_trafic_exact(size_t packet_size, size_t orginal_s
 	std::ostringstream oss; oss << "["; 	for (auto sample: m_history) oss << sample.m_size << " ";	 oss << "]" << std::ends;
 	std::string history_str = oss.str();
 
-    logger_handle_net("log/dr-monero/net/inreq-all.data",get_time_seconds(),packet_size);
 	_info_c( "net/" + m_nameshort , "Throttle " << m_name << ": packet of ~"<<packet_size<<"b " << " (from "<<orginal_size<<" b)" 
         << " Speed AVG=" << std::setw(4) <<  ((long int)(cts .average/1024)) <<"[w="<<cts .window<<"]"
         <<           " " << std::setw(4) <<  ((long int)(cts2.average/1024)) <<"[w="<<cts2.window<<"]"
@@ -233,23 +235,22 @@ void network_throttle::handle_trafic_tcp(size_t packet_size)
 	_handle_trafic_exact( all_size , packet_size );
 }
 
-void network_throttle::handle_congestion(double overheat) {
-	// TODO
-}
-
 network_time_seconds network_throttle::get_sleep_time_after_tick(size_t packet_size) {
 	tick();
 	return get_sleep_time(packet_size);
 }
 
 void network_throttle::logger_handle_net(const std::string &filename, double time, size_t size) {
+	if (! epee::net_utils::data_logger::m_save_graph)
+		return;
     std::mutex mutex;
     mutex.lock(); {
         std::fstream file;
         file.open(filename.c_str(), std::ios::app | std::ios::out );
+        file.precision(6);
         if(!file.is_open())
             _warn("Can't open file " << filename);
-        file << time << " " << size/1024 << "\n";
+        file << static_cast<int>(time) << " " << static_cast<double>(size/1024) << "\n";
         file.close();
     }  mutex.unlock();
 }
@@ -257,27 +258,11 @@ void network_throttle::logger_handle_net(const std::string &filename, double tim
 // fine tune this to decide about sending speed:
 network_time_seconds network_throttle::get_sleep_time(size_t packet_size) const 
 {
-	//_scope_mark("");
 	double D2=0;
 	calculate_times_struct cts = { 0, 0, 0, 0};
-	//calculate_times(packet_size, cts, false, m_window_size/2); D2=cts.delay;
-	//calculate_times(packet_size, cts, true, m_window_size/2); D2=cts.delay;
 	calculate_times(packet_size, cts, true, m_window_size); D2=cts.delay;
 	return D2;
 }
-double network_throttle::get_current_overheat() const {
- 	auto now = get_time_seconds();
- 	auto diff = now - m_overheat_time;
- 	auto overheat = m_overheat - diff;
- 	overheat = std::max(m_overheat, 0.);
- 	return overheat;
-}
-
-void network_throttle::set_overheat(double lag) {
-  	m_overheat += lag;
-  	m_overheat_time = get_time_seconds();
-  	LOG_PRINT_L0("Lag: " << lag << ", overheat: " << m_overheat );
-}
 
 // MAIN LOGIC:
 void network_throttle::calculate_times(size_t packet_size, calculate_times_struct &cts, bool dbg, double force_window) const 
@@ -310,9 +295,7 @@ void network_throttle::calculate_times(size_t packet_size, calculate_times_struc
 	const double D1 = (Epast - M*cts.window) / M; // delay - how long to sleep to get back to target speed
 	const double D2 = (Enow  - M*cts.window) / M; // delay - how long to sleep to get back to target speed (including current packet)
 
-	auto O = get_current_overheat();
-	auto Ouse = O * 0 ; // XXX TODO
-    cts.delay = (D1*0.80 + D2*0.20) + Ouse; // finall sleep depends on both with/without current packet
+    cts.delay = (D1*0.80 + D2*0.20); // finall sleep depends on both with/without current packet
 	//				update_overheat();
 	cts.average = Epast/cts.window; // current avg. speed (for info)
 
@@ -329,13 +312,13 @@ void network_throttle::calculate_times(size_t packet_size, calculate_times_struc
 	if (dbg) {
 		std::ostringstream oss; oss << "["; 	for (auto sample: m_history) oss << sample.m_size << " ";	 oss << "]" << std::ends;
 		std::string history_str = oss.str();
-		_dbg1_c( "net/"+m_nameshort+"_c" ,
-			"dbg " << m_name << ": " 
+		_info_c( "net/"+m_nameshort+"_c" ,
+			(cts.delay > 0 ? "SLEEP" : "")
+			<< "dbg " << m_name << ": " 
 			<< "speed is A=" << std::setw(8) <<cts.average<<" vs "
 			<< "Max=" << std::setw(8) <<M<<" "
 			<< " so sleep: "
 			<< "D=" << std::setw(8) <<cts.delay<<" sec "
-			<< "Overheat=" << std::setw(8) <<O<<" sec "
 			<< "E="<< std::setw(8) << E << " (Enow="<<std::setw(8)<<Enow<<") "
             << "M=" << std::setw(8) << M <<" W="<< std::setw(8) << cts.window << " "
             << "R=" << std::setw(8) << cts.recomendetDataSize << " Wgood" << std::setw(8) << Wgood << " "
@@ -347,7 +330,7 @@ void network_throttle::calculate_times(size_t packet_size, calculate_times_struc
 }
 
 double network_throttle::get_time_seconds() const {
-	using namespace boost::chrono;
+	using namespace std::chrono;
 	auto point = steady_clock::now();
 	auto time_from_epoh = point.time_since_epoch();
 	auto ms = duration_cast< milliseconds >( time_from_epoh ).count();
@@ -368,14 +351,28 @@ size_t network_throttle::get_recommended_size_of_planned_transport_window(double
 size_t network_throttle::get_recommended_size_of_planned_transport() const {
 	size_t R1=0,R2=0,R3=0;
 	R1 = get_recommended_size_of_planned_transport_window( -1 );
-	R2 = get_recommended_size_of_planned_transport_window( m_window_size/2);
-	R3 = get_recommended_size_of_planned_transport_window( 8              );
+	R2 = get_recommended_size_of_planned_transport_window(m_window_size / 2);
+	R3 = get_recommended_size_of_planned_transport_window( 5              );
 	auto RM = std::min(R1, std::min(R2,R3));
 
-	const double a1=70, a2=10, a3=10, am=10; // weight of the various windows in decisssion
+	const double a1=20, a2=10, a3=10, am=10; // weight of the various windows in decisssion // TODO 70 => 20
 	return (R1*a1 + R2*a2 + R3*a3 + RM*am) / (a1+a2+a3+am);
 }
 
+double network_throttle::get_current_speed() const {
+	unsigned int bytes_transferred = 0;
+	if (m_history.size() == 0 || m_slot_size == 0)
+		return 0;
+		
+	auto it = m_history.begin();
+	while (it < m_history.end() - 1)
+	{
+		bytes_transferred += it->m_size;
+		it ++;
+	}
+	
+	return bytes_transferred / ((m_history.size() - 1) * m_slot_size);
+}
 
 } // namespace
 } // namespace
diff --git a/src/p2p/network_throttle-detail.hpp b/src/p2p/network_throttle-detail.hpp
index 9d492c534..063dac850 100644
--- a/src/p2p/network_throttle-detail.hpp
+++ b/src/p2p/network_throttle-detail.hpp
@@ -54,7 +54,7 @@ class network_throttle : public i_network_throttle {
 
 
 		network_speed_kbps m_target_speed;
-		network_MB m_target_MB;
+		network_speed_kbps m_real_target_speed;
 		size_t m_network_add_cost; // estimated add cost of headers 
 		size_t m_network_minimal_segment; // estimated minimal cost of sending 1 byte to round up to
 		size_t m_network_max_segment; // recommended max size of 1 TCP transmission
@@ -80,18 +80,16 @@ class network_throttle : public i_network_throttle {
 		virtual ~network_throttle();
 		virtual void set_name(const std::string &name);
 		virtual void set_target_speed( network_speed_kbps target );
-		virtual void set_target_kill( network_MB target );
+		virtual void set_real_target_speed( network_speed_kbps real_target ); // only for throttle_out
+		virtual network_speed_kbps get_terget_speed();
 
 		// add information about events:
 		virtual void handle_trafic_exact(size_t packet_size); ///< count the new traffic/packet; the size is exact considering all network costs
 		virtual void handle_trafic_tcp(size_t packet_size); ///< count the new traffic/packet; the size is as TCP, we will consider MTU etc
-		virtual void handle_congestion(double overheat); ///< call this when congestion is detected; see example use
 
 		virtual void tick(); ///< poke and update timers/history (recalculates, moves the history if needed, checks the real clock etc)
 
 		virtual double get_time_seconds() const ; ///< timer that we use, time in seconds, monotionic
-		virtual double get_current_overheat() const; ///< did we detected congestion now. NOT USED NOW TODO
-		virtual void set_overheat(double lag); ///< did we detected congestion now. NOT USED NOW TODO.  rename to add_overheat ?
 
 		// time calculations:
 		virtual void calculate_times(size_t packet_size, calculate_times_struct &cts, bool dbg, double force_window) const; ///< MAIN LOGIC (see base class for info)
@@ -101,7 +99,7 @@ class network_throttle : public i_network_throttle {
 
 		virtual size_t get_recommended_size_of_planned_transport() const; ///< what should be the size (bytes) of next data block to be transported
 		virtual size_t get_recommended_size_of_planned_transport_window(double force_window) const;  ///< ditto, but for given windows time frame
-		//virtual void add_planned_transport(size_t size);
+		virtual double get_current_speed() const;
 
 	private:
 		virtual network_time_seconds time_to_slot(network_time_seconds t) const { return std::floor( t ); } // convert exact time eg 13.7 to rounded time for slot number in history 13
diff --git a/src/p2p/network_throttle.hpp b/src/p2p/network_throttle.hpp
index dc25a2c45..add4daa86 100644
--- a/src/p2p/network_throttle.hpp
+++ b/src/p2p/network_throttle.hpp
@@ -100,7 +100,7 @@ struct calculate_times_struct {
 typedef calculate_times_struct calculate_times_struct;
 
 
-namespace cryptonote { class cryptonote_protocol_handler_base; }; // a friend class // TODO friend not working
+namespace cryptonote { class cryptonote_protocol_handler_base; } // a friend class // TODO friend not working
 
 /*** 
 @brief Access to simple throttles, with singlton to access global network limits
@@ -146,11 +146,11 @@ class i_network_throttle {
 	public:
 		virtual void set_name(const std::string &name)=0;
 		virtual void set_target_speed( network_speed_kbps target )=0;
-		virtual void set_target_kill( network_MB target )=0;
+		virtual void set_real_target_speed(network_speed_kbps real_target)=0;
+		virtual network_speed_kbps get_terget_speed()=0;
 
 		virtual void handle_trafic_exact(size_t packet_size) =0; // count the new traffic/packet; the size is exact considering all network costs
 		virtual void handle_trafic_tcp(size_t packet_size) =0; // count the new traffic/packet; the size is as TCP, we will consider MTU etc
-		virtual void handle_congestion(double overheat) =0; // call this when congestion is detected; see example use
 		virtual void tick() =0; // poke and update timers/history
 		
 		// time calculations:
@@ -166,8 +166,6 @@ class i_network_throttle {
 		virtual size_t get_recommended_size_of_planned_transport() const =0; // what should be the recommended limit of data size that we can transport over current network_throttle in near future
 
 		virtual double get_time_seconds() const =0; // a timer
-		virtual double get_current_overheat() const =0;
-        virtual void set_overheat(double lag) =0;
         virtual void logger_handle_net(const std::string &filename, double time, size_t size)=0;