refactor: use smaller integral types in some structs (#3005)
This commit is contained in:
parent
fca85c2f4d
commit
bf655a921d
|
@ -156,10 +156,10 @@ bool refreshFilesForeach(
|
|||
auto const old_progress = iter->get_value(file_cols.prog);
|
||||
auto const old_size = iter->get_value(file_cols.size);
|
||||
|
||||
auto new_enabled = old_enabled;
|
||||
auto new_enabled = int{};
|
||||
auto new_have = old_have;
|
||||
auto new_priority = old_priority;
|
||||
auto new_progress = old_progress;
|
||||
auto new_priority = int{};
|
||||
auto new_progress = int{};
|
||||
auto new_size = old_size;
|
||||
|
||||
if (is_file)
|
||||
|
|
|
@ -121,10 +121,10 @@ bool tr_peerIsSeed(tr_peer const* peer);
|
|||
|
||||
struct tr_swarm_stats
|
||||
{
|
||||
int activePeerCount[2];
|
||||
int activeWebseedCount;
|
||||
int peerCount;
|
||||
int peerFromCount[TR_PEER_FROM__MAX];
|
||||
uint16_t active_peer_count[2];
|
||||
uint16_t active_webseed_count;
|
||||
uint16_t peer_count;
|
||||
uint16_t peer_from_count[TR_PEER_FROM__MAX];
|
||||
};
|
||||
|
||||
void tr_swarmGetStats(tr_swarm const* swarm, tr_swarm_stats* setme);
|
||||
|
|
|
@ -54,7 +54,7 @@ static auto constexpr RechokePeriodMsec = int{ 10 * 1000 };
|
|||
|
||||
// an optimistically unchoked peer is immune from rechoking
|
||||
// for this many calls to rechokeUploads().
|
||||
static auto constexpr OptimisticUnchokeMultiplier = int{ 4 };
|
||||
static auto constexpr OptimisticUnchokeMultiplier = uint8_t{ 4 };
|
||||
|
||||
// how frequently to reallocate bandwidth
|
||||
static auto constexpr BandwidthPeriodMsec = int{ 500 };
|
||||
|
@ -109,15 +109,12 @@ static auto constexpr CancelHistorySec = int{ 60 };
|
|||
*/
|
||||
struct peer_atom
|
||||
{
|
||||
uint8_t fromFirst; /* where the peer was first found */
|
||||
uint8_t fromBest; /* the "best" value of where the peer has been found */
|
||||
uint8_t flags; /* these match the added_f flags */
|
||||
uint8_t flags2; /* flags that aren't defined in added_f */
|
||||
int8_t blocklisted; /* -1 for unknown, true for blocklisted, false for not blocklisted */
|
||||
tr_address addr;
|
||||
|
||||
tr_port port;
|
||||
bool utp_failed; /* We recently failed to connect over uTP */
|
||||
uint16_t numFails;
|
||||
|
||||
uint16_t num_fails;
|
||||
|
||||
time_t time; /* when the peer's connection status last changed */
|
||||
time_t piece_data_time;
|
||||
|
||||
|
@ -127,8 +124,16 @@ struct peer_atom
|
|||
/* similar to a TTL field, but less rigid --
|
||||
* if the swarm is small, the atom will be kept past this date. */
|
||||
time_t shelf_date;
|
||||
|
||||
tr_peer* peer; /* will be nullptr if not connected */
|
||||
tr_address addr;
|
||||
|
||||
uint8_t fromFirst; /* where the peer was first found */
|
||||
uint8_t fromBest; /* the "best" value of where the peer has been found */
|
||||
uint8_t flags; /* these match the added_f flags */
|
||||
uint8_t flags2; /* flags that aren't defined in added_f */
|
||||
int8_t blocklisted; /* -1 for unknown, true for blocklisted, false for not blocklisted */
|
||||
|
||||
bool utp_failed; /* We recently failed to connect over uTP */
|
||||
};
|
||||
|
||||
#ifndef TR_ENABLE_ASSERTS
|
||||
|
@ -208,37 +213,42 @@ private:
|
|||
class tr_swarm
|
||||
{
|
||||
public:
|
||||
tr_swarm(tr_peerMgr* manager_in, tr_torrent* tor_in)
|
||||
tr_swarm(tr_peerMgr* manager_in, tr_torrent* tor_in) noexcept
|
||||
: manager{ manager_in }
|
||||
, tor{ tor_in }
|
||||
{
|
||||
}
|
||||
|
||||
public:
|
||||
Handshakes outgoing_handshakes;
|
||||
|
||||
uint16_t interested_count = 0;
|
||||
uint16_t max_peers = 0;
|
||||
|
||||
tr_swarm_stats stats = {};
|
||||
|
||||
Handshakes outgoing_handshakes;
|
||||
tr_ptrArray pool = {}; /* struct peer_atom */
|
||||
tr_ptrArray peers = {}; /* tr_peerMsgs */
|
||||
std::vector<std::unique_ptr<tr_peer>> webseeds;
|
||||
uint8_t optimistic_unchoke_time_scaler = 0;
|
||||
|
||||
bool pool_is_all_seeds = false;
|
||||
bool pool_is_all_seeds_dirty = true; /* true if pool_is_all_seeds needs to be recomputed */
|
||||
bool is_running = false;
|
||||
bool needs_completeness_check = true;
|
||||
bool is_endgame = false;
|
||||
|
||||
tr_peerMgr* const manager;
|
||||
|
||||
std::vector<std::unique_ptr<tr_peer>> webseeds;
|
||||
|
||||
tr_ptrArray pool = {}; /* struct peer_atom */
|
||||
tr_ptrArray peers = {}; /* tr_peerMsgs */
|
||||
|
||||
tr_torrent* const tor;
|
||||
|
||||
tr_peerMsgs* optimistic = nullptr; /* the optimistic peer, or nullptr if none */
|
||||
int optimisticUnchokeTimeScaler = 0;
|
||||
|
||||
bool poolIsAllSeeds = false;
|
||||
bool poolIsAllSeedsDirty = true; /* true if poolIsAllSeeds needs to be recomputed */
|
||||
bool isRunning = false;
|
||||
bool needsCompletenessCheck = true;
|
||||
bool endgame = false;
|
||||
time_t lastCancel = 0;
|
||||
|
||||
ActiveRequests active_requests;
|
||||
|
||||
int interestedCount = 0;
|
||||
int maxPeers = 0;
|
||||
time_t lastCancel = 0;
|
||||
};
|
||||
|
||||
struct tr_peerMgr
|
||||
|
@ -361,7 +371,7 @@ static void swarmFree(tr_swarm* s)
|
|||
TR_ASSERT(s != nullptr);
|
||||
auto const lock = s->manager->unique_lock();
|
||||
|
||||
TR_ASSERT(!s->isRunning);
|
||||
TR_ASSERT(!s->is_running);
|
||||
TR_ASSERT(std::empty(s->outgoing_handshakes));
|
||||
TR_ASSERT(tr_ptrArrayEmpty(&s->peers));
|
||||
|
||||
|
@ -386,7 +396,7 @@ static void rebuildWebseedArray(tr_swarm* s, tr_torrent* tor)
|
|||
}
|
||||
s->webseeds.shrink_to_fit();
|
||||
|
||||
s->stats.activeWebseedCount = 0;
|
||||
s->stats.active_webseed_count = 0;
|
||||
}
|
||||
|
||||
static tr_swarm* swarmNew(tr_peerMgr* manager, tr_torrent* tor)
|
||||
|
@ -478,7 +488,7 @@ static void atomSetSeed(tr_swarm* s, struct peer_atom* atom)
|
|||
{
|
||||
tr_logAddTraceSwarm(s, fmt::format("marking peer {} as a seed", tr_atomAddrStr(atom)));
|
||||
atom->flags |= ADDED_F_SEED_FLAG;
|
||||
s->poolIsAllSeedsDirty = true;
|
||||
s->pool_is_all_seeds_dirty = true;
|
||||
}
|
||||
|
||||
bool tr_peerMgrPeerIsSeed(tr_torrent const* tor, tr_address const* addr)
|
||||
|
@ -532,7 +542,7 @@ void tr_peerMgrSetUtpFailed(tr_torrent* tor, tr_address const* addr, bool failed
|
|||
*** struct block_request
|
||||
**/
|
||||
|
||||
static int countActiveWebseeds(tr_swarm* s)
|
||||
[[nodiscard]] static uint16_t countActiveWebseeds(tr_swarm* s) noexcept
|
||||
{
|
||||
if (!s->tor->isRunning || s->tor->isDone())
|
||||
{
|
||||
|
@ -562,7 +572,7 @@ static void updateEndgame(tr_swarm* s)
|
|||
{
|
||||
/* we consider ourselves to be in endgame if the number of bytes
|
||||
we've got requested is >= the number of bytes left to download */
|
||||
s->endgame = uint64_t(std::size(s->active_requests)) * tr_block_info::BlockSize >= s->tor->leftUntilDone();
|
||||
s->is_endgame = uint64_t(std::size(s->active_requests)) * tr_block_info::BlockSize >= s->tor->leftUntilDone();
|
||||
}
|
||||
|
||||
std::vector<tr_block_span_t> tr_peerMgrGetNextRequests(tr_torrent* torrent, tr_peer const* peer, size_t numwant)
|
||||
|
@ -591,7 +601,7 @@ std::vector<tr_block_span_t> tr_peerMgrGetNextRequests(tr_torrent* torrent, tr_p
|
|||
|
||||
[[nodiscard]] bool isEndgame() const override
|
||||
{
|
||||
return swarm_->endgame;
|
||||
return swarm_->is_endgame;
|
||||
}
|
||||
|
||||
[[nodiscard]] size_t countActiveRequests(tr_block_index_t block) const override
|
||||
|
@ -776,7 +786,7 @@ void tr_peerMgrPieceCompleted(tr_torrent* tor, tr_piece_index_t p)
|
|||
}
|
||||
|
||||
/* bookkeeping */
|
||||
s->needsCompletenessCheck = true;
|
||||
s->needs_completeness_check = true;
|
||||
}
|
||||
|
||||
static void peerCallbackFunc(tr_peer* peer, tr_peer_event const* e, void* vs)
|
||||
|
@ -959,14 +969,14 @@ static struct peer_atom* ensureAtomExists(
|
|||
a->flags |= flags;
|
||||
}
|
||||
|
||||
s->poolIsAllSeedsDirty = true;
|
||||
s->pool_is_all_seeds_dirty = true;
|
||||
|
||||
return a;
|
||||
}
|
||||
|
||||
static int getMaxPeerCount(tr_torrent const* tor)
|
||||
[[nodiscard]] static constexpr auto getMaxPeerCount(tr_torrent const* tor) noexcept
|
||||
{
|
||||
return tor->maxConnectedPeers;
|
||||
return tor->max_connected_peers;
|
||||
}
|
||||
|
||||
static int getPeerCount(tr_swarm const* s)
|
||||
|
@ -987,11 +997,11 @@ static void createBitTorrentPeer(tr_torrent* tor, tr_peerIo* io, struct peer_ato
|
|||
atom->peer = peer;
|
||||
|
||||
tr_ptrArrayInsertSorted(&swarm->peers, peer, peerCompare);
|
||||
++swarm->stats.peerCount;
|
||||
++swarm->stats.peerFromCount[atom->fromFirst];
|
||||
++swarm->stats.peer_count;
|
||||
++swarm->stats.peer_from_count[atom->fromFirst];
|
||||
|
||||
TR_ASSERT(swarm->stats.peerCount == tr_ptrArraySize(&swarm->peers));
|
||||
TR_ASSERT(swarm->stats.peerFromCount[atom->fromFirst] <= swarm->stats.peerCount);
|
||||
TR_ASSERT(swarm->stats.peer_count == tr_ptrArraySize(&swarm->peers));
|
||||
TR_ASSERT(swarm->stats.peer_from_count[atom->fromFirst] <= swarm->stats.peer_count);
|
||||
|
||||
// TODO is this needed?
|
||||
// isn't it already initialized in tr_peerMsgsImpl's ctor?
|
||||
|
@ -1025,7 +1035,7 @@ static bool on_handshake_done(tr_handshake_result const& result)
|
|||
|
||||
auto const lock = manager->unique_lock();
|
||||
|
||||
if (!ok || s == nullptr || !s->isRunning)
|
||||
if (!ok || s == nullptr || !s->is_running)
|
||||
{
|
||||
if (s != nullptr)
|
||||
{
|
||||
|
@ -1033,13 +1043,16 @@ static bool on_handshake_done(tr_handshake_result const& result)
|
|||
|
||||
if (atom != nullptr)
|
||||
{
|
||||
++atom->numFails;
|
||||
++atom->num_fails;
|
||||
|
||||
if (!result.readAnythingFromPeer)
|
||||
{
|
||||
tr_logAddTraceSwarm(
|
||||
s,
|
||||
fmt::format("marking peer {} as unreachable... numFails is {}", tr_atomAddrStr(atom), atom->numFails));
|
||||
fmt::format(
|
||||
"marking peer {} as unreachable... num_fails is {}",
|
||||
tr_atomAddrStr(atom),
|
||||
atom->num_fails));
|
||||
atom->flags2 |= MyflagUnreachable;
|
||||
}
|
||||
}
|
||||
|
@ -1144,8 +1157,8 @@ void tr_peerMgrSetSwarmIsAllSeeds(tr_torrent* tor)
|
|||
atomSetSeed(swarm, atoms[i]);
|
||||
}
|
||||
|
||||
swarm->poolIsAllSeeds = true;
|
||||
swarm->poolIsAllSeedsDirty = false;
|
||||
swarm->pool_is_all_seeds = true;
|
||||
swarm->pool_is_all_seeds_dirty = false;
|
||||
}
|
||||
|
||||
size_t tr_peerMgrAddPex(tr_torrent* tor, uint8_t from, tr_pex const* pex, size_t n_pex)
|
||||
|
@ -1277,9 +1290,9 @@ static int compareAtomsByUsefulness(void const* va, void const* vb)
|
|||
return a->fromBest < b->fromBest ? -1 : 1;
|
||||
}
|
||||
|
||||
if (a->numFails != b->numFails)
|
||||
if (a->num_fails != b->num_fails)
|
||||
{
|
||||
return a->numFails < b->numFails ? -1 : 1;
|
||||
return a->num_fails < b->num_fails ? -1 : 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
@ -1441,8 +1454,8 @@ void tr_peerMgrStartTorrent(tr_torrent* tor)
|
|||
|
||||
ensureMgrTimersExist(s->manager);
|
||||
|
||||
s->isRunning = true;
|
||||
s->maxPeers = tor->maxConnectedPeers;
|
||||
s->is_running = true;
|
||||
s->max_peers = getMaxPeerCount(tor);
|
||||
|
||||
// rechoke soon
|
||||
tr_timerAddMsec(*s->manager->rechokeTimer, 100);
|
||||
|
@ -1452,7 +1465,7 @@ static void removeAllPeers(tr_swarm* /*swarm*/);
|
|||
|
||||
static void stopSwarm(tr_swarm* swarm)
|
||||
{
|
||||
swarm->isRunning = false;
|
||||
swarm->is_running = false;
|
||||
|
||||
removeAllPeers(swarm);
|
||||
|
||||
|
@ -1588,7 +1601,7 @@ void tr_swarmGetStats(tr_swarm const* swarm, tr_swarm_stats* setme)
|
|||
|
||||
void tr_swarmIncrementActivePeers(tr_swarm* swarm, tr_direction direction, bool is_active)
|
||||
{
|
||||
int n = swarm->stats.activePeerCount[direction];
|
||||
int n = swarm->stats.active_peer_count[direction];
|
||||
|
||||
if (is_active)
|
||||
{
|
||||
|
@ -1600,9 +1613,9 @@ void tr_swarmIncrementActivePeers(tr_swarm* swarm, tr_direction direction, bool
|
|||
}
|
||||
|
||||
TR_ASSERT(n >= 0);
|
||||
TR_ASSERT(n <= swarm->stats.peerCount);
|
||||
TR_ASSERT(n <= swarm->stats.peer_count);
|
||||
|
||||
swarm->stats.activePeerCount[direction] = n;
|
||||
swarm->stats.active_peer_count[direction] = n;
|
||||
}
|
||||
|
||||
bool tr_peerIsSeed(tr_peer const* peer)
|
||||
|
@ -1623,7 +1636,7 @@ uint64_t tr_peerMgrGetDesiredAvailable(tr_torrent const* tor)
|
|||
}
|
||||
|
||||
tr_swarm const* const s = tor->swarm;
|
||||
if (s == nullptr || !s->isRunning)
|
||||
if (s == nullptr || !s->is_running)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
@ -1871,10 +1884,11 @@ static constexpr int compare_rechoke_info(void const* va, void const* vb)
|
|||
/* determines who we send "interested" messages to */
|
||||
static void rechokeDownloads(tr_swarm* s)
|
||||
{
|
||||
int maxPeers = 0;
|
||||
int rechoke_count = 0;
|
||||
static auto constexpr MinInterestingPeers = uint16_t{ 5 };
|
||||
|
||||
uint16_t max_peers = 0;
|
||||
uint16_t rechoke_count = 0;
|
||||
struct tr_rechoke_info* rechoke = nullptr;
|
||||
auto constexpr MinInterestingPeers = 5;
|
||||
int const peerCount = tr_ptrArraySize(&s->peers);
|
||||
time_t const now = tr_time();
|
||||
|
||||
|
@ -1924,7 +1938,7 @@ static void rechokeDownloads(tr_swarm* s)
|
|||
* higher values indicate more congestion. */
|
||||
double const cancelRate = cancels / (double)(cancels + blocks);
|
||||
double const mult = 1 - std::min(cancelRate, 0.5);
|
||||
maxPeers = s->interestedCount * mult;
|
||||
max_peers = s->interested_count * mult;
|
||||
tr_logAddTraceSwarm(
|
||||
s,
|
||||
fmt::format(
|
||||
|
@ -1942,7 +1956,7 @@ static void rechokeDownloads(tr_swarm* s)
|
|||
time_t const maxHistory = 2 * CancelHistorySec;
|
||||
double const mult = std::min(timeSinceCancel, maxHistory) / (double)maxHistory;
|
||||
int const inc = maxIncrease * mult;
|
||||
maxPeers = s->maxPeers + inc;
|
||||
max_peers = s->max_peers + inc;
|
||||
tr_logAddTraceSwarm(
|
||||
s,
|
||||
fmt::format(
|
||||
|
@ -1953,9 +1967,9 @@ static void rechokeDownloads(tr_swarm* s)
|
|||
}
|
||||
|
||||
/* don't let the previous section's number tweaking go too far... */
|
||||
maxPeers = std::clamp(maxPeers, MinInterestingPeers, int(s->tor->maxConnectedPeers));
|
||||
max_peers = std::clamp(max_peers, MinInterestingPeers, s->tor->max_connected_peers);
|
||||
|
||||
s->maxPeers = maxPeers;
|
||||
s->max_peers = max_peers;
|
||||
|
||||
if (peerCount > 0)
|
||||
{
|
||||
|
@ -2028,11 +2042,11 @@ static void rechokeDownloads(tr_swarm* s)
|
|||
|
||||
/* now that we know which & how many peers to be interested in... update the peer interest */
|
||||
|
||||
s->interestedCount = std::min(maxPeers, rechoke_count);
|
||||
s->interested_count = std::min(max_peers, rechoke_count);
|
||||
|
||||
for (int i = 0; i < rechoke_count; ++i)
|
||||
{
|
||||
rechoke[i].peer->set_interested(i < s->interestedCount);
|
||||
rechoke[i].peer->set_interested(i < s->interested_count);
|
||||
}
|
||||
|
||||
/* cleanup */
|
||||
|
@ -2134,9 +2148,9 @@ static void rechokeUploads(tr_swarm* s, uint64_t const now)
|
|||
|
||||
/* an optimistic unchoke peer's "optimistic"
|
||||
* state lasts for N calls to rechokeUploads(). */
|
||||
if (s->optimisticUnchokeTimeScaler > 0)
|
||||
if (s->optimistic_unchoke_time_scaler > 0)
|
||||
{
|
||||
s->optimisticUnchokeTimeScaler--;
|
||||
--s->optimistic_unchoke_time_scaler;
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -2230,7 +2244,7 @@ static void rechokeUploads(tr_swarm* s, uint64_t const now)
|
|||
auto* c = randPool[tr_rand_int_weak(n)];
|
||||
c->isChoked = false;
|
||||
s->optimistic = c->msgs;
|
||||
s->optimisticUnchokeTimeScaler = OptimisticUnchokeMultiplier;
|
||||
s->optimistic_unchoke_time_scaler = OptimisticUnchokeMultiplier;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -2255,7 +2269,7 @@ static void rechokePulse(evutil_socket_t /*fd*/, short /*what*/, void* vmgr)
|
|||
{
|
||||
tr_swarm* s = tor->swarm;
|
||||
|
||||
if (s->stats.peerCount > 0)
|
||||
if (s->stats.peer_count > 0)
|
||||
{
|
||||
rechokeUploads(s, now);
|
||||
rechokeDownloads(s);
|
||||
|
@ -2334,7 +2348,7 @@ static int getReconnectIntervalSecs(struct peer_atom const* atom, time_t const n
|
|||
* and failed to connect to the peer */
|
||||
else
|
||||
{
|
||||
int step = atom->numFails;
|
||||
auto step = atom->num_fails;
|
||||
|
||||
/* penalize peers that were unreachable the last time we tried */
|
||||
if (unreachable)
|
||||
|
@ -2389,11 +2403,11 @@ static void removePeer(tr_peer* peer)
|
|||
atom->time = tr_time();
|
||||
|
||||
tr_ptrArrayRemoveSortedPointer(&s->peers, peer, peerCompare);
|
||||
--s->stats.peerCount;
|
||||
--s->stats.peerFromCount[atom->fromFirst];
|
||||
--s->stats.peer_count;
|
||||
--s->stats.peer_from_count[atom->fromFirst];
|
||||
|
||||
TR_ASSERT(s->stats.peerCount == tr_ptrArraySize(&s->peers));
|
||||
TR_ASSERT(s->stats.peerFromCount[atom->fromFirst] >= 0);
|
||||
TR_ASSERT(s->stats.peer_count == tr_ptrArraySize(&s->peers));
|
||||
TR_ASSERT(s->stats.peer_from_count[atom->fromFirst] >= 0);
|
||||
|
||||
delete peer;
|
||||
}
|
||||
|
@ -2404,17 +2418,17 @@ static void closePeer(tr_peer* peer)
|
|||
auto const* const s = peer->swarm;
|
||||
|
||||
/* if we transferred piece data, then they might be good peers,
|
||||
so reset their `numFails' weight to zero. otherwise we connected
|
||||
so reset their `num_fails' weight to zero. otherwise we connected
|
||||
to them fruitlessly, so mark it as another fail */
|
||||
if (auto* const atom = peer->atom; atom->piece_data_time != 0)
|
||||
{
|
||||
tr_logAddTraceSwarm(s, fmt::format("resetting atom {} numFails to 0", tr_atomAddrStr(atom)));
|
||||
atom->numFails = 0;
|
||||
tr_logAddTraceSwarm(s, fmt::format("resetting atom {} num_fails to 0", tr_atomAddrStr(atom)));
|
||||
atom->num_fails = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
++atom->numFails;
|
||||
tr_logAddTraceSwarm(s, fmt::format("incremented atom {} numFails to {}", tr_atomAddrStr(atom), atom->numFails));
|
||||
++atom->num_fails;
|
||||
tr_logAddTraceSwarm(s, fmt::format("incremented atom {} num_fails to {}", tr_atomAddrStr(atom), atom->num_fails));
|
||||
}
|
||||
|
||||
tr_logAddTraceSwarm(s, fmt::format("removing bad peer {}", tr_atomAddrStr(peer->atom)));
|
||||
|
@ -2430,7 +2444,7 @@ static void removeAllPeers(tr_swarm* swarm)
|
|||
removePeer(peer);
|
||||
}
|
||||
|
||||
TR_ASSERT(swarm->stats.peerCount == 0);
|
||||
TR_ASSERT(swarm->stats.peer_count == 0);
|
||||
}
|
||||
|
||||
static auto getPeersToClose(tr_swarm* s, time_t const now_sec)
|
||||
|
@ -2546,7 +2560,7 @@ static void reconnectPulse(evutil_socket_t /*fd*/, short /*what*/, void* vmgr)
|
|||
// remove crappy peers
|
||||
for (auto* const tor : mgr->session->torrents())
|
||||
{
|
||||
if (!tor->swarm->isRunning)
|
||||
if (!tor->swarm->is_running)
|
||||
{
|
||||
removeAllPeers(tor->swarm);
|
||||
}
|
||||
|
@ -2632,9 +2646,9 @@ static void bandwidthPulse(evutil_socket_t /*fd*/, short /*what*/, void* vmgr)
|
|||
tr_torrentCheckSeedLimit(tor);
|
||||
|
||||
/* run the completeness check for any torrents that need it */
|
||||
if (tor->swarm->needsCompletenessCheck)
|
||||
if (tor->swarm->needs_completeness_check)
|
||||
{
|
||||
tor->swarm->needsCompletenessCheck = false;
|
||||
tor->swarm->needs_completeness_check = false;
|
||||
tor->recheckCompleteness();
|
||||
}
|
||||
|
||||
|
@ -2646,7 +2660,7 @@ static void bandwidthPulse(evutil_socket_t /*fd*/, short /*what*/, void* vmgr)
|
|||
}
|
||||
|
||||
/* update the torrent's stats */
|
||||
tor->swarm->stats.activeWebseedCount = countActiveWebseeds(tor->swarm);
|
||||
tor->swarm->stats.active_webseed_count = countActiveWebseeds(tor->swarm);
|
||||
}
|
||||
|
||||
/* pump the queues */
|
||||
|
@ -2714,9 +2728,12 @@ static int compareAtomPtrsByShelfDate(void const* va, void const* vb)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int getMaxAtomCount(tr_torrent const* tor)
|
||||
static auto getMaxAtomCount(tr_torrent const* tor)
|
||||
{
|
||||
return std::min(50, tor->maxConnectedPeers * 3);
|
||||
static auto constexpr Limit = uint16_t{ 50 };
|
||||
static auto constexpr Multiplier = uint16_t{ 3 };
|
||||
|
||||
return std::min(Limit, static_cast<uint16_t>(tor->max_connected_peers * Multiplier));
|
||||
}
|
||||
|
||||
static void atomPulse(evutil_socket_t /*fd*/, short /*what*/, void* vmgr)
|
||||
|
@ -2933,13 +2950,13 @@ static bool calculateAllSeeds(tr_swarm* swarm)
|
|||
|
||||
static bool swarmIsAllSeeds(tr_swarm* swarm)
|
||||
{
|
||||
if (swarm->poolIsAllSeedsDirty)
|
||||
if (swarm->pool_is_all_seeds_dirty)
|
||||
{
|
||||
swarm->poolIsAllSeeds = calculateAllSeeds(swarm);
|
||||
swarm->poolIsAllSeedsDirty = false;
|
||||
swarm->pool_is_all_seeds = calculateAllSeeds(swarm);
|
||||
swarm->pool_is_all_seeds_dirty = false;
|
||||
}
|
||||
|
||||
return swarm->poolIsAllSeeds;
|
||||
return swarm->pool_is_all_seeds;
|
||||
}
|
||||
|
||||
/** @return an array of all the atoms we might want to connect to */
|
||||
|
@ -2971,7 +2988,7 @@ static std::vector<peer_candidate> getPeerCandidates(tr_session* session, size_t
|
|||
/* populate the candidate array */
|
||||
for (auto* tor : session->torrents())
|
||||
{
|
||||
if (!tor->swarm->isRunning)
|
||||
if (!tor->swarm->is_running)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
@ -3056,7 +3073,7 @@ static void initiateConnection(tr_peerMgr* mgr, tr_swarm* s, struct peer_atom* a
|
|||
{
|
||||
tr_logAddTraceSwarm(s, fmt::format("peerIo not created; marking peer {} as unreachable", tr_atomAddrStr(atom)));
|
||||
atom->flags2 |= MyflagUnreachable;
|
||||
atom->numFails++;
|
||||
++atom->num_fails;
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
|
@ -742,7 +742,7 @@ static auto loadFromFile(tr_torrent* tor, tr_resume::fields_t fieldsToLoad, bool
|
|||
|
||||
if ((fieldsToLoad & tr_resume::MaxPeers) != 0 && tr_variantDictFindInt(&top, TR_KEY_max_peers, &i))
|
||||
{
|
||||
tor->maxConnectedPeers = i;
|
||||
tor->max_connected_peers = static_cast<uint16_t>(i);
|
||||
fields_loaded |= tr_resume::MaxPeers;
|
||||
}
|
||||
|
||||
|
@ -873,7 +873,7 @@ static auto setFromCtor(tr_torrent* tor, tr_resume::fields_t fields, tr_ctor con
|
|||
}
|
||||
}
|
||||
|
||||
if (((fields & tr_resume::MaxPeers) != 0) && tr_ctorGetPeerLimit(ctor, mode, &tor->maxConnectedPeers))
|
||||
if (((fields & tr_resume::MaxPeers) != 0) && tr_ctorGetPeerLimit(ctor, mode, &tor->max_connected_peers))
|
||||
{
|
||||
ret |= tr_resume::MaxPeers;
|
||||
}
|
||||
|
@ -943,7 +943,7 @@ void save(tr_torrent* tor)
|
|||
|
||||
tr_variantDictAddInt(&top, TR_KEY_downloaded, tor->downloadedPrev + tor->downloadedCur);
|
||||
tr_variantDictAddInt(&top, TR_KEY_uploaded, tor->uploadedPrev + tor->uploadedCur);
|
||||
tr_variantDictAddInt(&top, TR_KEY_max_peers, tor->maxConnectedPeers);
|
||||
tr_variantDictAddInt(&top, TR_KEY_max_peers, tor->max_connected_peers);
|
||||
tr_variantDictAddInt(&top, TR_KEY_bandwidth_priority, tr_torrentGetPriority(tor));
|
||||
tr_variantDictAddBool(&top, TR_KEY_paused, !tor->isRunning && !tor->isQueued());
|
||||
savePeers(&top, tor);
|
||||
|
|
|
@ -654,7 +654,7 @@ static void initField(tr_torrent const* const tor, tr_stat const* const st, tr_v
|
|||
case TR_KEY_peersFrom:
|
||||
{
|
||||
tr_variantInitDict(initme, 7);
|
||||
int const* f = st->peersFrom;
|
||||
auto const* f = st->peersFrom;
|
||||
tr_variantDictAddInt(initme, TR_KEY_fromCache, f[TR_PEER_FROM_RESUME]);
|
||||
tr_variantDictAddInt(initme, TR_KEY_fromDht, f[TR_PEER_FROM_DHT]);
|
||||
tr_variantDictAddInt(initme, TR_KEY_fromIncoming, f[TR_PEER_FROM_INCOMING]);
|
||||
|
|
|
@ -1045,14 +1045,14 @@ tr_stat const* tr_torrentStat(tr_torrent* tor)
|
|||
s->errorString = tor->error_string.c_str();
|
||||
|
||||
s->manualAnnounceTime = tr_announcerNextManualAnnounce(tor);
|
||||
s->peersConnected = swarm_stats.peerCount;
|
||||
s->peersSendingToUs = swarm_stats.activePeerCount[TR_DOWN];
|
||||
s->peersGettingFromUs = swarm_stats.activePeerCount[TR_UP];
|
||||
s->webseedsSendingToUs = swarm_stats.activeWebseedCount;
|
||||
s->peersConnected = swarm_stats.peer_count;
|
||||
s->peersSendingToUs = swarm_stats.active_peer_count[TR_DOWN];
|
||||
s->peersGettingFromUs = swarm_stats.active_peer_count[TR_UP];
|
||||
s->webseedsSendingToUs = swarm_stats.active_webseed_count;
|
||||
|
||||
for (int i = 0; i < TR_PEER_FROM__MAX; i++)
|
||||
{
|
||||
s->peersFrom[i] = swarm_stats.peerFromCount[i];
|
||||
s->peersFrom[i] = swarm_stats.peer_from_count[i];
|
||||
}
|
||||
|
||||
s->rawUploadSpeed_KBps = tr_toSpeedKBps(tor->bandwidth_.getRawSpeedBytesPerSecond(now, TR_UP));
|
||||
|
@ -1980,13 +1980,13 @@ void tr_torrentSetPriority(tr_torrent* tor, tr_priority_t priority)
|
|||
****
|
||||
***/
|
||||
|
||||
void tr_torrentSetPeerLimit(tr_torrent* tor, uint16_t maxConnectedPeers)
|
||||
void tr_torrentSetPeerLimit(tr_torrent* tor, uint16_t max_connected_peers)
|
||||
{
|
||||
TR_ASSERT(tr_isTorrent(tor));
|
||||
|
||||
if (tor->maxConnectedPeers != maxConnectedPeers)
|
||||
if (tor->max_connected_peers != max_connected_peers)
|
||||
{
|
||||
tor->maxConnectedPeers = maxConnectedPeers;
|
||||
tor->max_connected_peers = max_connected_peers;
|
||||
|
||||
tor->setDirty();
|
||||
}
|
||||
|
@ -1996,7 +1996,7 @@ uint16_t tr_torrentGetPeerLimit(tr_torrent const* tor)
|
|||
{
|
||||
TR_ASSERT(tr_isTorrent(tor));
|
||||
|
||||
return tor->maxConnectedPeers;
|
||||
return tor->max_connected_peers;
|
||||
}
|
||||
|
||||
/***
|
||||
|
|
|
@ -73,7 +73,7 @@ void tr_torrentCheckSeedLimit(tr_torrent* tor);
|
|||
/** save a torrent's .resume file if it's changed since the last time it was saved */
|
||||
void tr_torrentSave(tr_torrent* tor);
|
||||
|
||||
enum tr_verify_state
|
||||
enum tr_verify_state : uint8_t
|
||||
{
|
||||
TR_VERIFY_NONE,
|
||||
TR_VERIFY_WAIT,
|
||||
|
@ -699,7 +699,7 @@ public:
|
|||
void markEdited();
|
||||
void markChanged();
|
||||
|
||||
uint16_t maxConnectedPeers = TR_DEFAULT_PEER_LIMIT_TORRENT;
|
||||
uint16_t max_connected_peers = TR_DEFAULT_PEER_LIMIT_TORRENT;
|
||||
|
||||
time_t lastStatTime = 0;
|
||||
tr_stat stats = {};
|
||||
|
|
|
@ -1497,21 +1497,69 @@ enum tr_stat_errtype
|
|||
/** @brief Used by tr_torrentStat() to tell clients about a torrent's state and statistics */
|
||||
struct tr_stat
|
||||
{
|
||||
/** The torrent's unique Id.
|
||||
@see tr_torrentId() */
|
||||
int id;
|
||||
|
||||
/** What is this torrent doing right now? */
|
||||
tr_torrent_activity activity;
|
||||
|
||||
/** Defines what kind of text is in errorString.
|
||||
@see errorString */
|
||||
tr_stat_errtype error;
|
||||
|
||||
/** A warning or error message regarding the torrent.
|
||||
@see error */
|
||||
char const* errorString;
|
||||
|
||||
/** Byte count of all the piece data we'll have downloaded when we're done,
|
||||
whether or not we have it yet. This may be less than tr_torrentTotalSize()
|
||||
if only some of the torrent's files are wanted.
|
||||
[0...tr_torrentTotalSize()] */
|
||||
uint64_t sizeWhenDone;
|
||||
|
||||
/** Byte count of how much data is left to be downloaded until we've got
|
||||
all the pieces that we want. [0...tr_stat.sizeWhenDone] */
|
||||
uint64_t leftUntilDone;
|
||||
|
||||
/** Byte count of all the piece data we want and don't have yet,
|
||||
but that a connected peer does have. [0...leftUntilDone] */
|
||||
uint64_t desiredAvailable;
|
||||
|
||||
/** Byte count of all the corrupt data you've ever downloaded for
|
||||
this torrent. If you're on a poisoned torrent, this number can
|
||||
grow very large. */
|
||||
uint64_t corruptEver;
|
||||
|
||||
/** Byte count of all data you've ever uploaded for this torrent. */
|
||||
uint64_t uploadedEver;
|
||||
|
||||
/** Byte count of all the non-corrupt data you've ever downloaded
|
||||
for this torrent. If you deleted the files and downloaded a second
|
||||
time, this will be 2*totalSize.. */
|
||||
uint64_t downloadedEver;
|
||||
|
||||
/** Byte count of all the checksum-verified data we have for this torrent.
|
||||
*/
|
||||
uint64_t haveValid;
|
||||
|
||||
/** Byte count of all the partial piece data we have for this torrent.
|
||||
As pieces become complete, this value may decrease as portions of it
|
||||
are moved to `corrupt' or `haveValid'. */
|
||||
uint64_t haveUnchecked;
|
||||
|
||||
/** time when one or more of the torrent's trackers will
|
||||
allow you to manually ask for more peers,
|
||||
or 0 if you can't */
|
||||
time_t manualAnnounceTime;
|
||||
|
||||
/** When the torrent was first added. */
|
||||
time_t addedDate;
|
||||
|
||||
/** When the torrent finished downloading. */
|
||||
time_t doneDate;
|
||||
|
||||
/** When the torrent was last started. */
|
||||
time_t startDate;
|
||||
|
||||
/** The last time we uploaded or downloaded piece data on this torrent. */
|
||||
time_t activityDate;
|
||||
|
||||
/** The last time during this session that a rarely-changing field
|
||||
changed -- e.g. any tr_torrent_metainfo field (trackers, filenames, name)
|
||||
or download directory. RPC clients can monitor this to know when
|
||||
to reload fields that rarely change. */
|
||||
time_t editDate;
|
||||
|
||||
/** When tr_stat.activity is TR_STATUS_CHECK or TR_STATUS_CHECK_WAIT,
|
||||
this is the percentage of how much of the files has been
|
||||
verified. When it gets to 1, the verify process is done.
|
||||
|
@ -1556,93 +1604,14 @@ struct tr_stat
|
|||
This ONLY counts piece data. */
|
||||
float pieceDownloadSpeed_KBps;
|
||||
|
||||
#define TR_ETA_NOT_AVAIL (-1)
|
||||
#define TR_ETA_UNKNOWN (-2)
|
||||
/** If downloading, estimated number of seconds left until the torrent is done.
|
||||
If seeding, estimated number of seconds left until seed ratio is reached. */
|
||||
int eta;
|
||||
/** If seeding, number of seconds left until the idle time limit is reached. */
|
||||
int etaIdle;
|
||||
|
||||
/** Number of peers that we're connected to */
|
||||
int peersConnected;
|
||||
|
||||
/** How many peers we found out about from the tracker, or from pex,
|
||||
or from incoming connections, or from our resume file. */
|
||||
int peersFrom[TR_PEER_FROM__MAX];
|
||||
|
||||
/** Number of peers that are sending data to us. */
|
||||
int peersSendingToUs;
|
||||
|
||||
/** Number of peers that we're sending data to */
|
||||
int peersGettingFromUs;
|
||||
|
||||
/** Number of webseeds that are sending data to us. */
|
||||
int webseedsSendingToUs;
|
||||
|
||||
/** Byte count of all the piece data we'll have downloaded when we're done,
|
||||
whether or not we have it yet. This may be less than tr_torrentTotalSize()
|
||||
if only some of the torrent's files are wanted.
|
||||
[0...tr_torrentTotalSize()] */
|
||||
uint64_t sizeWhenDone;
|
||||
|
||||
/** Byte count of how much data is left to be downloaded until we've got
|
||||
all the pieces that we want. [0...tr_stat.sizeWhenDone] */
|
||||
uint64_t leftUntilDone;
|
||||
|
||||
/** Byte count of all the piece data we want and don't have yet,
|
||||
but that a connected peer does have. [0...leftUntilDone] */
|
||||
uint64_t desiredAvailable;
|
||||
|
||||
/** Byte count of all the corrupt data you've ever downloaded for
|
||||
this torrent. If you're on a poisoned torrent, this number can
|
||||
grow very large. */
|
||||
uint64_t corruptEver;
|
||||
|
||||
/** Byte count of all data you've ever uploaded for this torrent. */
|
||||
uint64_t uploadedEver;
|
||||
|
||||
/** Byte count of all the non-corrupt data you've ever downloaded
|
||||
for this torrent. If you deleted the files and downloaded a second
|
||||
time, this will be 2*totalSize.. */
|
||||
uint64_t downloadedEver;
|
||||
|
||||
/** Byte count of all the checksum-verified data we have for this torrent.
|
||||
*/
|
||||
uint64_t haveValid;
|
||||
|
||||
/** Byte count of all the partial piece data we have for this torrent.
|
||||
As pieces become complete, this value may decrease as portions of it
|
||||
are moved to `corrupt' or `haveValid'. */
|
||||
uint64_t haveUnchecked;
|
||||
|
||||
/** time when one or more of the torrent's trackers will
|
||||
allow you to manually ask for more peers,
|
||||
or 0 if you can't */
|
||||
time_t manualAnnounceTime;
|
||||
|
||||
/** Total uploaded bytes / sizeWhenDone.
|
||||
NB: In Transmission 3.00 and earlier, this was total upload / download,
|
||||
which caused edge cases when total download was less than sizeWhenDone. */
|
||||
float ratio;
|
||||
|
||||
/** When the torrent was first added. */
|
||||
time_t addedDate;
|
||||
|
||||
/** When the torrent finished downloading. */
|
||||
time_t doneDate;
|
||||
|
||||
/** When the torrent was last started. */
|
||||
time_t startDate;
|
||||
|
||||
/** The last time we uploaded or downloaded piece data on this torrent. */
|
||||
time_t activityDate;
|
||||
|
||||
/** The last time during this session that a rarely-changing field
|
||||
changed -- e.g. any tr_torrent_metainfo field (trackers, filenames, name)
|
||||
or download directory. RPC clients can monitor this to know when
|
||||
to reload fields that rarely change. */
|
||||
time_t editDate;
|
||||
/** The torrent's unique Id.
|
||||
@see tr_torrentId() */
|
||||
int id;
|
||||
|
||||
/** Number of seconds since the last activity (or since started).
|
||||
-1 if activity is not seeding or downloading. */
|
||||
|
@ -1658,6 +1627,38 @@ struct tr_stat
|
|||
All torrents have a queue position, even if it's not queued. */
|
||||
int queuePosition;
|
||||
|
||||
#define TR_ETA_NOT_AVAIL (-1)
|
||||
#define TR_ETA_UNKNOWN (-2)
|
||||
/** If downloading, estimated number of seconds left until the torrent is done.
|
||||
If seeding, estimated number of seconds left until seed ratio is reached. */
|
||||
int eta;
|
||||
|
||||
/** If seeding, number of seconds left until the idle time limit is reached. */
|
||||
int etaIdle;
|
||||
|
||||
/** What is this torrent doing right now? */
|
||||
tr_torrent_activity activity;
|
||||
|
||||
/** Defines what kind of text is in errorString.
|
||||
@see errorString */
|
||||
tr_stat_errtype error;
|
||||
|
||||
/** Number of peers that we're connected to */
|
||||
uint16_t peersConnected;
|
||||
|
||||
/** How many peers we found out about from the tracker, or from pex,
|
||||
or from incoming connections, or from our resume file. */
|
||||
uint16_t peersFrom[TR_PEER_FROM__MAX];
|
||||
|
||||
/** Number of peers that are sending data to us. */
|
||||
uint16_t peersSendingToUs;
|
||||
|
||||
/** Number of peers that we're sending data to */
|
||||
uint16_t peersGettingFromUs;
|
||||
|
||||
/** Number of webseeds that are sending data to us. */
|
||||
uint16_t webseedsSendingToUs;
|
||||
|
||||
/** A torrent is considered finished if it has met its seed ratio.
|
||||
As a result, only paused torrents can be finished. */
|
||||
bool finished;
|
||||
|
|
Loading…
Reference in New Issue