Changeset 8782

Timestamp:

Jul 6, 2009, 12:27:24 PM (13 years ago)

Author:

charles

Message:

(trunk libT) fix r8781 oops

File:

• trunk/libtransmission/peer-mgr.c (modified) (8 diffs)

trunk/libtransmission/peer-mgr.c

@@ -2159 +2159 @@
 
 static int
-compareCandidates( const void * va,
-                   const void * vb )
+compareCandidates( const void * va, const void * vb )
 {
     const struct peer_atom * a = *(const struct peer_atom**) va;
@@ -2414 +2413 @@
 {
     tr_peer * peer;
-    int speed;
+    void * clientData;
     time_t pieceDataTime;
     time_t time;
-    void * clientData;
+    int speed;
+    tr_bool doPurge;
 };
 
@@ -2426 +2426 @@
     const struct peer_liveliness * b = vb;
 
+    if( a->doPurge != b->doPurge )
+        return a->doPurge ? 1 : -1;
+
     if( a->speed != b->speed ) /* faster goes first */
         return a->speed > b->speed ? -1 : 1;
 
-    if( a->pieceDataTime != b->pieceDataTime ) /* the one to give us data more recently goes first */
+    /* the one to give us data more recently goes first */
+    if( a->pieceDataTime != b->pieceDataTime )
         return a->pieceDataTime > b->pieceDataTime ? -1 : 1;
 
-    if( a->time != b->time ) /* the one we connected to most recently goes first */
+    /* the one we connected to most recently goes first */
+    if( a->time != b->time )
         return a->time > b->time ? -1 : 1;
 
@@ -2440 +2445 @@
 /* FIXME: getPeersToClose() should use this */
 static void
-sortPeersFromBestToWorst( tr_peer ** peers, void** clientData, int n, uint64_t now )
+sortPeersByLiveliness( tr_peer ** peers, void** clientData, int n, uint64_t now )
 {
     int i;
-    struct peer_liveliness * l;
+    struct peer_liveliness *lives, *l;
 
     /* build a sortable array of peer + extra info */
-    l = tr_new0( struct peer_liveliness, n );
-    for( i=0; i<n; ++i ) {
+    lives = l = tr_new0( struct peer_liveliness, n );
+    for( i=0; i<n; ++i, ++l ) {
         tr_peer * p = peers[i];
-        l[i].peer = p;
-        l[i].speed = 1024.0 * (tr_peerGetPieceSpeed( p, now, TR_UP ) + tr_peerGetPieceSpeed( p, now, TR_DOWN ));
-        l[i].pieceDataTime = p->atom->piece_data_time;
-        l[i].time = p->atom->time;
+        l->peer = p;
+        l->doPurge = p->doPurge;
+        l->pieceDataTime = p->atom->piece_data_time;
+        l->time = p->atom->time;
+        l->speed = 1024.0 * (   tr_peerGetPieceSpeed( p, now, TR_UP )
+                              + tr_peerGetPieceSpeed( p, now, TR_DOWN ) );
         if( clientData )
-            l[i].clientData = clientData[i];
+            l->clientData = clientData[i];
     }
 
     /* sort 'em */
-    qsort( l, n, sizeof(struct peer_liveliness), comparePeerLiveliness );
+    assert( n == ( l - lives ) );
+    qsort( lives, n, sizeof( struct peer_liveliness ), comparePeerLiveliness );
 
     /* build the peer array */
-    for( i=0; i<n; ++i ) {
-        peers[i] = l[i].peer;
+    for( i=0, l=lives; i<n; ++i, ++l ) {
+        peers[i] = l->peer;
         if( clientData )
-            clientData[i] = l[i].clientData;
-    }
+            clientData[i] = l->clientData;
+    }
+    assert( n == ( l - lives ) );
 
     /* cleanup */
-    tr_free( l );
+    tr_free( lives );
 }
 
@@ -2478 +2487 @@
     if( n > max )
     {
-        tr_peer ** peers = tr_memdup( tr_ptrArrayBase( &t->peers ), n*sizeof(tr_peer*) );
-        sortPeersFromBestToWorst( peers, NULL, n, now );
+        void * base = tr_ptrArrayBase( &t->peers );
+        tr_peer ** peers = tr_memdup( base, n*sizeof( tr_peer* ) );
+        sortPeersByLiveliness( peers, NULL, n, now );
         while( n > max )
             closePeer( t, peers[--n] );
@@ -2489 +2499 @@
 enforceSessionPeerLimit( tr_session * session, uint64_t now )
 {
-    int n;
-    tr_torrent * tor;
+    int n = 0;
+    tr_torrent * tor = NULL;
     const int max = tr_sessionGetPeerLimit( session );
 
     /* count the total number of peers */
-    n = 0;
-    tor = NULL;
     while(( tor = tr_torrentNext( session, tor )))
         n += tr_ptrArraySize( &tor->torrentPeers->peers );
@@ -2502 +2510 @@
     if( n > max )
     {
-        int n = 0;
         tr_peer ** peers = tr_new( tr_peer*, n );
         Torrent ** torrents = tr_new( Torrent*, n );
 
         /* populate the peer array */
+        n = 0;
         tor = NULL;
         while(( tor = tr_torrentNext( session, tor ))) {
@@ -2519 +2527 @@
         
         /* sort 'em */
-        sortPeersFromBestToWorst( peers, (void**)torrents, n, now );
+        sortPeersByLiveliness( peers, (void**)torrents, n, now );
 
         /* cull out the crappiest */