Ticket #2352: nosample.diff

File nosample.diff, 4.8 KB (added by charles, 13 years ago)

patch from #2347

  • libtransmission/completion.c

    diff -u -w transmission-1.74b1/libtransmission/completion.c transmission-1.74b1_org/libtransmission/completion.c
    old new  
    290290       
    291291    for( i = 0; i < tabCount; ++i )
    292292    {
     293        const tr_piece_index_t piece = i * interval;
     294
    293295        if( tor == NULL )
    294296            tab[i] = 0.0f;
    295         else if( isSeed )
     297        else if( isSeed || tr_cpPieceIsComplete( cp, piece ) )
    296298            tab[i] = 1.0f;
    297299        else
    298                 {                       
    299                         int first_piece = i * interval;
    300                        
    301                         // Last piece of last interval is also the last piece of the torrent
    302                         int last_piece =  i < tabCount - 1 ? ( i + 1 ) * interval : tor->info.pieceCount - 1;
    303                        
    304                         float lower_piece_fract = 1.0f - ((float)i * interval - first_piece );
    305                         float upper_piece_fract = ((float)(i + 1) * interval -  last_piece );
    306                        
    307                         float sum = 0.0f, avg;
    308                        
    309                         tr_bool complete = TRUE;
    310                        
    311                         if ( first_piece == last_piece ) {
    312                                 if ( !tr_cpPieceIsComplete( cp, first_piece ) ) {
    313                                         avg =  (float)cp->completeBlocks[first_piece] /
    314                                         tr_torPieceCountBlocks( tor, first_piece );
    315                                         complete = FALSE;
    316                                 }
    317                                 else {
    318                                         avg = 1.0;
    319                                 }
    320                         }
    321                         else {
    322                                 if ( !tr_cpPieceIsComplete( cp, first_piece ) ) {
    323                                         sum += (float)cp->completeBlocks[first_piece] /
    324                                                 tr_torPieceCountBlocks( tor, first_piece ) * lower_piece_fract;
    325                                         complete = FALSE;
    326                                 }
    327                                 else {
    328                                         sum += lower_piece_fract;
    329                                 }
    330                                
    331                                 if ( !tr_cpPieceIsComplete( cp, last_piece ) ) {                               
    332                                         sum += (float)cp->completeBlocks[last_piece] /
    333                                                 tr_torPieceCountBlocks( tor, last_piece ) * upper_piece_fract;
    334                                         complete = FALSE;
    335                                 }
    336                                 else {
    337                                         sum += upper_piece_fract;
    338                                 }
    339                                
    340                                 int j;
    341                                 for ( j = first_piece + 1; j < last_piece; j++ ) {
    342                                         if ( !tr_cpPieceIsComplete( cp, j ) ) {
    343                                                 sum += (float)cp->completeBlocks[j] /
    344                                                         tr_torPieceCountBlocks( tor, j );
    345                                                 complete = FALSE;
    346                                         }
    347                                         else {
    348                                                 sum += 1.0f;
    349                                         }
    350                                        
    351                                 }
    352                                
    353                                 avg = sum / interval;
    354                         }
    355                        
    356                         tab[i] = complete ? 1.0f : avg;
    357                 }
     300            tab[i] = (float)cp->completeBlocks[piece] /
     301                     tr_torPieceCountBlocks( tor, piece );
    358302    }
    359303}
    360304
  • libtransmission/peer-mgr.c

    diff -u -w transmission-1.74b1/libtransmission/peer-mgr.c transmission-1.74b1_org/libtransmission/peer-mgr.c
    old new  
    16531653    tr_torrentUnlock( tor );
    16541654}
    16551655
    1656 int
    1657 tr_availableCount(const tr_peer ** peers, int peerCount, int piece) {
    1658         int count = 0;
    1659         int i;
    1660         for( i = 0; i < peerCount; ++i )
    1661                 if( tr_bitfieldHas( peers[i]->have, piece ) )
    1662                         count++;
    1663        
    1664         return count;
    1665 }
    1666 
    16671656void
    16681657tr_peerMgrTorrentAvailability( const tr_torrent * tor,
    16691658                                                          int8_t           * tab,
     
    16881677       
    16891678    for( i = 0; tor && i < tabCount; ++i )
    16901679    {
    1691         if( isSeed )
    1692             tab[i] = -1;
    1693         else
    1694                 {
    1695                         int first_piece = i * interval;
    1696                        
    1697                         // Last piece of last interval is also the last piece of the torrent
    1698                         int last_piece =  i < tabCount - 1 ? ( i + 1 ) * interval : tor->info.pieceCount - 1;
    1699                        
    1700                         float lower_piece_fract = 1.0f - ((float)i * interval - first_piece );
    1701                         float upper_piece_fract = ((float)(i + 1) * interval -  last_piece );
    1702                        
    1703                         float sum = 0.0f, result;
    1704                        
    1705                         if ( first_piece == last_piece ) {
    1706                                 if ( tr_cpPieceIsComplete( &tor->completion, first_piece ) )
    1707                                         result = -1;
    1708                                 else
    1709                                         result = tr_availableCount(peers, peerCount, first_piece);
    1710                         }
    1711                         else {
    1712                                 float incompleteCount = 0.0f;
    1713                                
    1714                                 if ( !tr_cpPieceIsComplete( &tor->completion, first_piece ) )
    1715                                 {       
    1716                                         sum += tr_availableCount(peers, peerCount, first_piece) * lower_piece_fract;
    1717                                         incompleteCount += lower_piece_fract;
    1718                                 }
    1719                                
    1720                                 if ( !tr_cpPieceIsComplete( &tor->completion, last_piece ) )
    1721                                 {       
    1722                                         sum += tr_availableCount(peers, peerCount, last_piece) * upper_piece_fract;
    1723                                         incompleteCount += upper_piece_fract;
    1724                                 }
     1680        const int piece = i * interval;
    17251681                               
     1682        if( isSeed || tr_cpPieceIsComplete( &tor->completion, piece ) )
     1683            tab[i] = -1;
     1684        else if( peerCount ) {
    17261685                                int j;
    1727                                 for ( j = first_piece + 1; j < last_piece; j++ ) {
    1728                                         if ( !tr_cpPieceIsComplete( &tor->completion, j ) )
    1729                                         {       
    1730                                                 sum += tr_availableCount(peers, peerCount, j );
    1731                                                 incompleteCount += 1.0f;
    1732                                         }
    1733                                 }
    1734                                
    1735                                 result = incompleteCount > 0 ? ( sum / incompleteCount ) : -1.0f;
    1736                         }
    1737                        
    1738                         tab[i] = (int)result;
     1686            for( j = 0; j < peerCount; ++j )
     1687                if( tr_bitfieldHas( peers[j]->have, i ) )
     1688                    ++tab[i];
    17391689                }
    17401690    }
    17411691