dn724/dncurrency
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions

Use nano::transport::traffic_type for bandwidth limiter selection

Browse source
This commit is contained in:
Piotr Wójcik 2024-09-09 21:15:23 +02:00
commit 4d5664a1e1
4 changed files with 15 additions and 43 deletions
Download patch file Download diff file Expand all files Collapse all files

32
nano/node/bandwidth_limiter.cpp
View file

@ -7,49 +7,35 @@
nano::bandwidth_limiter::bandwidth_limiter (nano::bandwidth_limiter::config config_a) :
config_m{ config_a },
limiter_standard (config_m.standard_limit, config_m.standard_burst_ratio),
limiter_generic{ config_m.standard_limit, config_m.standard_burst_ratio },
limiter_bootstrap{ config_m.bootstrap_limit, config_m.bootstrap_burst_ratio }
{
}
nano::rate_limiter & nano::bandwidth_limiter::select_limiter (nano::bandwidth_limit_type type)
nano::rate_limiter & nano::bandwidth_limiter::select_limiter (nano::transport::traffic_type type)
{
switch (type)
{
case bandwidth_limit_type::bootstrap:
case nano::transport::traffic_type::bootstrap:
return limiter_bootstrap;
case bandwidth_limit_type::standard:
case nano::transport::traffic_type::generic:
return limiter_generic;
break;
default:
debug_assert (false);
debug_assert (false, "missing traffic type");
break;
}
return limiter_standard;
return limiter_generic;
}
bool nano::bandwidth_limiter::should_pass (std::size_t buffer_size, nano::bandwidth_limit_type type)
bool nano::bandwidth_limiter::should_pass (std::size_t buffer_size, nano::transport::traffic_type type)
{
auto & limiter = select_limiter (type);
return limiter.should_pass (buffer_size);
}
void nano::bandwidth_limiter::reset (std::size_t limit, double burst_ratio, nano::bandwidth_limit_type type)
void nano::bandwidth_limiter::reset (std::size_t limit, double burst_ratio, nano::transport::traffic_type type)
{
auto & limiter = select_limiter (type);
limiter.reset (limit, burst_ratio);
}
nano::bandwidth_limit_type nano::to_bandwidth_limit_type (const nano::transport::traffic_type & traffic_type)
{
switch (traffic_type)
{
case nano::transport::traffic_type::generic:
return nano::bandwidth_limit_type::standard;
break;
case nano::transport::traffic_type::bootstrap:
return nano::bandwidth_limit_type::bootstrap;
break;
}
debug_assert (false);
return {};
}

21
nano/node/bandwidth_limiter.hpp
View file

@ -5,19 +5,6 @@
namespace nano
{
/**
* Enumeration for different bandwidth limits for different traffic types
*/
enum class bandwidth_limit_type
{
/** For all message */
standard,
/** For bootstrap (asc_pull_ack, asc_pull_req) traffic */
bootstrap
};
nano::bandwidth_limit_type to_bandwidth_limit_type (nano::transport::traffic_type const &);
/**
* Class that tracks and manages bandwidth limits for IO operations
*/
@ -41,23 +28,23 @@ public:
* Check whether packet falls withing bandwidth limits and should be allowed
* @return true if OK, false if needs to be dropped
*/
bool should_pass (std::size_t buffer_size, bandwidth_limit_type);
bool should_pass (std::size_t buffer_size, nano::transport::traffic_type type);
/**
* Reset limits of selected limiter type to values passed in arguments
*/
void reset (std::size_t limit, double burst_ratio, bandwidth_limit_type = bandwidth_limit_type::standard);
void reset (std::size_t limit, double burst_ratio, nano::transport::traffic_type type = nano::transport::traffic_type::generic);
private:
/**
* Returns reference to limiter corresponding to the limit type
*/
nano::rate_limiter & select_limiter (bandwidth_limit_type);
nano::rate_limiter & select_limiter (nano::transport::traffic_type type);
private:
const config config_m;
private:
nano::rate_limiter limiter_standard;
nano::rate_limiter limiter_generic;
nano::rate_limiter limiter_bootstrap;
};
}

2
nano/node/transport/channel.cpp
View file

@ -19,7 +19,7 @@ void nano::transport::channel::send (nano::message & message_a, std::function<vo
auto buffer = message_a.to_shared_const_buffer ();
bool is_droppable_by_limiter = (drop_policy_a == nano::transport::buffer_drop_policy::limiter);
bool should_pass = node.outbound_limiter.should_pass (buffer.size (), to_bandwidth_limit_type (traffic_type));
bool should_pass = node.outbound_limiter.should_pass (buffer.size (), traffic_type);
bool pass = !is_droppable_by_limiter || should_pass;
node.stats.inc (pass ? nano::stat::type::message : nano::stat::type::drop, to_stat_detail (message_a.type ()), nano::stat::dir::out, /* aggregate all */ true);

3
nano/node/transport/traffic_type.hpp
View file

@ -8,7 +8,6 @@ namespace nano::transport
enum class traffic_type
{
generic,
/** For bootstrap (asc_pull_ack, asc_pull_req) traffic */
bootstrap
bootstrap, // Ascending bootstrap (asc_pull_ack, asc_pull_req) traffic
};
}