Changeset 2231

Timestamp:

Jun 29, 2007, 5:45:17 AM (15 years ago)

Author:

charles

Message:

lots of performance improvements. fun!

• dynamically resize the request queue on a per-peer basis based on its speed
• fix a huge bug that sabotaged the `swift' performance
• on startup, unchoke peers much sooner
• bump MAX_PEERS and PERCENT_PEER_WANTED
• do a better job of estimating speed on torrents less than 30 seconds old.
• getting an unrecognized extension ID, ignore it instead of stopping the torrent.

Location:

trunk/libtransmission

Files:

• choking.c (modified) (1 diff)
• peer.c (modified) (15 diffs)
• peer.h (modified) (1 diff)
• peerparse.h (modified) (3 diffs)
• ratecontrol.c (modified) (3 diffs)
• shared.c (modified) (1 diff)
• torrent.c (modified) (2 diffs)
• utils.h (modified) (1 diff)

trunk/libtransmission/choking.c

@@ -201 +201 @@
             else
             {
-                if( tr_peerLastChoke( peer ) + 10000 < now )
+                if( !tr_peerTimesChoked(peer) || tr_peerLastChoke( peer ) + 10000 < now )
                     canUnchoke[canUnchokeCount++] = peer;
             }

trunk/libtransmission/peer.c

@@ -46 +46 @@
  * allow them to download this many bytes from us
  */
-static const double SWIFT_REPAYMENT_RATIO = 1.1;
+static const double SWIFT_REPAYMENT_RATIO = 1.33;
 
 /**
@@ -71 +71 @@
 *****/
 
-#define PERCENT_PEER_WANTED     25      /* Percent before we start relax peers min activeness */
+#define PERCENT_PEER_WANTED     75      /* Percent before we start relax peers min activeness */
 #define MIN_UPLOAD_IDLE         60000   /* In high peer situations we wait only 1 min
                                             until dropping peers for idling */
@@ -84 +84 @@
 #define MAX_CON_TIMEOUT         30000   /* Time to timeout connecting to peer, 
                                             during high peer situations */
-#define MAX_REQUEST_COUNT       32
-#define OUR_REQUEST_COUNT       12 /* TODO: we should detect if we are on a
-                                      high-speed network and adapt */
 #define PEX_PEER_CUTOFF         50 /* only try to add new peers from pex if
                                       we have fewer existing peers than this */
@@ -151 +148 @@
 
     int                 optimistic;
+    int                 timesChoked;
     uint64_t            lastChoke;
 
@@ -181 +179 @@
 
     int                 inRequestCount;
-    tr_request_t        inRequests[OUR_REQUEST_COUNT];
+    int                 inRequestMax;
+    int                 inRequestAlloc;
+    tr_request_t      * inRequests;
     int                 inIndex;
     int                 inBegin;
@@ -188 +188 @@
 
     int                 outRequestCount;
-    tr_request_t        outRequests[MAX_REQUEST_COUNT];
+    int                 outRequestMax;
+    int                 outRequestAlloc;
+    tr_request_t      * outRequests;
     uint64_t            outTotal;
     uint64_t            outDate;
@@ -234 +236 @@
     assert( 0 <= from && TR_PEER_FROM__MAX > from );
 
+    peer->outRequestMax = peer->outRequestAlloc = 2;
+    peer->outRequests = tr_new0( tr_request_t, peer->outRequestAlloc );
+
+    peer->inRequestMax = peer->inRequestAlloc = 2;
+    peer->inRequests = tr_new0( tr_request_t, peer->inRequestAlloc );
+
     peer->socket = s;
     peer->addr = addr;
@@ -355 +363 @@
             peer->buf   = realloc( peer->buf, peer->size );
         }
+#if 0
         /* Never read more than 1K each time, otherwise the rate
            control is no use */
         ret = tr_netRecv( peer->socket, &peer->buf[peer->pos],
-                          MIN( 1024, peer->size - peer->pos ) );
+                          MIN( 1024, peer->size - peer->pos ) ); 
+#else
+        /* Hm, it doesn't *seem* to break rate control... */
+        ret = tr_netRecv( peer->socket, &peer->buf[peer->pos],
+                          peer->size - peer->pos ); 
+#endif
+
         if( ret & TR_NET_CLOSE )
         {
@@ -596 +611 @@
         && !peer->peerChoking
         && !peer->banned
-        &&  peer->inRequestCount < OUR_REQUEST_COUNT )
+        &&  peer->inRequestCount < peer->inRequestMax )
     {
         int i;
@@ -602 +617 @@
         int * pool = getPreferredPieces ( tor, peer, &poolSize, &endgame );
 
-        /* TODO: add some asserts to see if this bitfield is really necessary */
-        tr_bitfield_t * requestedBlocks = tr_bitfieldNew( tor->blockCount );
-        for( i=0; i<peer->inRequestCount; ++i) {
-            const tr_request_t * r = &peer->inRequests[i];
-            const int block = tr_block( r->index, r->begin );
-            tr_bitfieldAdd( requestedBlocks, block );
-        }
-
-        for( i=0; i<poolSize && peer->inRequestCount<OUR_REQUEST_COUNT;  )
+        for( i=0; i<poolSize && peer->inRequestCount<peer->inRequestMax;  )
         {
             int unused;
@@ -618 +625 @@
                 : tr_cpMissingBlockInPiece ( tor->completion, piece );
 
-            if( block>=0 && (endgame || !tr_bitfieldHas( requestedBlocks, block ) ) )
-            {
-                tr_bitfieldAdd( requestedBlocks, block );
+            if( block>=0 )
                 sendRequest( tor, peer, block );
-            }
             else ++i;
         }
 
-        tr_bitfieldFree( requestedBlocks );
         free( pool );
     }
@@ -683 +686 @@
 {
     return tr_rcRate( peer->upload );
+}
+
+int tr_peerTimesChoked( const tr_peer_t * peer )
+{
+    return peer->timesChoked;
 }
 
@@ -689 +697 @@
     sendChoke( peer, 1 );
     peer->lastChoke = tr_date();
+    ++peer->timesChoked;
 }
 
@@ -838 +847 @@
 
     tr_torrentWriterLock( tor );
+
+    for( i=0; i<tor->peerCount; ++i )
+    {
+        /* preferred # of seconds for the request queue's turnaround time.
+           this is just an arbitrary number. */
+        const int queueTime = 5;
+        int j;
+        tr_peer_t * peer = tor->peers[ i ];
+
+        if( !tr_peerIsConnected( peer ) )
+            continue;
+
+        /* decide how deep the request queue should be */
+        peer->outRequestMax = queueTime * tr_rcRate(peer->download) / tor->blockSize;
+        peer->inRequestMax += 2; /* room to grow */
+
+        /* make room for new requests */
+        if( peer->outRequestAlloc < peer->outRequestMax ) {
+            peer->outRequestAlloc = peer->outRequestMax;
+            peer->outRequests = tr_renew( tr_request_t, peer->outRequests, peer->outRequestAlloc );
+        }
+
+        /* decide how deep the request queue should be */
+        peer->inRequestMax = queueTime * tr_rcRate(peer->download) / (tor->blockSize/1024);
+        peer->inRequestMax += 2; /* room to grow */
+
+        /* make room for new requests */
+        if( peer->inRequestAlloc < peer->inRequestMax ) {
+            peer->inRequestAlloc = peer->inRequestMax;
+            peer->inRequests = tr_renew( tr_request_t, peer->inRequests, peer->inRequestAlloc );
+        }
+
+        /* queue shrank... notify completion that we won't be sending those requests */
+        for( j=peer->inRequestMax; j<peer->inRequestCount; ++j ) {
+            tr_request_t * r = &peer->inRequests[j];
+            tr_cpDownloaderRem( tor->completion, tr_block(r->index,r->begin) );
+        }
+    }
 
     deadbeats = tr_calloc( tor->peerCount, sizeof(tr_peer_t*) );
@@ -848 +895 @@
     if( deadbeatCount )
     {
-        const double ul_KiBsec = tr_rcRate( tor->upload );
+        const double ul_KiBsec = tr_rcRate( tor->download );
         const double ul_KiB = ul_KiBsec * SWIFT_REFRESH_INTERVAL_SEC;
         const double ul_bytes = ul_KiB * 1024;

trunk/libtransmission/peer.h

@@ -46 +46 @@
 int         tr_peerAmInterested    ( const tr_peer_t * );
 int         tr_peerIsChoking       ( const tr_peer_t * );
+int         tr_peerTimesChoked     ( const tr_peer_t * );
 int         tr_peerIsInterested    ( const tr_peer_t * );
 float       tr_peerProgress        ( const tr_peer_t * );

trunk/libtransmission/peerparse.h

@@ -238 +238 @@
     }
 
-    if( peer->outRequestCount >= MAX_REQUEST_COUNT )
+    if( peer->outRequestCount >= peer->outRequestMax )
     {
         tr_err( "Too many requests" );
@@ -524 +524 @@
                 peer_dbg( "GET  unknown extended message '%hhu'", extid );
             }
-            return 1;
+            /* ignore the unknown extension */
+            return 0;
         case AZ_MSG_BT_KEEP_ALIVE:
             return TR_OK;
@@ -537 +538 @@
     }
 
-    peer_dbg( "GET  unknown message '%d'", id );
+    tr_err( "GET  unknown message '%d'", id );
     return TR_ERROR;
 }

trunk/libtransmission/ratecontrol.c

@@ -166 +166 @@
 {
     tr_transfer_t * t = NULL;
-    uint64_t now, start;
-    int i, total;
-
-    now = tr_date();
+    uint64_t now, then, start;
+    float total = 0;
+    int i;
+
+    now = then = tr_date();
     start = now - interval;
 
     /* Browse the history back in time */
-    total = 0;
     for( i = r->transferStop; i != r->transferStart; i-- )
     {
         t = &r->transfers[i];
-        if( t->date < start )
+        then = t->date;
+        if( then < start )
             break;
 
@@ -185 +186 @@
             i = HISTORY_SIZE; /* Loop */
     }
+#if 0
     if( ( r->transferStop + 1 ) % HISTORY_SIZE == r->transferStart
         && i == r->transferStart )
@@ -193 +195 @@
         interval = now - t->date;
     }
-
-    return ( 1000.0f / 1024.0f ) * total / interval;
-}
-
+#endif
+
+    if( now == then )
+        return 0.0;
+    return ( 1000.0f / 1024.0f ) * total / (now - then);
+}
+

trunk/libtransmission/shared.c

@@ -27 +27 @@
 
 /* Maximum number of peers that we keep in our local list */
-#define MAX_PEER_COUNT 42
+/* This is an arbitrary number, but it seems to work well */
+#define MAX_PEER_COUNT 128
 
 struct tr_shared_s

trunk/libtransmission/torrent.c

@@ -545 +545 @@
     for( i=0; i<tor->peerCount; ++i ) {
         const tr_peer_t * peer = tor->peers[i];
+            ++s->peersTotal;
         if( tr_peerIsConnected( peer ) ) {
-            ++s->peersTotal;
             ++s->peersFrom[tr_peerIsFrom(peer)];
             if( tr_peerAmInterested( peer ) && !tr_peerIsChoking( peer ) )
@@ -954 +954 @@
 
         /* sleep a little while */
-        tr_wait( tor->runStatus == TR_RUN_STOPPED ? 1000 : 100 );
+        tr_wait( tor->runStatus == TR_RUN_STOPPED ? 1600 : 800 );
 
         /* if we're stopping... */

trunk/libtransmission/utils.h

@@ -181 +181 @@
 #define tr_new0(struct_type, n_structs)          \
     ((struct_type *) tr_malloc0 (((size_t) sizeof (struct_type)) * ((size_t) (n_structs))))
+#define tr_renew(struct_type, mem, n_structs)    \
+    ((struct_type *) realloc ((mem), ((size_t) sizeof (struct_type)) * ((size_t) (n_structs))))
 
 void* tr_malloc  ( size_t );