Ticket #3596: choke.diff

libtransmission/peer-msgs.c

@@ -71 +71 @@
 
     MAX_PEX_PEER_COUNT      = 50,
 
-    MIN_CHOKE_PERIOD_SEC    = 10,
-
     /* idle seconds before we send a keepalive */
     KEEPALIVE_INTERVAL_SECS = 100,
 
@@ -737 +735 @@
 }
 
 void
-tr_peerMsgsSetChoke( tr_peermsgs * msgs,
-                     int           choke )
+tr_peerMsgsSetChoke( tr_peermsgs * msgs, uint8_t state )
 {
-    const time_t now = tr_time( );
-    const time_t fibrillationTime = now - MIN_CHOKE_PERIOD_SEC;
+    tr_peer * peer;
 
     assert( msgs );
-    assert( msgs->peer );
-    assert( choke == 0 || choke == 1 );
+    peer = msgs->peer;
+    assert( peer );
+    assert( choke==PEER_CHOKE_STATE_CHOKED ||
+            choke==PEER_CHOKE_STATE_UNCHOKED ||
+            choke==PEER_CHOKE_STATE_UNCHOKED_OPTIMISTIC );
 
-    if( msgs->peer->chokeChangedAt > fibrillationTime )
+    /* if the state's changed... */
+    if( peer->peerChokeState != state )
     {
-        dbgmsg( msgs, "Not changing choke to %d to avoid fibrillation", choke );
+        tr_bool was_choked;
+        tr_bool is_choked;
+
+        /* change the state... */
+        was_choked = tr_peerIsChoked( peer );
+        peer->peerChokeState = state;
+        peer->peerChokeChangedAt = tr_time( );
+        is_choked = tr_peerIsChoked( peer );
+
+        if( is_choked != was_choked ) {
+            if( is_choked )
+                cancelAllRequestsToClient( msgs );
+            protocolSendChoke( msgs, is_choked  );
+        }
     }
-    else if( msgs->peer->peerIsChoked != choke )
-    {
-        msgs->peer->peerIsChoked = choke;
-        if( choke )
-            cancelAllRequestsToClient( msgs );
-        protocolSendChoke( msgs, choke );
-        msgs->peer->chokeChangedAt = now;
-    }
 }
 
 /**
@@ -1225 +1230 @@
     const tr_bool fext = tr_peerIoSupportsFEXT( msgs->peer->io );
     const int reqIsValid = requestIsValid( msgs, req );
     const int clientHasPiece = reqIsValid && tr_cpPieceIsComplete( &msgs->torrent->completion, req->index );
-    const int peerIsChoked = msgs->peer->peerIsChoked;
+    const int peerIsChoked = tr_peerIsChoked( msgs->peer );
 
     int allow = FALSE;
 
@@ -2333 +2338 @@
     m->peer = peer;
     m->torrent = torrent;
     m->peer->clientIsChoked = 1;
-    m->peer->peerIsChoked = 1;
+    m->peer->peerChokeState = PEER_CHOKE_STATE_CHOKED;
+    m->peer->peerChokeChangedAt = 0;
     m->peer->clientIsInterested = 0;
     m->peer->peerIsInterested = 0;
     m->state = AWAITING_BT_LENGTH;

libtransmission/peer-msgs.h

@@ -36 +36 @@
                              tr_peer_callback     * callback,
                              void                 * callback_data );
 
-void         tr_peerMsgsSetChoke( tr_peermsgs *, int doChoke );
+void         tr_peerMsgsSetChoke( tr_peermsgs *, uint8_t peer_choke_state );
 
 int          tr_peerMsgsIsReadingBlock( const tr_peermsgs * msgs, tr_block_index_t block );
 

libtransmission/peer-mgr.c

@@ -51 +51 @@
     /* how frequently to reallocate bandwidth */
     BANDWIDTH_PERIOD_MSEC = 500,
 
+    /* don't change a peer's choke/unchoke state more frequently than this */
+    CHOKE_FIBRILATION_PERIOD_SEC = 30,
+
     /* how frequently to age out old piece request lists */
     REFILL_UPKEEP_PERIOD_MSEC = ( 10 * 1000 ),
 
