Changeset 1869


Ignore:
Timestamp:
May 16, 2007, 2:03:18 AM (15 years ago)
Author:
livings124
Message:

determine upload/download rates the old way, which is not the most accurate way at a few points, but should have a positive overall impact

Location:
trunk/libtransmission
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/internal.h

    r1750 r1869  
    220220struct tr_handle_s
    221221{
    222     int            torrentCount;
    223     tr_torrent_t * torrentList;
    224 
    225     char         * tag;
    226     int            isPortSet;
    227     int            uploadLimit;
    228     int            downloadLimit;
    229     tr_shared_t  * shared;
     222    int                torrentCount;
     223    tr_torrent_t     * torrentList;
     224
     225    char             * tag;
     226    int                isPortSet;
     227
     228    tr_ratecontrol_t * upload;
     229    tr_ratecontrol_t * download;
     230
     231    tr_shared_t      * shared;
    230232
    231233#define TR_ID_LEN               20
  • trunk/libtransmission/peer.c

    r1653 r1869  
    281281        if( tor )
    282282        {
    283             if( tor->customDownloadLimit )
     283            if( tor->customDownloadLimit
     284                ? !tr_rcCanTransfer( tor->download )
     285                : !tr_rcCanTransfer( tor->handle->download ) )
    284286            {
    285                 if( !tr_rcCanTransfer( tor->download ) )
    286                 {
    287                     break;
    288                 }
    289             }
    290             else
    291             {
    292                 tr_lockUnlock( &tor->lock );
    293                 if( !tr_rcCanGlobalTransfer( tor->handle, 0 ) )
    294                 {
    295                     tr_lockLock( &tor->lock );
    296                     break;
    297                 }
    298                 tr_lockLock( &tor->lock );
     287                break;
    299288            }
    300289        }
     
    329318            tr_rcTransferred( peer->download, ret );
    330319            tr_rcTransferred( tor->download, ret );
     320            if ( !tor->customDownloadLimit )
     321            {
     322                tr_rcTransferred( tor->handle->download, ret );
     323            }
     324           
    331325            if( ( ret = parseBuf( tor, peer ) ) )
    332326            {
     
    490484    while( ( p = blockPending( tor, peer, &size ) ) )
    491485    {
    492         if( tor->customUploadLimit )
    493         {
    494             if( !tr_rcCanTransfer( tor->upload ) )
    495             {
    496                 break;
    497             }
    498         }
    499         else
    500         {
    501             tr_lockUnlock( &tor->lock );
    502             if( !tr_rcCanGlobalTransfer( tor->handle, 1 ) )
    503             {
    504                 tr_lockLock( &tor->lock );
    505                 break;
    506             }
    507             tr_lockLock( &tor->lock );
     486        if( tor->customUploadLimit
     487            ? !tr_rcCanTransfer( tor->upload )
     488            : !tr_rcCanTransfer( tor->handle->upload ) )
     489        {
     490            break;
    508491        }
    509492
     
    521504        tr_rcTransferred( peer->upload, ret );
    522505        tr_rcTransferred( tor->upload, ret );
     506        if ( !tor->customUploadLimit )
     507        {
     508            tr_rcTransferred( tor->handle->upload, ret );
     509        }
    523510
    524511        tor->uploadedCur += ret;
  • trunk/libtransmission/ratecontrol.c

    r1452 r1869  
    8181
    8282    return r;
    83 }
    84 
    85 int tr_rcCanGlobalTransfer( tr_handle_t * h, int isUpload )
    86 {
    87     tr_torrent_t * tor;
    88     tr_ratecontrol_t * r;
    89     float rate = 0;
    90     int limit = isUpload ? h->uploadLimit : h->downloadLimit;
    91    
    92     if( limit <= 0 )
    93     {
    94         return limit < 0;
    95     }
    96    
    97     tr_sharedLock( h->shared );
    98     for( tor = h->torrentList; tor; tor = tor->next )
    99     {
    100         if( isUpload ? tor->customUploadLimit : tor->customDownloadLimit )
    101         {
    102             continue;
    103         }
    104        
    105         r = isUpload ? tor->upload : tor->download;
    106         tr_lockLock( &r->lock );
    107         rate += rateForInterval( r, SHORT_INTERVAL );
    108         tr_lockUnlock( &r->lock );
    109        
    110         if( rate >= (float)limit )
    111         {
    112             tr_sharedUnlock( h->shared );
    113             return 0;
    114         }
    115     }
    116     tr_sharedUnlock( h->shared );
    117    
    118     return 1;
    11983}
    12084
  • trunk/libtransmission/ratecontrol.h

    r1320 r1869  
    2626
    2727tr_ratecontrol_t * tr_rcInit();
    28 int                tr_rcCanGlobalTransfer( tr_handle_t * h, int isUpload );
    2928void               tr_rcSetLimit( tr_ratecontrol_t *, int );
    3029int                tr_rcCanTransfer( tr_ratecontrol_t * );
  • trunk/libtransmission/torrent.c

    r1868 r1869  
    241241int tr_torrentDuplicateDownload( tr_torrent_t * tor )
    242242{
    243     tr_torrent_t * current, * next;
     243    tr_torrent_t * current;
    244244   
    245245    /* Check if a torrent with the same name and destination is already active */
  • trunk/libtransmission/transmission.c

    r1704 r1869  
    8080
    8181    /* Initialize rate and file descripts controls */
    82     h->uploadLimit   = -1;
    83     h->downloadLimit = -1;
    84    
     82    h->upload   = tr_rcInit();
     83    h->download = tr_rcInit();
     84
    8585    tr_fdInit();
    8686    h->shared = tr_sharedInit( h );
     
    126126void tr_setGlobalUploadLimit( tr_handle_t * h, int limit )
    127127{
    128     h->uploadLimit = limit;
     128    tr_rcSetLimit( h->upload, limit );
    129129    tr_sharedSetLimit( h->shared, limit );
    130130}
     
    132132void tr_setGlobalDownloadLimit( tr_handle_t * h, int limit )
    133133{
    134     h->downloadLimit = limit;
     134    tr_rcSetLimit( h->download, limit );
    135135}
    136136
     
    171171void tr_close( tr_handle_t * h )
    172172{
     173    tr_rcClose( h->upload );
     174    tr_rcClose( h->download );
     175   
    173176    tr_sharedClose( h->shared );
    174177    tr_fdClose();
Note: See TracChangeset for help on using the changeset viewer.