transmission/libtransmission/completion.cc

360 lines
8.5 KiB
C++
Raw Normal View History

/*
* This file Copyright (C) 2009-2014 Mnemosyne LLC
2006-07-16 19:39:23 +00:00
*
* It may be used under the GNU GPL versions 2 or 3
* or any future license endorsed by Mnemosyne LLC.
2006-07-16 19:39:23 +00:00
*
*/
2006-07-16 19:39:23 +00:00
#include "transmission.h"
#include "completion.h"
#include "torrent.h"
#include "tr-assert.h"
#include "utils.h"
/***
****
***/
static void tr_cpReset(tr_completion* cp)
2007-11-12 22:26:10 +00:00
{
cp->sizeNow = 0;
cp->sizeWhenDoneIsDirty = true;
cp->haveValidIsDirty = true;
tr_bitfieldSetHasNone(&cp->blockBitfield);
2007-11-12 22:26:10 +00:00
}
void tr_cpConstruct(tr_completion* cp, tr_torrent* tor)
2006-07-16 19:39:23 +00:00
{
cp->tor = tor;
tr_bitfieldConstruct(&cp->blockBitfield, tor->blockCount);
tr_cpReset(cp);
2006-07-16 19:39:23 +00:00
}
void tr_cpBlockInit(tr_completion* cp, tr_bitfield const* b)
{
tr_cpReset(cp);
2012-12-15 04:28:19 +00:00
/* set blockBitfield */
tr_bitfieldSetFromBitfield(&cp->blockBitfield, b);
2012-12-15 04:28:19 +00:00
/* set sizeNow */
cp->sizeNow = tr_bitfieldCountTrueBits(&cp->blockBitfield);
TR_ASSERT(cp->sizeNow <= cp->tor->blockCount);
cp->sizeNow *= cp->tor->blockSize;
2012-12-15 04:28:19 +00:00
if (tr_bitfieldHas(b, cp->tor->blockCount - 1))
{
cp->sizeNow -= (cp->tor->blockSize - cp->tor->lastBlockSize);
}
TR_ASSERT(cp->sizeNow <= cp->tor->info.totalSize);
2006-07-16 19:39:23 +00:00
}
/***
****
***/
tr_completeness tr_cpGetStatus(tr_completion const* cp)
{
if (tr_cpHasAll(cp))
{
return TR_SEED;
}
2012-12-15 04:28:19 +00:00
if (!tr_torrentHasMetadata(cp->tor))
{
return TR_LEECH;
}
2012-12-15 04:28:19 +00:00
if (cp->sizeNow == tr_cpSizeWhenDone(cp))
{
return TR_PARTIAL_SEED;
}
2012-12-15 04:28:19 +00:00
return TR_LEECH;
}
void tr_cpPieceRem(tr_completion* cp, tr_piece_index_t piece)
{
tr_block_index_t f;
tr_block_index_t l;
tr_torrent const* tor = cp->tor;
tr_torGetPieceBlockRange(cp->tor, piece, &f, &l);
2017-05-13 22:38:31 +00:00
for (tr_block_index_t i = f; i <= l; ++i)
{
if (tr_cpBlockIsComplete(cp, i))
{
cp->sizeNow -= tr_torBlockCountBytes(tor, i);
}
}
cp->haveValidIsDirty = true;
cp->sizeWhenDoneIsDirty = true;
tr_bitfieldRemRange(&cp->blockBitfield, f, l + 1);
2006-07-16 19:39:23 +00:00
}
void tr_cpPieceAdd(tr_completion* cp, tr_piece_index_t piece)
2006-07-16 19:39:23 +00:00
{
tr_block_index_t f;
tr_block_index_t l;
tr_torGetPieceBlockRange(cp->tor, piece, &f, &l);
2006-07-16 19:39:23 +00:00
2017-05-13 22:38:31 +00:00
for (tr_block_index_t i = f; i <= l; ++i)
{
tr_cpBlockAdd(cp, i);
}
2006-07-16 19:39:23 +00:00
}
void tr_cpBlockAdd(tr_completion* cp, tr_block_index_t block)
2006-07-16 19:39:23 +00:00
{
tr_torrent const* tor = cp->tor;
if (!tr_cpBlockIsComplete(cp, block))
2006-07-16 19:39:23 +00:00
{
tr_piece_index_t const piece = tr_torBlockPiece(cp->tor, block);
tr_bitfieldAdd(&cp->blockBitfield, block);
cp->sizeNow += tr_torBlockCountBytes(tor, block);
2006-07-16 19:39:23 +00:00
cp->haveValidIsDirty = true;
2019-07-14 12:40:41 +00:00
cp->sizeWhenDoneIsDirty = cp->sizeWhenDoneIsDirty || tor->info.pieces[piece].dnd;
2006-07-16 19:39:23 +00:00
}
}
/***
****
***/
uint64_t tr_cpHaveValid(tr_completion const* ccp)
{
if (ccp->haveValidIsDirty)
{
uint64_t size = 0;
tr_completion* cp = (tr_completion*)ccp; /* mutable */
tr_torrent const* tor = ccp->tor;
tr_info const* info = &tor->info;
2017-05-13 22:38:31 +00:00
for (tr_piece_index_t i = 0; i < info->pieceCount; ++i)
{
if (tr_cpPieceIsComplete(ccp, i))
{
size += tr_torPieceCountBytes(tor, i);
}
}
cp->haveValidLazy = size;
cp->haveValidIsDirty = false;
}
return ccp->haveValidLazy;
}
uint64_t tr_cpSizeWhenDone(tr_completion const* ccp)
{
if (ccp->sizeWhenDoneIsDirty)
{
uint64_t size = 0;
tr_torrent const* tor = ccp->tor;
tr_info const* inf = tr_torrentInfo(tor);
tr_completion* cp = (tr_completion*)ccp; /* mutable */
if (tr_cpHasAll(ccp))
{
size = inf->totalSize;
}
else
{
2017-05-13 22:38:31 +00:00
for (tr_piece_index_t p = 0; p < inf->pieceCount; ++p)
{
uint64_t n = 0;
uint64_t const pieceSize = tr_torPieceCountBytes(tor, p);
if (!inf->pieces[p].dnd)
{
n = pieceSize;
}
else
{
tr_block_index_t f;
tr_block_index_t l;
tr_torGetPieceBlockRange(cp->tor, p, &f, &l);
n = tr_bitfieldCountRange(&cp->blockBitfield, f, l + 1);
n *= cp->tor->blockSize;
if (l == cp->tor->blockCount - 1 && tr_bitfieldHas(&cp->blockBitfield, l))
{
n -= cp->tor->blockSize - cp->tor->lastBlockSize;
}
}
TR_ASSERT(n <= tr_torPieceCountBytes(tor, p));
size += n;
}
}
TR_ASSERT(size <= inf->totalSize);
TR_ASSERT(size >= cp->sizeNow);
cp->sizeWhenDoneLazy = size;
cp->sizeWhenDoneIsDirty = false;
}
return ccp->sizeWhenDoneLazy;
}
uint64_t tr_cpLeftUntilDone(tr_completion const* cp)
{
uint64_t const sizeWhenDone = tr_cpSizeWhenDone(cp);
TR_ASSERT(sizeWhenDone >= cp->sizeNow);
return sizeWhenDone - cp->sizeNow;
}
void tr_cpGetAmountDone(tr_completion const* cp, float* tab, int tabCount)
{
bool const seed = tr_cpHasAll(cp);
float const interval = cp->tor->info.pieceCount / (float)tabCount;
2012-12-15 04:28:19 +00:00
2017-05-13 22:38:31 +00:00
for (int i = 0; i < tabCount; ++i)
2012-12-15 04:28:19 +00:00
{
if (seed)
2012-12-15 04:28:19 +00:00
{
tab[i] = 1.0F;
2012-12-15 04:28:19 +00:00
}
else
2012-12-15 04:28:19 +00:00
{
tr_block_index_t f;
tr_block_index_t l;
tr_piece_index_t const piece = (tr_piece_index_t)i * interval;
tr_torGetPieceBlockRange(cp->tor, piece, &f, &l);
tab[i] = tr_bitfieldCountRange(&cp->blockBitfield, f, l + 1) / (float)(l + 1 - f);
}
}
}
size_t tr_cpMissingBlocksInPiece(tr_completion const* cp, tr_piece_index_t piece)
{
if (tr_cpHasAll(cp))
2012-12-15 04:28:19 +00:00
{
return 0;
2012-12-15 04:28:19 +00:00
}
else
2012-12-15 04:28:19 +00:00
{
tr_block_index_t f;
tr_block_index_t l;
tr_torGetPieceBlockRange(cp->tor, piece, &f, &l);
return (l + 1 - f) - tr_bitfieldCountRange(&cp->blockBitfield, f, l + 1);
}
}
size_t tr_cpMissingBytesInPiece(tr_completion const* cp, tr_piece_index_t piece)
{
if (tr_cpHasAll(cp))
2012-12-15 04:28:19 +00:00
{
return 0;
2012-12-15 04:28:19 +00:00
}
else
2012-12-15 04:28:19 +00:00
{
size_t haveBytes = 0;
tr_block_index_t f;
tr_block_index_t l;
size_t const pieceByteSize = tr_torPieceCountBytes(cp->tor, piece);
tr_torGetPieceBlockRange(cp->tor, piece, &f, &l);
if (f != l)
2012-12-15 04:28:19 +00:00
{
/* nb: we don't pass the usual l+1 here to tr_bitfieldCountRange().
It's faster to handle the last block separately because its size
needs to be checked separately. */
haveBytes = tr_bitfieldCountRange(&cp->blockBitfield, f, l);
haveBytes *= cp->tor->blockSize;
}
2012-12-15 04:28:19 +00:00
if (tr_bitfieldHas(&cp->blockBitfield, l)) /* handle the last block */
{
haveBytes += tr_torBlockCountBytes(cp->tor, l);
}
2012-12-15 04:28:19 +00:00
TR_ASSERT(haveBytes <= pieceByteSize);
return pieceByteSize - haveBytes;
}
}
bool tr_cpFileIsComplete(tr_completion const* cp, tr_file_index_t i)
{
if (cp->tor->info.files[i].length == 0)
2012-12-15 04:28:19 +00:00
{
return true;
2012-12-15 04:28:19 +00:00
}
else
2012-12-15 04:28:19 +00:00
{
tr_block_index_t f;
tr_block_index_t l;
tr_torGetFileBlockRange(cp->tor, i, &f, &l);
return tr_bitfieldCountRange(&cp->blockBitfield, f, l + 1) == (l + 1 - f);
}
}
void* tr_cpCreatePieceBitfield(tr_completion const* cp, size_t* byte_count)
{
TR_ASSERT(tr_torrentHasMetadata(cp->tor));
void* ret;
tr_piece_index_t n;
tr_bitfield pieces;
2012-12-15 04:28:19 +00:00
n = cp->tor->info.pieceCount;
tr_bitfieldConstruct(&pieces, n);
2012-12-15 04:28:19 +00:00
if (tr_cpHasAll(cp))
2012-12-15 04:28:19 +00:00
{
tr_bitfieldSetHasAll(&pieces);
2012-12-15 04:28:19 +00:00
}
else if (!tr_cpHasNone(cp))
2012-12-15 04:28:19 +00:00
{
bool* flags = tr_new(bool, n);
2017-05-13 22:38:31 +00:00
for (tr_piece_index_t i = 0; i < n; ++i)
{
flags[i] = tr_cpPieceIsComplete(cp, i);
}
tr_bitfieldSetFromFlags(&pieces, flags, n);
tr_free(flags);
}
ret = tr_bitfieldGetRaw(&pieces, byte_count);
tr_bitfieldDestruct(&pieces);
return ret;
}
double tr_cpPercentComplete(tr_completion const* cp)
{
double const ratio = tr_getRatio(cp->sizeNow, cp->tor->info.totalSize);
if ((int)ratio == TR_RATIO_NA)
{
return 0.0;
}
else if ((int)ratio == TR_RATIO_INF)
{
return 1.0;
}
else
{
return ratio;
}
}
double tr_cpPercentDone(tr_completion const* cp)
{
double const ratio = tr_getRatio(cp->sizeNow, tr_cpSizeWhenDone(cp));
int const iratio = (int)ratio;
return (iratio == TR_RATIO_NA || iratio == TR_RATIO_INF) ? 0.0 : ratio;
}