wornvirtue
/
premiere-libtorrent
forked from premiere/premiere-libtorrent
1
0
Fork 0
Code Pull Requests Activity

changed min_distance_exp for correctness and clarity (#789) 

changed min_distance_exp for correctness and clarity
This commit is contained in:
Alden Torres 2016-06-06 18:22:33 -04:00 committed by Arvid Norberg
parent 3d5e0144c7
commit 9d3cf5e68b
6 changed files with 69 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/libtorrent/alert_types.hpp
View File

@ -1334,8 +1334,8 @@ namespace libtorrent
}; };
// This alert is posted when the listen port succeeds to be opened on a // This alert is posted when the listen port succeeds to be opened on a
// particular interface. ``endpoint`` is the endpoint that successfully // particular interface. ``address`` and ``port`` is the endpoint that
// was opened for listening. // successfully was opened for listening.
struct TORRENT_EXPORT listen_succeeded_alert final : alert struct TORRENT_EXPORT listen_succeeded_alert final : alert
{ {
enum socket_type_t { tcp, tcp_ssl, udp, i2p, socks5, utp_ssl }; enum socket_type_t { tcp, tcp_ssl, udp, i2p, socks5, utp_ssl };

2
include/libtorrent/kademlia/dht_storage.hpp
View File

@ -76,6 +76,8 @@ namespace dht
// libtorrent comes with one built-in storage implementation: // libtorrent comes with one built-in storage implementation:
// ``dht_default_storage`` (private non-accessible class). Its // ``dht_default_storage`` (private non-accessible class). Its
// constructor function is called dht_default_storage_constructor(). // constructor function is called dht_default_storage_constructor().
// You should know that if this storage becomes full of DHT items,
// the current implementation could degrade in performance.
// //
struct TORRENT_EXPORT dht_storage_interface struct TORRENT_EXPORT dht_storage_interface
{ {

40
simulation/test_dht_storage.cpp
View File

@ -30,6 +30,8 @@ POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef TORRENT_DISABLE_DHT
#include "test.hpp" #include "test.hpp"
#include "settings.hpp" #include "settings.hpp"
#include "setup_transfer.hpp" // for ep() #include "setup_transfer.hpp" // for ep()
@ -56,15 +58,13 @@ using sim::default_config;
using namespace std::placeholders; using namespace std::placeholders;
#ifndef TORRENT_DISABLE_DHT
namespace namespace
{ {
dht_settings test_settings() { dht_settings test_settings() {
dht_settings sett; dht_settings sett;
sett.max_torrents = 2; sett.max_torrents = 2;
sett.max_dht_items = 2; sett.max_dht_items = 2;
sett.item_lifetime = seconds(120 * 60).count(); sett.item_lifetime = int(seconds(120 * 60).count());
return sett; return sett;
} }
@ -75,9 +75,20 @@ namespace
TORRENT_ASSERT(!hash.fail()); TORRENT_ASSERT(!hash.fail());
return ret; return ret;
} }
std::unique_ptr<dht_storage_interface> create_default_dht_storage(
dht_settings const& sett)
{
std::unique_ptr<dht_storage_interface> s(dht_default_storage_constructor(sett));
TEST_CHECK(s.get() != nullptr);
s->update_node_ids({to_hash("0000000000000000000000000000000000000200")});
return s;
}
} }
void timer_tick(boost::shared_ptr<dht_storage_interface> s void timer_tick(dht_storage_interface* s
, dht_storage_counters const& c , dht_storage_counters const& c
, boost::system::error_code const& ec) , boost::system::error_code const& ec)
{ {
@ -91,7 +102,7 @@ void timer_tick(boost::shared_ptr<dht_storage_interface> s
} }
void test_expiration(high_resolution_clock::duration const& expiry_time void test_expiration(high_resolution_clock::duration const& expiry_time
, boost::shared_ptr<dht_storage_interface> s , std::unique_ptr<dht_storage_interface>& s
, dht_storage_counters const& c) , dht_storage_counters const& c)
{ {
default_config cfg; default_config cfg;
@ -100,26 +111,23 @@ void test_expiration(high_resolution_clock::duration const& expiry_time
sim::asio::high_resolution_timer timer(ios); sim::asio::high_resolution_timer timer(ios);
timer.expires_from_now(expiry_time); timer.expires_from_now(expiry_time);
timer.async_wait(std::bind(&timer_tick, s, c, _1)); timer.async_wait(std::bind(&timer_tick, s.get(), c, _1));
boost::system::error_code ec; boost::system::error_code ec;
sim.run(ec); sim.run(ec);
} }
#endif // TORRENT_DISABLE_DHT
TORRENT_TEST(dht_storage_counters) TORRENT_TEST(dht_storage_counters)
{ {
#ifndef TORRENT_DISABLE_DHT
dht_settings sett = test_settings(); dht_settings sett = test_settings();
boost::shared_ptr<dht_storage_interface> s(dht_default_storage_constructor(sett)); std::unique_ptr<dht_storage_interface> s(create_default_dht_storage(sett));
TEST_CHECK(s.get() != NULL); TEST_CHECK(s.get() != nullptr);
sha1_hash n1 = to_hash("5fbfbff10c5d6a4ec8a88e4c6ab4c28b95eee401"); sha1_hash const n1 = to_hash("5fbfbff10c5d6a4ec8a88e4c6ab4c28b95eee401");
sha1_hash n2 = to_hash("5fbfbff10c5d6a4ec8a88e4c6ab4c28b95eee402"); sha1_hash const n2 = to_hash("5fbfbff10c5d6a4ec8a88e4c6ab4c28b95eee402");
sha1_hash n3 = to_hash("5fbfbff10c5d6a4ec8a88e4c6ab4c28b95eee403"); sha1_hash const n3 = to_hash("5fbfbff10c5d6a4ec8a88e4c6ab4c28b95eee403");
sha1_hash n4 = to_hash("5fbfbff10c5d6a4ec8a88e4c6ab4c28b95eee404"); sha1_hash const n4 = to_hash("5fbfbff10c5d6a4ec8a88e4c6ab4c28b95eee404");
tcp::endpoint const p1 = ep("124.31.75.21", 1); tcp::endpoint const p1 = ep("124.31.75.21", 1);
tcp::endpoint const p2 = ep("124.31.75.22", 1); tcp::endpoint const p2 = ep("124.31.75.22", 1);
@ -162,6 +170,6 @@ TORRENT_TEST(dht_storage_counters)
c.immutable_data = 0; c.immutable_data = 0;
c.mutable_data = 0; c.mutable_data = 0;
test_expiration(hours(1), s, c); // test expiration of everything after 3 hours test_expiration(hours(1), s, c); // test expiration of everything after 3 hours
#endif // TORRENT_DISABLE_DHT
} }
#endif // TORRENT_DISABLE_DHT

16
src/kademlia/node_id.cpp
View File

@ -31,11 +31,9 @@ POSSIBILITY OF SUCH DAMAGE.
*/ */
#include <algorithm> #include <algorithm>
#include <limits>
#include "libtorrent/kademlia/node_id.hpp" #include "libtorrent/kademlia/node_id.hpp"
#include "libtorrent/kademlia/node_entry.hpp" #include "libtorrent/kademlia/node_entry.hpp"
#include "libtorrent/hasher.hpp"
#include "libtorrent/assert.hpp" #include "libtorrent/assert.hpp"
#include "libtorrent/broadcast_socket.hpp" // for is_local et.al #include "libtorrent/broadcast_socket.hpp" // for is_local et.al
#include "libtorrent/socket_io.hpp" // for hash_address #include "libtorrent/socket_io.hpp" // for hash_address
@ -73,18 +71,12 @@ int distance_exp(node_id const& n1, node_id const& n2)
int min_distance_exp(node_id const& n1, std::vector<node_id> const& ids) int min_distance_exp(node_id const& n1, std::vector<node_id> const& ids)
{ {
// specialized for cases of 0, 1 and 2 for performance reasons TORRENT_ASSERT(ids.size() > 0);
if (ids.size() == 0) return 0;
if (ids.size() == 1) return distance_exp(n1, ids[0]);
if (ids.size() == 2)
return std::min(distance_exp(n1, ids[0]), distance_exp(n1, ids[1]));
int min = std::numeric_limits<int>::max(); int min = 160; // see distance_exp for the why of this constant
for (const auto &node_id : ids) for (auto const& node_id : ids)
{ {
int d = distance_exp(n1, node_id); min = std::min(min, distance_exp(n1, node_id));
if (d < min)
min = d;
} }
return min; return min;

2
test/test_dht.cpp
View File

@ -2712,8 +2712,6 @@ TORRENT_TEST(node_id_min_distance_exp)
std::vector<node_id> ids; std::vector<node_id> ids;
TEST_EQUAL(min_distance_exp(sha1_hash::min(), ids), 0);
ids.push_back(n1); ids.push_back(n1);
TEST_EQUAL(min_distance_exp(sha1_hash::min(), ids), 1); TEST_EQUAL(min_distance_exp(sha1_hash::min(), ids), 1);

71
test/test_dht_storage.cpp
View File

@ -83,18 +83,28 @@ namespace
g_storage_constructor_invoked = true; g_storage_constructor_invoked = true;
return dht_default_storage_constructor(settings); return dht_default_storage_constructor(settings);
} }
std::unique_ptr<dht_storage_interface> create_default_dht_storage(
dht_settings const& sett)
{
std::unique_ptr<dht_storage_interface> s(dht_default_storage_constructor(sett));
TEST_CHECK(s.get() != nullptr);
s->update_node_ids({to_hash("0000000000000000000000000000000000000200")});
return s;
}
} }
const sha1_hash n1 = to_hash("5fbfbff10c5d6a4ec8a88e4c6ab4c28b95eee401"); sha1_hash const n1 = to_hash("5fbfbff10c5d6a4ec8a88e4c6ab4c28b95eee401");
const sha1_hash n2 = to_hash("5fbfbff10c5d6a4ec8a88e4c6ab4c28b95eee402"); sha1_hash const n2 = to_hash("5fbfbff10c5d6a4ec8a88e4c6ab4c28b95eee402");
const sha1_hash n3 = to_hash("5fbfbff10c5d6a4ec8a88e4c6ab4c28b95eee403"); sha1_hash const n3 = to_hash("5fbfbff10c5d6a4ec8a88e4c6ab4c28b95eee403");
const sha1_hash n4 = to_hash("5fbfbff10c5d6a4ec8a88e4c6ab4c28b95eee404"); sha1_hash const n4 = to_hash("5fbfbff10c5d6a4ec8a88e4c6ab4c28b95eee404");
TORRENT_TEST(announce_peer) TORRENT_TEST(announce_peer)
{ {
dht_settings sett = test_settings(); dht_settings sett = test_settings();
std::unique_ptr<dht_storage_interface> s(dht_default_storage_constructor(sett)); std::unique_ptr<dht_storage_interface> s(create_default_dht_storage(sett));
TEST_CHECK(s.get() != NULL);
entry peers; entry peers;
s->get_peers(n1, false, false, peers); s->get_peers(n1, false, false, peers);
@ -102,10 +112,10 @@ TORRENT_TEST(announce_peer)
TEST_CHECK(peers["n"].string().empty()) TEST_CHECK(peers["n"].string().empty())
TEST_CHECK(peers["values"].list().empty()); TEST_CHECK(peers["values"].list().empty());
tcp::endpoint p1 = ep("124.31.75.21", 1); tcp::endpoint const p1 = ep("124.31.75.21", 1);
tcp::endpoint p2 = ep("124.31.75.22", 1); tcp::endpoint const p2 = ep("124.31.75.22", 1);
tcp::endpoint p3 = ep("124.31.75.23", 1); tcp::endpoint const p3 = ep("124.31.75.23", 1);
tcp::endpoint p4 = ep("124.31.75.24", 1); tcp::endpoint const p4 = ep("124.31.75.24", 1);
s->announce_peer(n1, p1, "torrent_name", false); s->announce_peer(n1, p1, "torrent_name", false);
s->get_peers(n1, false, false, peers); s->get_peers(n1, false, false, peers);
@ -122,8 +132,7 @@ TORRENT_TEST(announce_peer)
TORRENT_TEST(put_immutable_item) TORRENT_TEST(put_immutable_item)
{ {
dht_settings sett = test_settings(); dht_settings sett = test_settings();
std::unique_ptr<dht_storage_interface> s(dht_default_storage_constructor(sett)); std::unique_ptr<dht_storage_interface> s(create_default_dht_storage(sett));
TEST_CHECK(s.get() != NULL);
entry item; entry item;
bool r = s->get_immutable_item(n4, item); bool r = s->get_immutable_item(n4, item);
@ -152,22 +161,20 @@ TORRENT_TEST(put_immutable_item)
TORRENT_TEST(counters) TORRENT_TEST(counters)
{ {
dht_settings sett = test_settings(); dht_settings sett = test_settings();
std::unique_ptr<dht_storage_interface> s(dht_default_storage_constructor(sett)); std::unique_ptr<dht_storage_interface> s(create_default_dht_storage(sett));
TEST_CHECK(s.get() != NULL); sha1_hash const n1 = to_hash("5fbfbff10c5d6a4ec8a88e4c6ab4c28b95eee401");
sha1_hash const n2 = to_hash("5fbfbff10c5d6a4ec8a88e4c6ab4c28b95eee402");
sha1_hash n1 = to_hash("5fbfbff10c5d6a4ec8a88e4c6ab4c28b95eee401"); sha1_hash const n3 = to_hash("5fbfbff10c5d6a4ec8a88e4c6ab4c28b95eee403");
sha1_hash n2 = to_hash("5fbfbff10c5d6a4ec8a88e4c6ab4c28b95eee402"); sha1_hash const n4 = to_hash("5fbfbff10c5d6a4ec8a88e4c6ab4c28b95eee404");
sha1_hash n3 = to_hash("5fbfbff10c5d6a4ec8a88e4c6ab4c28b95eee403");
sha1_hash n4 = to_hash("5fbfbff10c5d6a4ec8a88e4c6ab4c28b95eee404");
TEST_EQUAL(s->counters().peers, 0); TEST_EQUAL(s->counters().peers, 0);
TEST_EQUAL(s->counters().torrents, 0); TEST_EQUAL(s->counters().torrents, 0);
tcp::endpoint p1 = ep("124.31.75.21", 1); tcp::endpoint const p1 = ep("124.31.75.21", 1);
tcp::endpoint p2 = ep("124.31.75.22", 1); tcp::endpoint const p2 = ep("124.31.75.22", 1);
tcp::endpoint p3 = ep("124.31.75.23", 1); tcp::endpoint const p3 = ep("124.31.75.23", 1);
tcp::endpoint p4 = ep("124.31.75.24", 1); tcp::endpoint const p4 = ep("124.31.75.24", 1);
s->announce_peer(n1, p1, "torrent_name", false); s->announce_peer(n1, p1, "torrent_name", false);
TEST_EQUAL(s->counters().peers, 1); TEST_EQUAL(s->counters().peers, 1);
@ -241,8 +248,7 @@ TORRENT_TEST(peer_limit)
{ {
dht_settings sett = test_settings(); dht_settings sett = test_settings();
sett.max_peers = 42; sett.max_peers = 42;
std::unique_ptr<dht_storage_interface> s(dht_default_storage_constructor(sett)); std::unique_ptr<dht_storage_interface> s(create_default_dht_storage(sett));
TEST_CHECK(s.get() != NULL);
for (int i = 0; i < 200; ++i) for (int i = 0; i < 200; ++i)
{ {
@ -259,8 +265,7 @@ TORRENT_TEST(torrent_limit)
{ {
dht_settings sett = test_settings(); dht_settings sett = test_settings();
sett.max_torrents = 42; sett.max_torrents = 42;
std::unique_ptr<dht_storage_interface> s(dht_default_storage_constructor(sett)); std::unique_ptr<dht_storage_interface> s(create_default_dht_storage(sett));
TEST_CHECK(s.get() != NULL);
for (int i = 0; i < 200; ++i) for (int i = 0; i < 200; ++i)
{ {
@ -277,8 +282,7 @@ TORRENT_TEST(immutable_item_limit)
{ {
dht_settings sett = test_settings(); dht_settings sett = test_settings();
sett.max_dht_items = 42; sett.max_dht_items = 42;
std::unique_ptr<dht_storage_interface> s(dht_default_storage_constructor(sett)); std::unique_ptr<dht_storage_interface> s(create_default_dht_storage(sett));
TEST_CHECK(s.get() != NULL);
for (int i = 0; i < 200; ++i) for (int i = 0; i < 200; ++i)
{ {
@ -294,8 +298,7 @@ TORRENT_TEST(mutable_item_limit)
{ {
dht_settings sett = test_settings(); dht_settings sett = test_settings();
sett.max_dht_items = 42; sett.max_dht_items = 42;
std::unique_ptr<dht_storage_interface> s(dht_default_storage_constructor(sett)); std::unique_ptr<dht_storage_interface> s(create_default_dht_storage(sett));
TEST_CHECK(s.get() != NULL);
char public_key[item_pk_len]; char public_key[item_pk_len];
char signature[item_sig_len]; char signature[item_sig_len];
@ -329,9 +332,9 @@ TORRENT_TEST(update_node_ids)
dht_storage_counters cnt; dht_storage_counters cnt;
bool r; bool r;
sha1_hash h1 = to_hash("0000000000000000000000000000000000010200"); sha1_hash const h1 = to_hash("0000000000000000000000000000000000010200");
sha1_hash h2 = to_hash("0000000000000000000000000000000100000400"); sha1_hash const h2 = to_hash("0000000000000000000000000000000100000400");
sha1_hash h3 = to_hash("0000000000000000000000010000000000000800"); sha1_hash const h3 = to_hash("0000000000000000000000010000000000000800");
TEST_EQUAL(min_distance_exp(h1, node_ids), 16); TEST_EQUAL(min_distance_exp(h1, node_ids), 16);
TEST_EQUAL(min_distance_exp(h2, node_ids), 32); TEST_EQUAL(min_distance_exp(h2, node_ids), 32);