aboutsummaryrefslogtreecommitdiff
path: root/src/p2p
diff options
context:
space:
mode:
Diffstat (limited to 'src/p2p')
-rw-r--r--src/p2p/connection_basic.cpp167
-rw-r--r--src/p2p/connection_basic.hpp11
-rw-r--r--src/p2p/data_logger.cpp81
-rw-r--r--src/p2p/data_logger.hpp46
-rw-r--r--src/p2p/net_node.h12
-rw-r--r--src/p2p/net_node.inl66
-rw-r--r--src/p2p/network_throttle-detail.cpp75
-rw-r--r--src/p2p/network_throttle-detail.hpp10
-rw-r--r--src/p2p/network_throttle.hpp8
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;
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-16 20:59:02 +0000