@@ -546 +549 @@
 static int
 clientIsUploadingTo( const tr_peer * peer )
 {
-    return peer->peerIsInterested && !peer->peerIsChoked;
+    return peer->peerIsInterested && !tr_peerIsChoked( peer );
 }
 
 /***
@@ -2346 +2349 @@
         stat->isEncrypted         = tr_peerIoIsEncrypted( peer->io ) ? 1 : 0;
         stat->rateToPeer_KBps     = toSpeedKBps( tr_peerGetPieceSpeed_Bps( peer, now, TR_CLIENT_TO_PEER ) );
         stat->rateToClient_KBps   = toSpeedKBps( tr_peerGetPieceSpeed_Bps( peer, now, TR_PEER_TO_CLIENT ) );
-        stat->peerIsChoked        = peer->peerIsChoked;
+        stat->peerIsChoked        = tr_peerIsChoked( peer );
         stat->peerIsInterested    = peer->peerIsInterested;
         stat->clientIsChoked      = peer->clientIsChoked;
         stat->clientIsInterested  = peer->clientIsInterested;
@@ -2702 +2705 @@
 }
 
 static void
-rechokeUploads( Torrent * t, const uint64_t now )
+rechokeUploads( Torrent * t, const uint64_t now_msec )
 {
     int i, size, unchokedInterested;
     const int peerCount = tr_ptrArraySize( &t->peers );
     tr_peer ** peers = (tr_peer**) tr_ptrArrayBase( &t->peers );
     struct ChokeData * choke = tr_new0( struct ChokeData, peerCount );
+    tr_bool have_optimistic_unchoke = FALSE;
     const tr_session * session = t->manager->session;
-    const int chokeAll = !tr_torrentIsPieceTransferAllowed( t->tor, TR_CLIENT_TO_PEER );
-    const tr_bool isMaxedOut = isBandwidthMaxedOut( t->tor->bandwidth, now, TR_UP );
+    const int choke_all = !tr_torrentIsPieceTransferAllowed( t->tor, TR_CLIENT_TO_PEER );
+    const tr_bool is_maxed_out = isBandwidthMaxedOut( t->tor->bandwidth, now_msec, TR_UP );
 
     assert( torrentIsLocked( t ) );
 
     /* sort the peers by preference and rate */
-    for( i = 0, size = 0; i < peerCount; ++i )
+    for( i=size=0; i<peerCount; ++i )
     {
         tr_peer * peer = peers[i];
         struct peer_atom * atom = peer->atom;
+        const tr_bool changed_recently = tr_time() - peer->peerChokeChangedAt < CHOKE_FIBRILATION_PERIOD_SEC;
 
         if( peer->progress >= 1.0 ) /* choke all seeds */
         {
@@ -2728 +2733 @@
         {
             tr_peerMsgsSetChoke( peer->msgs, TRUE );
         }
-        else if( chokeAll ) /* choke everyone if we're not uploading */
+        else if( choke_all ) /* choke everyone if we're not uploading */
         {
             tr_peerMsgsSetChoke( peer->msgs, TRUE );
         }
+        else if( changed_recently ) /* don't change states too quickly */
+        {
+            have_optimistic_unchoke = peer->peerChokeState == PEER_CHOKE_STATE_UNCHOKED_OPTIMISTIC;
+        }
         else
         {
             struct ChokeData * n = &choke[size++];
             n->peer         = peer;
             n->isInterested = peer->peerIsInterested;
-            n->wasChoked    = peer->peerIsChoked;
-            n->rate         = getRate( t->tor, atom, now );
+            n->wasChoked    = tr_peerIsChoked( peer );
+            n->rate         = getRate( t->tor, atom, now_msec );
             n->salt         = tr_cryptoWeakRandInt( INT_MAX );
             n->isChoked     = TRUE;
         }
@@ -2763 +2772 @@
      */
     unchokedInterested = 0;
     for( i=0; i<size && unchokedInterested<session->uploadSlotsPerTorrent; ++i ) {
-        choke[i].isChoked = isMaxedOut ? choke[i].wasChoked : FALSE;
+        choke[i].isChoked = is_maxed_out ? choke[i].wasChoked : FALSE;
         if( choke[i].isInterested )
             ++unchokedInterested;
     }
 
     /* optimistic unchoke */
-    if( !isMaxedOut && (i<size) )
+    if( !have_optimistic_unchoke && !is_maxed_out && (i<size) )
     {
         int n;
         struct ChokeData * c;

libtransmission/peer-mgr.h

@@ -70 +70 @@
 /* opaque forward declaration */
 struct peer_atom;
 
+enum
+{
+    PEER_CHOKE_STATE_CHOKED,
+    PEER_CHOKE_STATE_UNCHOKED,
+    PEER_CHOKE_STATE_UNCHOKED_OPTIMISTIC
+};
+
 /**
  * State information about a connected peer.
  *
@@ -78 +85 @@
  */
 typedef struct tr_peer
 {
-    tr_bool                  peerIsChoked;
+    uint8_t                  peerChokeState;
     tr_bool                  peerIsInterested;
     tr_bool                  clientIsChoked;
     tr_bool                  clientIsInterested;
@@ -108 +115 @@
     /* the client name from the `v' string in LTEP's handshake dictionary */
     char                   * client;
 
-    time_t                   chokeChangedAt;
+    time_t                   peerChokeChangedAt;
 
     tr_recentHistory       * blocksSentToClient;
     tr_recentHistory       * blocksSentToPeer;
@@ -120 +127 @@
 }
 tr_peer;
 
+static inline tr_bool tr_peerIsChoked( const tr_peer * peer )
+{
+    return peer->peerChokeState == PEER_CHOKE_STATE_CHOKED;
+}
+
 const tr_address * tr_peerAddress( const tr_peer * );
 
 int tr_pexCompare( const void * a, const void * b );