deprecated setters for max connections, max half-open, upload and download rates and unchoke slots. These are now set through session_settings
This commit is contained in:
parent
45f535e80c
commit
21cbd1fac4
|
@ -1,3 +1,5 @@
|
||||||
|
* deprecated setters for max connections, max half-open, upload and download
|
||||||
|
rates and unchoke slots. These are now set through session_settings
|
||||||
* added functions to query an individual peer's upload and download limit
|
* added functions to query an individual peer's upload and download limit
|
||||||
* full support for BEP 21 (event=paused)
|
* full support for BEP 21 (event=paused)
|
||||||
* added share-mode feature for improving share ratios
|
* added share-mode feature for improving share ratios
|
||||||
|
|
151
docs/manual.rst
151
docs/manual.rst
|
@ -547,116 +547,6 @@ See ``torrent_handle::is_valid()`` to know if the torrent was found or not.
|
||||||
``get_torrents()`` returns a vector of torrent_handles to all the torrents
|
``get_torrents()`` returns a vector of torrent_handles to all the torrents
|
||||||
currently in the session.
|
currently in the session.
|
||||||
|
|
||||||
|
|
||||||
set_upload_rate_limit() set_download_rate_limit() upload_rate_limit() download_rate_limit()
|
|
||||||
-------------------------------------------------------------------------------------------
|
|
||||||
|
|
||||||
::
|
|
||||||
|
|
||||||
void set_upload_rate_limit(int bytes_per_second);
|
|
||||||
void set_download_rate_limit(int bytes_per_second);
|
|
||||||
int upload_rate_limit() const;
|
|
||||||
int download_rate_limit() const;
|
|
||||||
|
|
||||||
``set_upload_rate_limit()`` set the maximum number of bytes allowed to be
|
|
||||||
sent to peers per second. This bandwidth is distributed among all the peers. If
|
|
||||||
you don't want to limit upload rate, you can set this to 0 (the default).
|
|
||||||
``set_download_rate_limit()`` works the same way but for download rate instead
|
|
||||||
of upload rate.
|
|
||||||
``download_rate_limit()`` and ``upload_rate_limit()`` returns the previously
|
|
||||||
set limits.
|
|
||||||
|
|
||||||
A rate limit of 0 means infinite.
|
|
||||||
|
|
||||||
Upload and download rate limits are not applied to peers on the local network
|
|
||||||
by default. To change that, see ``session_settings::ignore_limits_on_local_network``.
|
|
||||||
|
|
||||||
|
|
||||||
set_local_upload_rate_limit() set_local_download_rate_limit() local_upload_rate_limit() local_download_rate_limit()
|
|
||||||
-------------------------------------------------------------------------------------------------------------------
|
|
||||||
|
|
||||||
::
|
|
||||||
|
|
||||||
void set_local_upload_rate_limit(int bytes_per_second);
|
|
||||||
void set_local_download_rate_limit(int bytes_per_second);
|
|
||||||
int local_upload_rate_limit() const;
|
|
||||||
int local_download_rate_limit() const;
|
|
||||||
|
|
||||||
These rate limits are only used for local peers (peers within the same subnet as
|
|
||||||
the client itself) and it is only used when ``session_settings::ignore_limits_on_local_network``
|
|
||||||
is set to true (which it is by default). These rate limits default to unthrottled,
|
|
||||||
but can be useful in case you want to treat local peers preferentially, but not
|
|
||||||
quite unthrottled.
|
|
||||||
|
|
||||||
A rate limit of 0 means infinite.
|
|
||||||
|
|
||||||
|
|
||||||
set_max_uploads() max_uploads()
|
|
||||||
-------------------------------
|
|
||||||
|
|
||||||
::
|
|
||||||
|
|
||||||
void set_max_uploads(int limit);
|
|
||||||
int max_uploads() const;
|
|
||||||
|
|
||||||
``set_max_uploads`` sets a global limit on the number of unchoked peers (uploads).
|
|
||||||
The number of uploads is at least one per torrent.
|
|
||||||
|
|
||||||
``max_uploads()`` returns the current settings.
|
|
||||||
|
|
||||||
The number of unchoke slots may be ignored depending on what
|
|
||||||
``session_settings::choking_algorithm`` is set to.
|
|
||||||
|
|
||||||
|
|
||||||
set_max_connections() max_connections()
|
|
||||||
---------------------------------------
|
|
||||||
|
|
||||||
::
|
|
||||||
|
|
||||||
void set_max_connections(int limit);
|
|
||||||
int max_connections() const;
|
|
||||||
|
|
||||||
``set_max_connections`` sets a global limit on the number of connections
|
|
||||||
opened. The number of connections is set to a hard minimum of at least two per
|
|
||||||
torrent, so if you set a too low connections limit, and open too many torrents,
|
|
||||||
the limit will not be met.
|
|
||||||
|
|
||||||
``max_connections()`` returns the current settings.
|
|
||||||
|
|
||||||
|
|
||||||
num_uploads() num_connections()
|
|
||||||
-------------------------------
|
|
||||||
|
|
||||||
::
|
|
||||||
|
|
||||||
int num_uploads() const;
|
|
||||||
int num_connections() const;
|
|
||||||
|
|
||||||
Returns the number of currently unchoked peers and the number of connections
|
|
||||||
(including half-open ones) respectively.
|
|
||||||
|
|
||||||
|
|
||||||
set_max_half_open_connections() max_half_open_connections()
|
|
||||||
-----------------------------------------------------------
|
|
||||||
|
|
||||||
::
|
|
||||||
|
|
||||||
void set_max_half_open_connections(int limit);
|
|
||||||
int max_half_open_connections() const;
|
|
||||||
|
|
||||||
Sets the maximum number of half-open connections libtorrent will have when
|
|
||||||
connecting to peers. A half-open connection is one where connect() has been
|
|
||||||
called, but the connection still hasn't been established (nor failed). Windows
|
|
||||||
XP Service Pack 2 sets a default, system wide, limit of the number of half-open
|
|
||||||
connections to 10. So, this limit can be used to work nicer together with
|
|
||||||
other network applications on that system. The default is to have no limit,
|
|
||||||
and passing -1 as the limit, means to have no limit. When limiting the number
|
|
||||||
of simultaneous connection attempts, peers will be put in a queue waiting for
|
|
||||||
their turn to get connected.
|
|
||||||
|
|
||||||
``max_half_open_connections()`` returns the set limit. This limit defaults
|
|
||||||
to 8 on windows.
|
|
||||||
|
|
||||||
load_asnum_db() load_country_db() as_for_ip()
|
load_asnum_db() load_country_db() as_for_ip()
|
||||||
---------------------------------------------
|
---------------------------------------------
|
||||||
|
|
||||||
|
@ -3929,6 +3819,13 @@ session_settings
|
||||||
bool anonymous_mode;
|
bool anonymous_mode;
|
||||||
int tick_interval;
|
int tick_interval;
|
||||||
int share_mode_target;
|
int share_mode_target;
|
||||||
|
int upload_rate_limit;
|
||||||
|
int download_rate_limit;
|
||||||
|
int local_upload_rate_limit;
|
||||||
|
int local_download_rate_limit;
|
||||||
|
int unchoke_slots_limit;
|
||||||
|
int half_open_limit;
|
||||||
|
int connections_limit;
|
||||||
};
|
};
|
||||||
|
|
||||||
``version`` is automatically set to the libtorrent version you're using
|
``version`` is automatically set to the libtorrent version you're using
|
||||||
|
@ -4599,6 +4496,40 @@ need to download the rarest piece, it's impossible to download a single piece
|
||||||
and upload it more than 3 times. If the share_mode_target is set to more than 3,
|
and upload it more than 3 times. If the share_mode_target is set to more than 3,
|
||||||
nothing is downloaded.
|
nothing is downloaded.
|
||||||
|
|
||||||
|
``upload_rate_limit``, ``download_rate_limit``, ``local_upload_rate_limit``
|
||||||
|
and ``local_download_rate_limit`` sets the session-global limits of upload
|
||||||
|
and download rate limits, in bytes per second. The local rates refer to peers
|
||||||
|
on the local network. By default peers on the local network are not rate limited.
|
||||||
|
|
||||||
|
These rate limits are only used for local peers (peers within the same subnet as
|
||||||
|
the client itself) and it is only used when ``session_settings::ignore_limits_on_local_network``
|
||||||
|
is set to true (which it is by default). These rate limits default to unthrottled,
|
||||||
|
but can be useful in case you want to treat local peers preferentially, but not
|
||||||
|
quite unthrottled.
|
||||||
|
|
||||||
|
A value of 0 means unlimited.
|
||||||
|
|
||||||
|
``unchoke_slots_limit`` is the mac number of unchoked peers in the session.
|
||||||
|
|
||||||
|
The number of unchoke slots may be ignored depending on what
|
||||||
|
``choking_algorithm`` is set to.
|
||||||
|
|
||||||
|
``half_open_limit`` sets the maximum number of half-open connections
|
||||||
|
libtorrent will have when connecting to peers. A half-open connection is one
|
||||||
|
where connect() has been called, but the connection still hasn't been established
|
||||||
|
(nor failed). Windows XP Service Pack 2 sets a default, system wide, limit of
|
||||||
|
the number of half-open connections to 10. So, this limit can be used to work
|
||||||
|
nicer together with other network applications on that system. The default is
|
||||||
|
to have no limit, and passing -1 as the limit, means to have no limit. When
|
||||||
|
limiting the number of simultaneous connection attempts, peers will be put in
|
||||||
|
a queue waiting for their turn to get connected.
|
||||||
|
|
||||||
|
``connections_limit`` sets a global limit on the number of connections
|
||||||
|
opened. The number of connections is set to a hard minimum of at least two per
|
||||||
|
torrent, so if you set a too low connections limit, and open too many torrents,
|
||||||
|
the limit will not be met.
|
||||||
|
|
||||||
|
|
||||||
pe_settings
|
pe_settings
|
||||||
===========
|
===========
|
||||||
|
|
||||||
|
|
|
@ -893,7 +893,7 @@ int main(int argc, char* argv[])
|
||||||
switch (argv[i][1])
|
switch (argv[i][1])
|
||||||
{
|
{
|
||||||
case 'f': g_log_file = fopen(arg, "w+"); break;
|
case 'f': g_log_file = fopen(arg, "w+"); break;
|
||||||
case 'o': ses.set_max_half_open_connections(atoi(arg)); break;
|
case 'o': settings.half_open_limit = atoi(arg); break;
|
||||||
case 'h': settings.allow_multiple_connections_per_ip = true; --i; break;
|
case 'h': settings.allow_multiple_connections_per_ip = true; --i; break;
|
||||||
case 'p': listen_port = atoi(arg); break;
|
case 'p': listen_port = atoi(arg); break;
|
||||||
case 'r':
|
case 'r':
|
||||||
|
@ -901,9 +901,9 @@ int main(int argc, char* argv[])
|
||||||
if (preferred_ratio != 0 && preferred_ratio < 1.f) preferred_ratio = 1.f;
|
if (preferred_ratio != 0 && preferred_ratio < 1.f) preferred_ratio = 1.f;
|
||||||
break;
|
break;
|
||||||
case 'n': settings.announce_to_all_tiers = true; --i; break;
|
case 'n': settings.announce_to_all_tiers = true; --i; break;
|
||||||
case 'd': ses.set_download_rate_limit(atoi(arg) * 1000); break;
|
case 'd': settings.download_rate_limit = atoi(arg) * 1000; break;
|
||||||
case 'u': ses.set_upload_rate_limit(atoi(arg) * 1000); break;
|
case 'u': settings.upload_rate_limit = atoi(arg) * 1000; break;
|
||||||
case 'S': ses.set_max_uploads(atoi(arg)); break;
|
case 'S': settings.unchoke_slots_limit = atoi(arg); break;
|
||||||
case 'a':
|
case 'a':
|
||||||
if (strcmp(arg, "allocate") == 0) allocation_mode = storage_mode_allocate;
|
if (strcmp(arg, "allocate") == 0) allocation_mode = storage_mode_allocate;
|
||||||
if (strcmp(arg, "compact") == 0) allocation_mode = storage_mode_compact;
|
if (strcmp(arg, "compact") == 0) allocation_mode = storage_mode_compact;
|
||||||
|
@ -942,7 +942,7 @@ int main(int argc, char* argv[])
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
break;
|
break;
|
||||||
case 'c': ses.set_max_connections(atoi(arg)); break;
|
case 'c': settings.connections_limit = atoi(arg); break;
|
||||||
case 'T': max_connections_per_torrent = atoi(arg); break;
|
case 'T': max_connections_per_torrent = atoi(arg); break;
|
||||||
#if TORRENT_USE_I2P
|
#if TORRENT_USE_I2P
|
||||||
case 'i':
|
case 'i':
|
||||||
|
|
|
@ -266,6 +266,7 @@ namespace libtorrent
|
||||||
|
|
||||||
alert const* wait_for_alert(time_duration max_wait);
|
alert const* wait_for_alert(time_duration max_wait);
|
||||||
|
|
||||||
|
#ifndef TORRENT_NO_DEPRECATE
|
||||||
int upload_rate_limit() const;
|
int upload_rate_limit() const;
|
||||||
int download_rate_limit() const;
|
int download_rate_limit() const;
|
||||||
int local_upload_rate_limit() const;
|
int local_upload_rate_limit() const;
|
||||||
|
@ -273,16 +274,17 @@ namespace libtorrent
|
||||||
|
|
||||||
void set_local_download_rate_limit(int bytes_per_second);
|
void set_local_download_rate_limit(int bytes_per_second);
|
||||||
void set_local_upload_rate_limit(int bytes_per_second);
|
void set_local_upload_rate_limit(int bytes_per_second);
|
||||||
|
|
||||||
void set_download_rate_limit(int bytes_per_second);
|
void set_download_rate_limit(int bytes_per_second);
|
||||||
void set_upload_rate_limit(int bytes_per_second);
|
void set_upload_rate_limit(int bytes_per_second);
|
||||||
void set_max_half_open_connections(int limit);
|
void set_max_half_open_connections(int limit);
|
||||||
void set_max_connections(int limit);
|
void set_max_connections(int limit);
|
||||||
void set_max_uploads(int limit);
|
void set_max_uploads(int limit);
|
||||||
|
|
||||||
int max_connections() const { return m_max_connections; }
|
int max_connections() const;
|
||||||
int max_uploads() const { return m_max_uploads; }
|
int max_uploads() const;
|
||||||
int max_half_open_connections() const { return m_half_open.limit(); }
|
int max_half_open_connections() const;
|
||||||
|
|
||||||
|
#endif
|
||||||
|
|
||||||
int num_uploads() const { return m_num_unchoked; }
|
int num_uploads() const { return m_num_unchoked; }
|
||||||
int num_connections() const
|
int num_connections() const
|
||||||
|
@ -395,6 +397,10 @@ namespace libtorrent
|
||||||
|
|
||||||
// private:
|
// private:
|
||||||
|
|
||||||
|
void update_connections_limit();
|
||||||
|
void update_unchoke_limit();
|
||||||
|
void update_rate_settings();
|
||||||
|
|
||||||
void update_disk_thread_settings();
|
void update_disk_thread_settings();
|
||||||
void on_lsd_peer(tcp::endpoint peer, sha1_hash const& ih);
|
void on_lsd_peer(tcp::endpoint peer, sha1_hash const& ih);
|
||||||
void setup_socket_buffers(socket_type& s);
|
void setup_socket_buffers(socket_type& s);
|
||||||
|
@ -605,16 +611,10 @@ namespace libtorrent
|
||||||
// is true if the session is paused
|
// is true if the session is paused
|
||||||
bool m_paused;
|
bool m_paused;
|
||||||
|
|
||||||
// the max number of unchoked peers as set by the user
|
|
||||||
int m_max_uploads;
|
|
||||||
|
|
||||||
// the number of unchoked peers as set by the auto-unchoker
|
// the number of unchoked peers as set by the auto-unchoker
|
||||||
// this should always be >= m_max_uploads
|
// this should always be >= m_max_uploads
|
||||||
int m_allowed_upload_slots;
|
int m_allowed_upload_slots;
|
||||||
|
|
||||||
// the max number of connections, as set by the user
|
|
||||||
int m_max_connections;
|
|
||||||
|
|
||||||
// the number of unchoked peers
|
// the number of unchoked peers
|
||||||
int m_num_unchoked;
|
int m_num_unchoked;
|
||||||
|
|
||||||
|
|
|
@ -392,22 +392,39 @@ namespace libtorrent
|
||||||
proxy_settings i2p_proxy() const;
|
proxy_settings i2p_proxy() const;
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
int upload_rate_limit() const;
|
#ifndef TORRENT_NO_DEPRECATE
|
||||||
int download_rate_limit() const;
|
// deprecated in 0.16
|
||||||
int local_upload_rate_limit() const;
|
TORRENT_DEPRECATED_PREFIX
|
||||||
int local_download_rate_limit() const;
|
int upload_rate_limit() const TORRENT_DEPRECATED;
|
||||||
int max_half_open_connections() const;
|
TORRENT_DEPRECATED_PREFIX
|
||||||
|
int download_rate_limit() const TORRENT_DEPRECATED;
|
||||||
|
TORRENT_DEPRECATED_PREFIX
|
||||||
|
int local_upload_rate_limit() const TORRENT_DEPRECATED;
|
||||||
|
TORRENT_DEPRECATED_PREFIX
|
||||||
|
int local_download_rate_limit() const TORRENT_DEPRECATED;
|
||||||
|
TORRENT_DEPRECATED_PREFIX
|
||||||
|
int max_half_open_connections() const TORRENT_DEPRECATED;
|
||||||
|
|
||||||
void set_local_upload_rate_limit(int bytes_per_second);
|
TORRENT_DEPRECATED_PREFIX
|
||||||
void set_local_download_rate_limit(int bytes_per_second);
|
void set_local_upload_rate_limit(int bytes_per_second) TORRENT_DEPRECATED;
|
||||||
void set_upload_rate_limit(int bytes_per_second);
|
TORRENT_DEPRECATED_PREFIX
|
||||||
void set_download_rate_limit(int bytes_per_second);
|
void set_local_download_rate_limit(int bytes_per_second) TORRENT_DEPRECATED;
|
||||||
void set_max_uploads(int limit);
|
TORRENT_DEPRECATED_PREFIX
|
||||||
void set_max_connections(int limit);
|
void set_upload_rate_limit(int bytes_per_second) TORRENT_DEPRECATED;
|
||||||
void set_max_half_open_connections(int limit);
|
TORRENT_DEPRECATED_PREFIX
|
||||||
|
void set_download_rate_limit(int bytes_per_second) TORRENT_DEPRECATED;
|
||||||
|
TORRENT_DEPRECATED_PREFIX
|
||||||
|
void set_max_uploads(int limit) TORRENT_DEPRECATED;
|
||||||
|
TORRENT_DEPRECATED_PREFIX
|
||||||
|
void set_max_connections(int limit) TORRENT_DEPRECATED;
|
||||||
|
TORRENT_DEPRECATED_PREFIX
|
||||||
|
void set_max_half_open_connections(int limit) TORRENT_DEPRECATED;
|
||||||
|
|
||||||
int max_connections() const;
|
TORRENT_DEPRECATED_PREFIX
|
||||||
int max_uploads() const;
|
int max_connections() const TORRENT_DEPRECATED;
|
||||||
|
TORRENT_DEPRECATED_PREFIX
|
||||||
|
int max_uploads() const TORRENT_DEPRECATED;
|
||||||
|
#endif
|
||||||
|
|
||||||
std::auto_ptr<alert> pop_alert();
|
std::auto_ptr<alert> pop_alert();
|
||||||
#ifndef TORRENT_NO_DEPRECATE
|
#ifndef TORRENT_NO_DEPRECATE
|
||||||
|
|
|
@ -222,6 +222,14 @@ namespace libtorrent
|
||||||
, tick_interval(100)
|
, tick_interval(100)
|
||||||
, report_web_seed_downloads(true)
|
, report_web_seed_downloads(true)
|
||||||
, share_mode_target(3)
|
, share_mode_target(3)
|
||||||
|
|
||||||
|
, upload_rate_limit(0)
|
||||||
|
, download_rate_limit(0)
|
||||||
|
, local_upload_rate_limit(0)
|
||||||
|
, local_download_rate_limit(0)
|
||||||
|
, unchoke_slots_limit(8)
|
||||||
|
, half_open_limit(0)
|
||||||
|
, connections_limit(200)
|
||||||
{}
|
{}
|
||||||
|
|
||||||
// libtorrent version. Used for forward binary compatibility
|
// libtorrent version. Used for forward binary compatibility
|
||||||
|
@ -847,6 +855,30 @@ namespace libtorrent
|
||||||
|
|
||||||
// this is the target share ratio for share-mode torrents
|
// this is the target share ratio for share-mode torrents
|
||||||
int share_mode_target;
|
int share_mode_target;
|
||||||
|
|
||||||
|
// max upload rate in bytes per second for the session
|
||||||
|
int upload_rate_limit;
|
||||||
|
|
||||||
|
// max download rate in bytes per second for the session
|
||||||
|
int download_rate_limit;
|
||||||
|
|
||||||
|
// max upload rate in bytes per second for peers on the local
|
||||||
|
// network, in the session
|
||||||
|
int local_upload_rate_limit;
|
||||||
|
|
||||||
|
// max download rate in bytes per second for peers on the local
|
||||||
|
// network, in the session
|
||||||
|
int local_download_rate_limit;
|
||||||
|
|
||||||
|
// the max number of unchoke slots in the session (might be
|
||||||
|
// overridden by unchoke algorithm)
|
||||||
|
int unchoke_slots_limit;
|
||||||
|
|
||||||
|
// the max number of half-open TCP connections
|
||||||
|
int half_open_limit;
|
||||||
|
|
||||||
|
// the max number of connections in the session
|
||||||
|
int connections_limit;
|
||||||
};
|
};
|
||||||
|
|
||||||
#ifndef TORRENT_DISABLE_DHT
|
#ifndef TORRENT_DISABLE_DHT
|
||||||
|
|
|
@ -1435,7 +1435,7 @@ namespace libtorrent
|
||||||
// just unchoke it immediately
|
// just unchoke it immediately
|
||||||
send_unchoke();
|
send_unchoke();
|
||||||
}
|
}
|
||||||
else if (m_ses.num_uploads() < m_ses.max_uploads()
|
else if (m_ses.num_uploads() < m_ses.settings().unchoke_slots_limit
|
||||||
&& (t->ratio() == 0
|
&& (t->ratio() == 0
|
||||||
|| share_diff() >= size_type(-free_upload_amount)
|
|| share_diff() >= size_type(-free_upload_amount)
|
||||||
|| t->is_finished()))
|
|| t->is_finished()))
|
||||||
|
@ -1456,12 +1456,12 @@ namespace libtorrent
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
std::string reason;
|
std::string reason;
|
||||||
if (m_ses.num_uploads() >= m_ses.max_uploads())
|
if (m_ses.num_uploads() >= m_ses.settings().unchoke_slots_limit)
|
||||||
{
|
{
|
||||||
(*m_logger) << time_now_string() << " DID NOT UNCHOKE [ "
|
(*m_logger) << time_now_string() << " DID NOT UNCHOKE [ "
|
||||||
"the number of uploads (" << m_ses.num_uploads() <<
|
"the number of uploads (" << m_ses.num_uploads() <<
|
||||||
") is more than or equal to the limit ("
|
") is more than or equal to the limit ("
|
||||||
<< m_ses.max_uploads() << ") ]\n";
|
<< m_ses.settings().unchoke_slots_limit << ") ]\n";
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
@ -3511,7 +3511,7 @@ namespace libtorrent
|
||||||
}
|
}
|
||||||
|
|
||||||
p.estimated_reciprocation_rate = m_est_reciprocation_rate;
|
p.estimated_reciprocation_rate = m_est_reciprocation_rate;
|
||||||
int upload_capacity = m_ses.upload_rate_limit();
|
int upload_capacity = m_ses.settings().upload_rate_limit;
|
||||||
if (upload_capacity == 0)
|
if (upload_capacity == 0)
|
||||||
upload_capacity = (std::max)(20000, m_ses.m_peak_up_rate + 10000);
|
upload_capacity = (std::max)(20000, m_ses.m_peak_up_rate + 10000);
|
||||||
|
|
||||||
|
@ -3767,7 +3767,7 @@ namespace libtorrent
|
||||||
&& !m_peer_interested
|
&& !m_peer_interested
|
||||||
&& d1 > time_limit
|
&& d1 > time_limit
|
||||||
&& d2 > time_limit
|
&& d2 > time_limit
|
||||||
&& (m_ses.num_connections() >= m_ses.max_connections()
|
&& (m_ses.num_connections() >= m_ses.settings().connections_limit
|
||||||
|| (t && t->num_peers() >= t->max_connections())))
|
|| (t && t->num_peers() >= t->max_connections())))
|
||||||
{
|
{
|
||||||
#if defined TORRENT_VERBOSE_LOGGING || defined TORRENT_ERROR_LOGGING
|
#if defined TORRENT_VERBOSE_LOGGING || defined TORRENT_ERROR_LOGGING
|
||||||
|
@ -4199,7 +4199,7 @@ namespace libtorrent
|
||||||
// is decided based on the estimated reciprocation rate and
|
// is decided based on the estimated reciprocation rate and
|
||||||
// the share it represents of the total upload rate capacity
|
// the share it represents of the total upload rate capacity
|
||||||
// the torrent priority is taken into account when unchoking peers
|
// the torrent priority is taken into account when unchoking peers
|
||||||
int upload_capacity = m_ses.upload_rate_limit();
|
int upload_capacity = m_ses.settings().upload_rate_limit;
|
||||||
if (upload_capacity == 0)
|
if (upload_capacity == 0)
|
||||||
{
|
{
|
||||||
// we don't know at what rate we can upload. If we have a
|
// we don't know at what rate we can upload. If we have a
|
||||||
|
|
|
@ -686,7 +686,7 @@ namespace libtorrent
|
||||||
aux::session_impl& ses = m_torrent->session();
|
aux::session_impl& ses = m_torrent->session();
|
||||||
|
|
||||||
if (m_torrent->num_peers() >= m_torrent->max_connections()
|
if (m_torrent->num_peers() >= m_torrent->max_connections()
|
||||||
&& ses.num_connections() >= ses.max_connections()
|
&& ses.num_connections() >= ses.settings().connections_limit
|
||||||
&& c.remote().address() != m_torrent->current_tracker().address())
|
&& c.remote().address() != m_torrent->current_tracker().address())
|
||||||
{
|
{
|
||||||
c.disconnect(errors::too_many_connections);
|
c.disconnect(errors::too_many_connections);
|
||||||
|
|
|
@ -804,6 +804,7 @@ namespace libtorrent
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
#ifndef TORRENT_NO_DEPRECATE
|
||||||
int session::max_uploads() const
|
int session::max_uploads() const
|
||||||
{
|
{
|
||||||
TORRENT_SYNC_CALL_RET(int, max_uploads);
|
TORRENT_SYNC_CALL_RET(int, max_uploads);
|
||||||
|
@ -892,6 +893,7 @@ namespace libtorrent
|
||||||
TORRENT_SYNC_CALL_RET(int, num_connections);
|
TORRENT_SYNC_CALL_RET(int, num_connections);
|
||||||
return r;
|
return r;
|
||||||
}
|
}
|
||||||
|
#endif // TORRENT_NO_DEPRECATE
|
||||||
|
|
||||||
std::auto_ptr<alert> session::pop_alert()
|
std::auto_ptr<alert> session::pop_alert()
|
||||||
{
|
{
|
||||||
|
|
|
@ -319,6 +319,13 @@ namespace aux {
|
||||||
TORRENT_SETTING(boolean, ignore_resume_timestamps)
|
TORRENT_SETTING(boolean, ignore_resume_timestamps)
|
||||||
TORRENT_SETTING(boolean, anonymous_mode)
|
TORRENT_SETTING(boolean, anonymous_mode)
|
||||||
TORRENT_SETTING(integer, tick_interval)
|
TORRENT_SETTING(integer, tick_interval)
|
||||||
|
TORRENT_SETTING(integer, upload_rate_limit)
|
||||||
|
TORRENT_SETTING(integer, download_rate_limit)
|
||||||
|
TORRENT_SETTING(integer, local_upload_rate_limit)
|
||||||
|
TORRENT_SETTING(integer, local_download_rate_limit)
|
||||||
|
TORRENT_SETTING(integer, unchoke_slots_limit)
|
||||||
|
TORRENT_SETTING(integer, half_open_limit)
|
||||||
|
TORRENT_SETTING(integer, connections_limit)
|
||||||
};
|
};
|
||||||
|
|
||||||
#undef TORRENT_SETTING
|
#undef TORRENT_SETTING
|
||||||
|
@ -486,9 +493,7 @@ namespace aux {
|
||||||
#endif
|
#endif
|
||||||
, m_abort(false)
|
, m_abort(false)
|
||||||
, m_paused(false)
|
, m_paused(false)
|
||||||
, m_max_uploads(8)
|
|
||||||
, m_allowed_upload_slots(8)
|
, m_allowed_upload_slots(8)
|
||||||
, m_max_connections(200)
|
|
||||||
, m_num_unchoked(0)
|
, m_num_unchoked(0)
|
||||||
, m_unchoke_time_scaler(0)
|
, m_unchoke_time_scaler(0)
|
||||||
, m_auto_manage_time_scaler(0)
|
, m_auto_manage_time_scaler(0)
|
||||||
|
@ -617,6 +622,7 @@ namespace aux {
|
||||||
// before XP SP2, there was no limit
|
// before XP SP2, there was no limit
|
||||||
m_half_open.limit(0);
|
m_half_open.limit(0);
|
||||||
}
|
}
|
||||||
|
m_settings.half_open_limit = m_half_open.limit();
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
m_bandwidth_channel[peer_connection::download_channel] = &m_download_channel;
|
m_bandwidth_channel[peer_connection::download_channel] = &m_download_channel;
|
||||||
|
@ -724,11 +730,12 @@ namespace aux {
|
||||||
rl.rlim_cur -= 20;
|
rl.rlim_cur -= 20;
|
||||||
|
|
||||||
// 80% of the available file descriptors should go
|
// 80% of the available file descriptors should go
|
||||||
m_max_connections = (std::min)(m_max_connections, int(rl.rlim_cur * 8 / 10));
|
m_settings.connections_limit = (std::min)(m_settings.connections_limit
|
||||||
|
, int(rl.rlim_cur * 8 / 10));
|
||||||
// 20% goes towards regular files
|
// 20% goes towards regular files
|
||||||
m_files.resize((std::min)(m_files.size_limit(), int(rl.rlim_cur * 2 / 10)));
|
m_files.resize((std::min)(m_files.size_limit(), int(rl.rlim_cur * 2 / 10)));
|
||||||
#if defined TORRENT_VERBOSE_LOGGING || defined TORRENT_LOGGING || defined TORRENT_ERROR_LOGGING
|
#if defined TORRENT_VERBOSE_LOGGING || defined TORRENT_LOGGING || defined TORRENT_ERROR_LOGGING
|
||||||
(*m_logger) << time_now_string() << " max connections: " << m_max_connections << "\n";
|
(*m_logger) << time_now_string() << " max connections: " << m_settings.connections_limit << "\n";
|
||||||
(*m_logger) << time_now_string() << " max files: " << m_files.size_limit() << "\n";
|
(*m_logger) << time_now_string() << " max files: " << m_files.size_limit() << "\n";
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
@ -750,6 +757,10 @@ namespace aux {
|
||||||
|
|
||||||
url_random((char*)&m_peer_id[print.length()], (char*)&m_peer_id[0] + 20);
|
url_random((char*)&m_peer_id[print.length()], (char*)&m_peer_id[0] + 20);
|
||||||
|
|
||||||
|
update_rate_settings();
|
||||||
|
update_connections_limit();
|
||||||
|
update_unchoke_limit();
|
||||||
|
|
||||||
m_thread.reset(new thread(boost::bind(&session_impl::main_thread, this)));
|
m_thread.reset(new thread(boost::bind(&session_impl::main_thread, this)));
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -790,18 +801,6 @@ namespace aux {
|
||||||
|
|
||||||
entry& e = *eptr;
|
entry& e = *eptr;
|
||||||
|
|
||||||
if (flags & session::save_settings)
|
|
||||||
{
|
|
||||||
// TODO: move these to session_settings
|
|
||||||
e["upload_rate_limit"] = upload_rate_limit();
|
|
||||||
e["download_rate_limit"] = download_rate_limit();
|
|
||||||
e["local_upload_rate_limit"] = local_upload_rate_limit();
|
|
||||||
e["local_download_rate_limit"] = local_download_rate_limit();
|
|
||||||
e["max_uploads"] = max_uploads();
|
|
||||||
e["max_half_open_connections"] = max_half_open_connections();
|
|
||||||
e["max_connections"] = max_connections();
|
|
||||||
}
|
|
||||||
|
|
||||||
for (int i = 0; i < sizeof(all_settings)/sizeof(all_settings[0]); ++i)
|
for (int i = 0; i < sizeof(all_settings)/sizeof(all_settings[0]); ++i)
|
||||||
{
|
{
|
||||||
session_category const& c = all_settings[i];
|
session_category const& c = all_settings[i];
|
||||||
|
@ -866,14 +865,6 @@ namespace aux {
|
||||||
|
|
||||||
if (e->type() != lazy_entry::dict_t) return;
|
if (e->type() != lazy_entry::dict_t) return;
|
||||||
|
|
||||||
set_upload_rate_limit(e->dict_find_int_value("upload_rate_limit", 0));
|
|
||||||
set_download_rate_limit(e->dict_find_int_value("download_rate_limit", 0));
|
|
||||||
set_local_upload_rate_limit(e->dict_find_int_value("local_upload_rate_limit", 0));
|
|
||||||
set_local_download_rate_limit(e->dict_find_int_value("local_download_rate_limit", 0));
|
|
||||||
set_max_uploads(e->dict_find_int_value("max_uploads", 0));
|
|
||||||
set_max_half_open_connections(e->dict_find_int_value("max_half_open_connections", 0));
|
|
||||||
set_max_connections(e->dict_find_int_value("max_connections", 0));
|
|
||||||
|
|
||||||
for (int i = 0; i < sizeof(all_settings)/sizeof(all_settings[0]); ++i)
|
for (int i = 0; i < sizeof(all_settings)/sizeof(all_settings[0]); ++i)
|
||||||
{
|
{
|
||||||
session_category const& c = all_settings[i];
|
session_category const& c = all_settings[i];
|
||||||
|
@ -881,6 +872,17 @@ namespace aux {
|
||||||
if (!settings) continue;
|
if (!settings) continue;
|
||||||
load_struct(*settings, reinterpret_cast<char*>(this) + c.offset, c.map, c.num_entries);
|
load_struct(*settings, reinterpret_cast<char*>(this) + c.offset, c.map, c.num_entries);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
update_rate_settings();
|
||||||
|
|
||||||
|
update_connections_limit();
|
||||||
|
update_unchoke_limit();
|
||||||
|
|
||||||
|
// in case we just set a socks proxy, we might have to
|
||||||
|
// open the socks incoming connection
|
||||||
|
if (!m_socks_listen_socket) open_new_incoming_socks_connection();
|
||||||
|
m_udp_socket.set_proxy_settings(m_proxy);
|
||||||
|
|
||||||
#ifndef TORRENT_DISABLE_DHT
|
#ifndef TORRENT_DISABLE_DHT
|
||||||
settings = e->dict_find_dict("dht");
|
settings = e->dict_find_dict("dht");
|
||||||
if (settings)
|
if (settings)
|
||||||
|
@ -1265,6 +1267,9 @@ namespace aux {
|
||||||
|| m_settings.low_prio_disk != s.low_prio_disk)
|
|| m_settings.low_prio_disk != s.low_prio_disk)
|
||||||
update_disk_io_thread = true;
|
update_disk_io_thread = true;
|
||||||
|
|
||||||
|
bool connections_limit_changed = m_settings.connections_limit != s.connections_limit;
|
||||||
|
bool unchoke_limit_changed = m_settings.unchoke_slots_limit != s.unchoke_slots_limit;
|
||||||
|
|
||||||
#ifndef TORRENT_NO_DEPRECATE
|
#ifndef TORRENT_NO_DEPRECATE
|
||||||
// support deprecated choker settings
|
// support deprecated choker settings
|
||||||
if (s.choking_algorithm == session_settings::rate_based_choker)
|
if (s.choking_algorithm == session_settings::rate_based_choker)
|
||||||
|
@ -1342,6 +1347,11 @@ namespace aux {
|
||||||
|
|
||||||
m_settings = s;
|
m_settings = s;
|
||||||
|
|
||||||
|
update_rate_settings();
|
||||||
|
|
||||||
|
if (connections_limit_changed) update_connections_limit();
|
||||||
|
if (unchoke_limit_changed) update_unchoke_limit();
|
||||||
|
|
||||||
// enable anonymous mode. We don't want to accept any incoming
|
// enable anonymous mode. We don't want to accept any incoming
|
||||||
// connections, except through a proxy.
|
// connections, except through a proxy.
|
||||||
if (anonymous)
|
if (anonymous)
|
||||||
|
@ -1376,10 +1386,10 @@ namespace aux {
|
||||||
}
|
}
|
||||||
|
|
||||||
if (s.choking_algorithm == session_settings::fixed_slots_choker)
|
if (s.choking_algorithm == session_settings::fixed_slots_choker)
|
||||||
m_allowed_upload_slots = m_max_uploads;
|
m_allowed_upload_slots = m_settings.unchoke_slots_limit;
|
||||||
else if (s.choking_algorithm == session_settings::auto_expand_choker
|
else if (s.choking_algorithm == session_settings::auto_expand_choker
|
||||||
&& m_allowed_upload_slots < m_max_uploads)
|
&& m_allowed_upload_slots < m_settings.unchoke_slots_limit)
|
||||||
m_allowed_upload_slots = m_max_uploads;
|
m_allowed_upload_slots = m_settings.unchoke_slots_limit;
|
||||||
|
|
||||||
// replace all occurances of '\n' with ' '.
|
// replace all occurances of '\n' with ' '.
|
||||||
std::string::iterator i = m_settings.user_agent.begin();
|
std::string::iterator i = m_settings.user_agent.begin();
|
||||||
|
@ -1791,8 +1801,8 @@ namespace aux {
|
||||||
// because we have too many files open, try again
|
// because we have too many files open, try again
|
||||||
// and lower the number of file descriptors used
|
// and lower the number of file descriptors used
|
||||||
// elsewere.
|
// elsewere.
|
||||||
if (m_max_connections > 10)
|
if (m_settings.connections_limit > 10)
|
||||||
--m_max_connections;
|
--m_settings.connections_limit;
|
||||||
// try again, but still alert the user of the problem
|
// try again, but still alert the user of the problem
|
||||||
async_accept(listener);
|
async_accept(listener);
|
||||||
}
|
}
|
||||||
|
@ -1844,10 +1854,10 @@ namespace aux {
|
||||||
// don't allow more connections than the max setting
|
// don't allow more connections than the max setting
|
||||||
bool reject = false;
|
bool reject = false;
|
||||||
if (m_settings.ignore_limits_on_local_network && is_local(endp.address()))
|
if (m_settings.ignore_limits_on_local_network && is_local(endp.address()))
|
||||||
reject = max_connections() < INT_MAX / 12
|
reject = m_settings.connections_limit < INT_MAX / 12
|
||||||
&& num_connections() >= max_connections() * 12 / 10;
|
&& num_connections() >= m_settings.connections_limit * 12 / 10;
|
||||||
else
|
else
|
||||||
reject = num_connections() >= max_connections();
|
reject = num_connections() >= m_settings.connections_limit;
|
||||||
|
|
||||||
if (reject)
|
if (reject)
|
||||||
{
|
{
|
||||||
|
@ -1859,7 +1869,7 @@ namespace aux {
|
||||||
}
|
}
|
||||||
#if defined(TORRENT_VERBOSE_LOGGING) || defined(TORRENT_LOGGING)
|
#if defined(TORRENT_VERBOSE_LOGGING) || defined(TORRENT_LOGGING)
|
||||||
(*m_logger) << "number of connections limit exceeded (conns: "
|
(*m_logger) << "number of connections limit exceeded (conns: "
|
||||||
<< num_connections() << ", limit: " << max_connections()
|
<< num_connections() << ", limit: " << m_settings.connections_limit
|
||||||
<< "), connection rejected\n";
|
<< "), connection rejected\n";
|
||||||
#endif
|
#endif
|
||||||
return;
|
return;
|
||||||
|
@ -2393,7 +2403,7 @@ namespace aux {
|
||||||
int free_slots = m_half_open.free_slots();
|
int free_slots = m_half_open.free_slots();
|
||||||
if (!m_torrents.empty()
|
if (!m_torrents.empty()
|
||||||
&& free_slots > -m_half_open.limit()
|
&& free_slots > -m_half_open.limit()
|
||||||
&& num_connections() < m_max_connections
|
&& num_connections() < m_settings.connections_limit
|
||||||
&& !m_abort
|
&& !m_abort
|
||||||
&& m_settings.connection_speed > 0)
|
&& m_settings.connection_speed > 0)
|
||||||
{
|
{
|
||||||
|
@ -2446,8 +2456,8 @@ namespace aux {
|
||||||
// we ran out of memory trying to connect to a peer
|
// we ran out of memory trying to connect to a peer
|
||||||
// lower the global limit to the number of peers
|
// lower the global limit to the number of peers
|
||||||
// we already have
|
// we already have
|
||||||
m_max_connections = num_connections();
|
m_settings.connections_limit = num_connections();
|
||||||
if (m_max_connections < 2) m_max_connections = 2;
|
if (m_settings.connections_limit < 2) m_settings.connections_limit = 2;
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
@ -2466,7 +2476,7 @@ namespace aux {
|
||||||
// attempts this tick, abort
|
// attempts this tick, abort
|
||||||
if (max_connections == 0) break;
|
if (max_connections == 0) break;
|
||||||
// maintain the global limit on number of connections
|
// maintain the global limit on number of connections
|
||||||
if (num_connections() >= m_max_connections) break;
|
if (num_connections() >= m_settings.connections_limit) break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -2510,7 +2520,7 @@ namespace aux {
|
||||||
{
|
{
|
||||||
m_disconnect_time_scaler = 90;
|
m_disconnect_time_scaler = 90;
|
||||||
|
|
||||||
if (num_connections() >= max_connections() * m_settings.peer_turnover_cutoff
|
if (num_connections() >= m_settings.connections_limit * m_settings.peer_turnover_cutoff
|
||||||
&& !m_torrents.empty())
|
&& !m_torrents.empty())
|
||||||
{
|
{
|
||||||
// every 90 seconds, disconnect the worst peers
|
// every 90 seconds, disconnect the worst peers
|
||||||
|
@ -2979,7 +2989,7 @@ namespace aux {
|
||||||
++m_allowed_upload_slots;
|
++m_allowed_upload_slots;
|
||||||
}
|
}
|
||||||
else if (m_upload_rate.queue_size() > 1
|
else if (m_upload_rate.queue_size() > 1
|
||||||
&& m_allowed_upload_slots > m_max_uploads)
|
&& m_allowed_upload_slots > m_settings.unchoke_slots_limit)
|
||||||
{
|
{
|
||||||
--m_allowed_upload_slots;
|
--m_allowed_upload_slots;
|
||||||
}
|
}
|
||||||
|
@ -3753,16 +3763,98 @@ namespace aux {
|
||||||
TORRENT_ASSERT(m_connections.empty());
|
TORRENT_ASSERT(m_connections.empty());
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#ifndef TORRENT_NO_DEPRECATE
|
||||||
|
int session_impl::max_connections() const
|
||||||
|
{
|
||||||
|
return m_settings.connections_limit;
|
||||||
|
}
|
||||||
|
|
||||||
|
int session_impl::max_uploads() const
|
||||||
|
{
|
||||||
|
return m_settings.unchoke_slots_limit;
|
||||||
|
}
|
||||||
|
|
||||||
|
int session_impl::max_half_open_connections() const
|
||||||
|
{
|
||||||
|
return m_settings.half_open_limit;
|
||||||
|
}
|
||||||
|
|
||||||
|
void session_impl::set_local_download_rate_limit(int bytes_per_second)
|
||||||
|
{
|
||||||
|
session_settings s = m_settings;
|
||||||
|
s.local_download_rate_limit = bytes_per_second;
|
||||||
|
set_settings(s);
|
||||||
|
}
|
||||||
|
|
||||||
|
void session_impl::set_local_upload_rate_limit(int bytes_per_second)
|
||||||
|
{
|
||||||
|
session_settings s = m_settings;
|
||||||
|
s.local_upload_rate_limit = bytes_per_second;
|
||||||
|
set_settings(s);
|
||||||
|
}
|
||||||
|
|
||||||
|
void session_impl::set_download_rate_limit(int bytes_per_second)
|
||||||
|
{
|
||||||
|
session_settings s = m_settings;
|
||||||
|
s.download_rate_limit = bytes_per_second;
|
||||||
|
set_settings(s);
|
||||||
|
}
|
||||||
|
|
||||||
|
void session_impl::set_upload_rate_limit(int bytes_per_second)
|
||||||
|
{
|
||||||
|
session_settings s = m_settings;
|
||||||
|
s.upload_rate_limit = bytes_per_second;
|
||||||
|
set_settings(s);
|
||||||
|
}
|
||||||
|
|
||||||
|
void session_impl::set_max_half_open_connections(int limit)
|
||||||
|
{
|
||||||
|
session_settings s = m_settings;
|
||||||
|
s.half_open_limit = limit;
|
||||||
|
set_settings(s);
|
||||||
|
}
|
||||||
|
|
||||||
|
void session_impl::set_max_connections(int limit)
|
||||||
|
{
|
||||||
|
session_settings s = m_settings;
|
||||||
|
s.connections_limit = limit;
|
||||||
|
set_settings(s);
|
||||||
|
}
|
||||||
|
|
||||||
void session_impl::set_max_uploads(int limit)
|
void session_impl::set_max_uploads(int limit)
|
||||||
{
|
{
|
||||||
TORRENT_ASSERT(limit >= 0 || limit == -1);
|
session_settings s = m_settings;
|
||||||
|
s.unchoke_slots_limit = limit;
|
||||||
|
set_settings(s);
|
||||||
|
}
|
||||||
|
|
||||||
INVARIANT_CHECK;
|
int session_impl::local_upload_rate_limit() const
|
||||||
|
{
|
||||||
|
return m_local_upload_channel.throttle();
|
||||||
|
}
|
||||||
|
|
||||||
if (limit < 0) limit = (std::numeric_limits<int>::max)();
|
int session_impl::local_download_rate_limit() const
|
||||||
if (m_max_uploads == limit) return;
|
{
|
||||||
m_max_uploads = limit;
|
return m_local_download_channel.throttle();
|
||||||
m_allowed_upload_slots = limit;
|
}
|
||||||
|
|
||||||
|
int session_impl::upload_rate_limit() const
|
||||||
|
{
|
||||||
|
return m_upload_channel.throttle();
|
||||||
|
}
|
||||||
|
|
||||||
|
int session_impl::download_rate_limit() const
|
||||||
|
{
|
||||||
|
return m_download_channel.throttle();
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
void session_impl::update_unchoke_limit()
|
||||||
|
{
|
||||||
|
if (m_settings.unchoke_slots_limit < 0)
|
||||||
|
m_settings.unchoke_slots_limit = (std::numeric_limits<int>::max)();
|
||||||
|
|
||||||
|
m_allowed_upload_slots = m_settings.unchoke_slots_limit;
|
||||||
if (m_settings.num_optimistic_unchoke_slots >= m_allowed_upload_slots / 2)
|
if (m_settings.num_optimistic_unchoke_slots >= m_allowed_upload_slots / 2)
|
||||||
{
|
{
|
||||||
if (m_alerts.should_post<performance_alert>())
|
if (m_alerts.should_post<performance_alert>())
|
||||||
|
@ -3771,37 +3863,59 @@ namespace aux {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void session_impl::set_max_connections(int limit)
|
void session_impl::update_rate_settings()
|
||||||
|
{
|
||||||
|
if (m_settings.half_open_limit <= 0) m_settings.half_open_limit
|
||||||
|
= (std::numeric_limits<int>::max)();
|
||||||
|
m_half_open.limit(m_settings.half_open_limit);
|
||||||
|
|
||||||
|
if (m_settings.local_download_rate_limit < 0)
|
||||||
|
m_settings.local_download_rate_limit = 0;
|
||||||
|
m_local_download_channel.throttle(m_settings.local_download_rate_limit);
|
||||||
|
|
||||||
|
if (m_settings.local_upload_rate_limit < 0)
|
||||||
|
m_settings.local_upload_rate_limit = 0;
|
||||||
|
m_local_upload_channel.throttle(m_settings.local_upload_rate_limit);
|
||||||
|
|
||||||
|
if (m_settings.download_rate_limit < 0)
|
||||||
|
m_settings.download_rate_limit = 0;
|
||||||
|
m_download_channel.throttle(m_settings.download_rate_limit);
|
||||||
|
|
||||||
|
if (m_settings.upload_rate_limit < 0)
|
||||||
|
m_settings.upload_rate_limit = 0;
|
||||||
|
m_upload_channel.throttle(m_settings.upload_rate_limit);
|
||||||
|
}
|
||||||
|
|
||||||
|
void session_impl::update_connections_limit()
|
||||||
{
|
{
|
||||||
INVARIANT_CHECK;
|
INVARIANT_CHECK;
|
||||||
|
|
||||||
if (limit <= 0)
|
if (m_settings.connections_limit <= 0)
|
||||||
{
|
{
|
||||||
limit = (std::numeric_limits<int>::max)();
|
m_settings.connections_limit = (std::numeric_limits<int>::max)();
|
||||||
#if TORRENT_USE_RLIMIT
|
#if TORRENT_USE_RLIMIT
|
||||||
rlimit l;
|
rlimit l;
|
||||||
if (getrlimit(RLIMIT_NOFILE, &l) == 0
|
if (getrlimit(RLIMIT_NOFILE, &l) == 0
|
||||||
&& l.rlim_cur != RLIM_INFINITY)
|
&& l.rlim_cur != RLIM_INFINITY)
|
||||||
{
|
{
|
||||||
limit = l.rlim_cur - m_settings.file_pool_size;
|
m_settings.connections_limit = l.rlim_cur - m_settings.file_pool_size;
|
||||||
if (limit < 5) limit = 5;
|
if (m_settings.connections_limit < 5) m_settings.connections_limit = 5;
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
m_max_connections = limit;
|
|
||||||
|
|
||||||
if (num_connections() > max_connections() && !m_torrents.empty())
|
if (num_connections() > m_settings.connections_limit && !m_torrents.empty())
|
||||||
{
|
{
|
||||||
// if we have more connections that we're allowed, disconnect
|
// if we have more connections that we're allowed, disconnect
|
||||||
// peers from the torrents so that they are all as even as possible
|
// peers from the torrents so that they are all as even as possible
|
||||||
|
|
||||||
int to_disconnect = num_connections() - max_connections();
|
int to_disconnect = num_connections() - m_settings.connections_limit;
|
||||||
|
|
||||||
int last_average = 0;
|
int last_average = 0;
|
||||||
int average = max_connections() / m_torrents.size();
|
int average = m_settings.connections_limit / m_torrents.size();
|
||||||
|
|
||||||
// the number of slots that are unused by torrents
|
// the number of slots that are unused by torrents
|
||||||
int extra = max_connections() % m_torrents.size();
|
int extra = m_settings.connections_limit % m_torrents.size();
|
||||||
|
|
||||||
// run 3 iterations of this, then we're probably close enough
|
// run 3 iterations of this, then we're probably close enough
|
||||||
for (int iter = 0; iter < 4; ++iter)
|
for (int iter = 0; iter < 4; ++iter)
|
||||||
|
@ -3848,46 +3962,6 @@ namespace aux {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void session_impl::set_max_half_open_connections(int limit)
|
|
||||||
{
|
|
||||||
INVARIANT_CHECK;
|
|
||||||
|
|
||||||
if (limit <= 0) limit = (std::numeric_limits<int>::max)();
|
|
||||||
m_half_open.limit(limit);
|
|
||||||
}
|
|
||||||
|
|
||||||
void session_impl::set_local_download_rate_limit(int bytes_per_second)
|
|
||||||
{
|
|
||||||
INVARIANT_CHECK;
|
|
||||||
|
|
||||||
if (bytes_per_second <= 0) bytes_per_second = 0;
|
|
||||||
m_local_download_channel.throttle(bytes_per_second);
|
|
||||||
}
|
|
||||||
|
|
||||||
void session_impl::set_local_upload_rate_limit(int bytes_per_second)
|
|
||||||
{
|
|
||||||
INVARIANT_CHECK;
|
|
||||||
|
|
||||||
if (bytes_per_second <= 0) bytes_per_second = 0;
|
|
||||||
m_local_upload_channel.throttle(bytes_per_second);
|
|
||||||
}
|
|
||||||
|
|
||||||
void session_impl::set_download_rate_limit(int bytes_per_second)
|
|
||||||
{
|
|
||||||
INVARIANT_CHECK;
|
|
||||||
|
|
||||||
if (bytes_per_second <= 0) bytes_per_second = 0;
|
|
||||||
m_download_channel.throttle(bytes_per_second);
|
|
||||||
}
|
|
||||||
|
|
||||||
void session_impl::set_upload_rate_limit(int bytes_per_second)
|
|
||||||
{
|
|
||||||
INVARIANT_CHECK;
|
|
||||||
|
|
||||||
if (bytes_per_second <= 0) bytes_per_second = 0;
|
|
||||||
m_upload_channel.throttle(bytes_per_second);
|
|
||||||
}
|
|
||||||
|
|
||||||
void session_impl::set_alert_dispatch(boost::function<void(std::auto_ptr<alert>)> const& fun)
|
void session_impl::set_alert_dispatch(boost::function<void(std::auto_ptr<alert>)> const& fun)
|
||||||
{
|
{
|
||||||
m_alerts.set_dispatch_function(fun);
|
m_alerts.set_dispatch_function(fun);
|
||||||
|
@ -3916,26 +3990,6 @@ namespace aux {
|
||||||
return m_alerts.set_alert_queue_size_limit(queue_size_limit_);
|
return m_alerts.set_alert_queue_size_limit(queue_size_limit_);
|
||||||
}
|
}
|
||||||
|
|
||||||
int session_impl::local_upload_rate_limit() const
|
|
||||||
{
|
|
||||||
return m_local_upload_channel.throttle();
|
|
||||||
}
|
|
||||||
|
|
||||||
int session_impl::local_download_rate_limit() const
|
|
||||||
{
|
|
||||||
return m_local_download_channel.throttle();
|
|
||||||
}
|
|
||||||
|
|
||||||
int session_impl::upload_rate_limit() const
|
|
||||||
{
|
|
||||||
return m_upload_channel.throttle();
|
|
||||||
}
|
|
||||||
|
|
||||||
int session_impl::download_rate_limit() const
|
|
||||||
{
|
|
||||||
return m_download_channel.throttle();
|
|
||||||
}
|
|
||||||
|
|
||||||
void session_impl::start_lsd()
|
void session_impl::start_lsd()
|
||||||
{
|
{
|
||||||
INVARIANT_CHECK;
|
INVARIANT_CHECK;
|
||||||
|
@ -4155,10 +4209,10 @@ namespace aux {
|
||||||
TORRENT_ASSERT(int(unique.size()) == total_downloaders);
|
TORRENT_ASSERT(int(unique.size()) == total_downloaders);
|
||||||
|
|
||||||
std::set<peer_connection*> unique_peers;
|
std::set<peer_connection*> unique_peers;
|
||||||
TORRENT_ASSERT(m_max_connections > 0);
|
TORRENT_ASSERT(m_settings.connections_limit > 0);
|
||||||
TORRENT_ASSERT(m_max_uploads >= 0);
|
TORRENT_ASSERT(m_settings.unchoke_slots_limit >= 0);
|
||||||
if (m_settings.choking_algorithm == session_settings::auto_expand_choker)
|
if (m_settings.choking_algorithm == session_settings::auto_expand_choker)
|
||||||
TORRENT_ASSERT(m_allowed_upload_slots >= m_max_uploads);
|
TORRENT_ASSERT(m_allowed_upload_slots >= m_settings.unchoke_slots_limit);
|
||||||
int unchokes = 0;
|
int unchokes = 0;
|
||||||
int num_optimistic = 0;
|
int num_optimistic = 0;
|
||||||
for (connection_map::const_iterator i = m_connections.begin();
|
for (connection_map::const_iterator i = m_connections.begin();
|
||||||
|
|
|
@ -4328,7 +4328,7 @@ namespace libtorrent
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
TORRENT_ASSERT(want_more_peers());
|
TORRENT_ASSERT(want_more_peers());
|
||||||
TORRENT_ASSERT(m_ses.num_connections() < m_ses.max_connections());
|
TORRENT_ASSERT(m_ses.num_connections() < m_ses.settings().connections_limit);
|
||||||
|
|
||||||
tcp::endpoint a(peerinfo->ip());
|
tcp::endpoint a(peerinfo->ip());
|
||||||
TORRENT_ASSERT((m_ses.m_ip_filter.access(peerinfo->address()) & ip_filter::blocked) == 0);
|
TORRENT_ASSERT((m_ses.m_ip_filter.access(peerinfo->address()) & ip_filter::blocked) == 0);
|
||||||
|
|
|
@ -25,18 +25,18 @@ void test_swarm()
|
||||||
// immediately. To make the swarm actually connect all
|
// immediately. To make the swarm actually connect all
|
||||||
// three peers before finishing.
|
// three peers before finishing.
|
||||||
float rate_limit = 100000;
|
float rate_limit = 100000;
|
||||||
ses1.set_upload_rate_limit(int(rate_limit));
|
|
||||||
ses1.set_max_uploads(1);
|
|
||||||
ses2.set_download_rate_limit(int(rate_limit / 5));
|
|
||||||
ses3.set_download_rate_limit(int(rate_limit / 5));
|
|
||||||
ses2.set_upload_rate_limit(int(rate_limit / 10));
|
|
||||||
ses3.set_upload_rate_limit(int(rate_limit / 10));
|
|
||||||
|
|
||||||
session_settings settings;
|
session_settings settings;
|
||||||
settings.allow_multiple_connections_per_ip = true;
|
settings.allow_multiple_connections_per_ip = true;
|
||||||
settings.ignore_limits_on_local_network = false;
|
settings.ignore_limits_on_local_network = false;
|
||||||
settings.choking_algorithm = session_settings::auto_expand_choker;
|
settings.choking_algorithm = session_settings::auto_expand_choker;
|
||||||
|
settings.upload_rate_limit = rate_limit;
|
||||||
|
settings.unchoke_slots_limit = 1;
|
||||||
ses1.set_settings(settings);
|
ses1.set_settings(settings);
|
||||||
|
|
||||||
|
settings.upload_rate_limit = rate_limit / 10;
|
||||||
|
settings.download_rate_limit = rate_limit / 5;
|
||||||
|
settings.unchoke_slots_limit = 0;
|
||||||
ses2.set_settings(settings);
|
ses2.set_settings(settings);
|
||||||
ses3.set_settings(settings);
|
ses3.set_settings(settings);
|
||||||
|
|
||||||
|
|
|
@ -53,13 +53,21 @@ void test_pex()
|
||||||
// immediately. To make the swarm actually connect all
|
// immediately. To make the swarm actually connect all
|
||||||
// three peers before finishing.
|
// three peers before finishing.
|
||||||
float rate_limit = 1000;
|
float rate_limit = 1000;
|
||||||
ses1.set_upload_rate_limit(int(rate_limit));
|
session_settings set = ses1.settings();
|
||||||
ses2.set_download_rate_limit(int(rate_limit));
|
set.upload_rate_limit = rate_limit;
|
||||||
ses3.set_download_rate_limit(int(rate_limit));
|
ses1.set_settings(set);
|
||||||
|
|
||||||
// make the peer connecting the two worthless to transfer
|
// make the peer connecting the two worthless to transfer
|
||||||
// data, to force peer 3 to connect directly to peer 1 through pex
|
// data, to force peer 3 to connect directly to peer 1 through pex
|
||||||
ses2.set_upload_rate_limit(2000);
|
set = ses2.settings();
|
||||||
ses3.set_upload_rate_limit(int(rate_limit / 2));
|
set.download_rate_limit = rate_limit;
|
||||||
|
set.upload_rate_limit = 2000;
|
||||||
|
ses2.set_settings(set);
|
||||||
|
|
||||||
|
set = ses3.settings();
|
||||||
|
set.download_rate_limit = rate_limit;
|
||||||
|
set.upload_rate_limit = rate_limit / 2;
|
||||||
|
ses3.set_settings(set);
|
||||||
|
|
||||||
ses1.add_extension(&create_ut_pex_plugin);
|
ses1.add_extension(&create_ut_pex_plugin);
|
||||||
ses2.add_extension(&create_ut_pex_plugin);
|
ses2.add_extension(&create_ut_pex_plugin);
|
||||||
|
|
|
@ -60,17 +60,17 @@ void test_swarm(bool super_seeding = false, bool strict = false, bool seed_mode
|
||||||
// immediately. To make the swarm actually connect all
|
// immediately. To make the swarm actually connect all
|
||||||
// three peers before finishing.
|
// three peers before finishing.
|
||||||
float rate_limit = 100000;
|
float rate_limit = 100000;
|
||||||
ses1.set_upload_rate_limit(int(rate_limit));
|
|
||||||
ses2.set_download_rate_limit(int(rate_limit));
|
|
||||||
ses3.set_download_rate_limit(int(rate_limit));
|
|
||||||
ses2.set_upload_rate_limit(int(rate_limit / 2));
|
|
||||||
ses3.set_upload_rate_limit(int(rate_limit / 2));
|
|
||||||
|
|
||||||
session_settings settings;
|
session_settings settings;
|
||||||
settings.allow_multiple_connections_per_ip = true;
|
settings.allow_multiple_connections_per_ip = true;
|
||||||
settings.ignore_limits_on_local_network = false;
|
settings.ignore_limits_on_local_network = false;
|
||||||
settings.strict_super_seeding = strict;
|
settings.strict_super_seeding = strict;
|
||||||
|
|
||||||
|
settings.upload_rate_limit = rate_limit;
|
||||||
ses1.set_settings(settings);
|
ses1.set_settings(settings);
|
||||||
|
|
||||||
|
settings.download_rate_limit = rate_limit / 2;
|
||||||
|
settings.upload_rate_limit = rate_limit;
|
||||||
ses2.set_settings(settings);
|
ses2.set_settings(settings);
|
||||||
ses3.set_settings(settings);
|
ses3.set_settings(settings);
|
||||||
|
|
||||||
|
|
|
@ -82,7 +82,7 @@ void test_rate()
|
||||||
|
|
||||||
ptime start = time_now();
|
ptime start = time_now();
|
||||||
|
|
||||||
for (int i = 0; i < 70; ++i)
|
for (int i = 0; i < 7; ++i)
|
||||||
{
|
{
|
||||||
print_alerts(ses1, "ses1");
|
print_alerts(ses1, "ses1");
|
||||||
print_alerts(ses2, "ses2");
|
print_alerts(ses2, "ses2");
|
||||||
|
@ -97,7 +97,7 @@ void test_rate()
|
||||||
<< std::endl;
|
<< std::endl;
|
||||||
|
|
||||||
if (tor2.is_seed()) break;
|
if (tor2.is_seed()) break;
|
||||||
test_sleep(100);
|
test_sleep(1000);
|
||||||
}
|
}
|
||||||
|
|
||||||
TEST_CHECK(tor2.is_seed());
|
TEST_CHECK(tor2.is_seed());
|
||||||
|
@ -263,7 +263,7 @@ void test_transfer(int proxy_type, bool test_disk_full = false, bool test_allowe
|
||||||
if (test_allowed_fast)
|
if (test_allowed_fast)
|
||||||
{
|
{
|
||||||
sett.allowed_fast_set_size = 2000;
|
sett.allowed_fast_set_size = 2000;
|
||||||
ses1.set_max_uploads(0);
|
sett.unchoke_slots_limit = 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
sett.min_reconnect_time = 1;
|
sett.min_reconnect_time = 1;
|
||||||
|
@ -324,7 +324,9 @@ void test_transfer(int proxy_type, bool test_disk_full = false, bool test_allowe
|
||||||
& ~alert::stats_notification);
|
& ~alert::stats_notification);
|
||||||
// ses1.set_alert_dispatch(&print_alert);
|
// ses1.set_alert_dispatch(&print_alert);
|
||||||
|
|
||||||
ses2.set_download_rate_limit(tor2.get_torrent_info().piece_length() * 5);
|
sett = ses2.settings();
|
||||||
|
sett.download_rate_limit = tor2.get_torrent_info().piece_length() * 5;
|
||||||
|
ses2.set_settings(sett);
|
||||||
|
|
||||||
// also test to move the storage of the downloader and the uploader
|
// also test to move the storage of the downloader and the uploader
|
||||||
// to make sure it can handle switching paths
|
// to make sure it can handle switching paths
|
||||||
|
|
Loading…
Reference in New Issue