Changeset 10748 for trunk/libtransmission/peer-mgr.c

Timestamp:

Jun 14, 2010, 1:56:03 AM (12 years ago)

Author:

charles

Message:

(trunk libT) add a much faster (but more complicated) implementation of comparePeerCandidates(). For testing in the nightlies, leave both and the new implementations in the code and run them both (which will make the nightlies slower for awhile) and crash if the results differ from each other. When it doesn't crash anymore I'll remove the old implementation. Happy testing! >:)
-place and compare them to make sure they both give the same results. If no testers can make it crash

File:

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

trunk/libtransmission/peer-mgr.c

@@ -3272 +3272 @@
 struct peer_candidate
 {
+    uint64_t score;
     int from;
-    int salt;
+    uint8_t salt;
     int priority;
     int seedProbability;
@@ -3281 +3282 @@
     tr_torrent * tor;
     struct peer_atom * atom;
-    
 };
 
@@ -3296 +3296 @@
     else if( b == -1 ) b = 100;
 
-    return a > b ? 1 : -1;
+    if( a > b ) return 1;
+    if( a < b ) return -1;
+    return 0;
 }
 
@@ -3303 +3305 @@
 {
     return difftime( tr_time( ), tor->startDate ) < 120;
+}
+
+static int loud = FALSE;
+
+static inline uint64_t
+addValToKey( uint64_t value, int width, uint64_t addme )
+{
+if(loud) fprintf( stderr, "old value %"PRIu64"... width %d, addme %d\n", value, width, (int)addme );
+    value = (value << (uint64_t)width);
+if(loud) fprintf( stderr, "mid value %"PRIu64"\n", value );
+    value |= addme;
+if(loud) fprintf( stderr, "new value %"PRIu64"\n", value );
+    return value;
+}
+
+/* smaller value is better */
+static uint64_t
+getPeerCandidateScore( const tr_torrent * tor, const struct peer_atom * atom, uint8_t salt  )
+{
+    uint64_t i;
+    uint64_t score = 0;
+    const tr_bool failed = atom->lastConnectionAt < atom->lastConnectionAttemptAt;
+
+    /* prefer peers we've connected to, or never tried, over peers we failed to connect to. */
+    i = failed ? 1 : 0;
+    score = addValToKey( score, 1, i );
+
+    /* prefer the one we attempted least recently (to cycle through all peers) */
+    i = atom->lastConnectionAttemptAt;
+    score = addValToKey( score, 32, i );
+
+    /* prefer peers belonging to a torrent of a higher priority */
+    switch( tr_torrentGetPriority( tor ) ) {
+        case TR_PRI_HIGH:    i = 0; break;
+        case TR_PRI_NORMAL:  i = 1; break;
+        case TR_PRI_LOW:     i = 2; break;
+    }
+    score = addValToKey( score, 4, i );
+
+    /* prefer recently-started torrents */
+    i = torrentWasRecentlyStarted( tor ) ? 0 : 1;
+    score = addValToKey( score, 1, i );
+
+    /* prefer peers that we might have a chance of uploading to...
+       so lower seed probability is better */
+    if( atom->seedProbability == 100 ) i = 101;
+    else if( atom->seedProbability == -1 ) i = 100;
+    else i = atom->seedProbability;
+    score = addValToKey( score, 8, i );
+
+    /* Prefer peers that we got from more trusted sources.
+     * lower `from' values indicate more trusted sources */
+    score = addValToKey( score, 4, atom->from );
+
+    /* salt */
+    score = addValToKey( score, 8, salt );
+
+    return score;
+}
+
+static int
+oldComparePeerCandidates( const void * va, const void * vb )
+{
+    int i;
+    const struct peer_candidate * a = va;
+    const struct peer_candidate * b = vb;
+
+    /* prefer peers we've connected to, or never tried, over peers we failed to connect to. */
+    const tr_bool a_failed = a->atom->lastConnectionAt < a->atom->lastConnectionAttemptAt;
+    const tr_bool b_failed = b->atom->lastConnectionAt < b->atom->lastConnectionAttemptAt;
+    if( a_failed != b_failed ) {
+if(loud) fprintf( stderr, "old: a_failed %d\n", (int)a_failed );
+if(loud) fprintf( stderr, "old: b_failed %d\n", (int)b_failed );
+        return a_failed ? 1 : -1;
+    }
+
+    /* prefer the one we attempted least recently (to cycle through all peers) */
+    if( a->lastConnectionAttemptAt != b->lastConnectionAttemptAt ) {
+if(loud) fprintf( stderr, "old: a->lastConnectionAttemptAt %u\n", (unsigned int)a->lastConnectionAttemptAt );
+if(loud) fprintf( stderr, "old: b->lastConnectionAttemptAt %u\n", (unsigned int)b->lastConnectionAttemptAt );
+        return a->lastConnectionAttemptAt < b->lastConnectionAttemptAt ? -1 : 1;
+    }
+
+    /* prefer peers belonging to a torrent of a higher priority */
+    if( a->priority != b->priority ) {
+if(loud) fprintf( stderr, "old: a->priority %d\n", (int)a->priority );
+if(loud) fprintf( stderr, "old: b->priority %d\n", (int)b->priority );
+        return a->priority > b->priority ? -1 : 1;
+    }
+
+    /* prefer recently-started torrents */
+    if( a->wasRecentlyStarted != b->wasRecentlyStarted ) {
+if(loud) fprintf( stderr, "old: a->wasRecentlyStarted %d\n", (int)a->wasRecentlyStarted );
+if(loud) fprintf( stderr, "old: b->wasRecentlyStarted %d\n", (int)b->wasRecentlyStarted );
+        return a->wasRecentlyStarted ? -1 : 1;
+     }
+
+    /* prefer peers that we might have a chance of uploading to */
+    if(( i = compareSeedProbabilities( a->seedProbability, b->seedProbability ))) {
+if(loud) fprintf( stderr, "old: a->seedProbability %d\n", (int)a->seedProbability );
+if(loud) fprintf( stderr, "old: b->seedProbability %d\n", (int)b->seedProbability );
+        return i;
+    }
+
+    /* prefer peers that we got from more trusted sources */
+    if( a->from != b->from ) {
+if(loud) fprintf( stderr, "old: a->from %d\n", (int)a->from );
+if(loud) fprintf( stderr, "old: b->from %d\n", (int)b->from );
+        return a->from < b->from ? -1 : 1;
+    }
+
+    /* salt */
+if(loud) fprintf( stderr, "old: a->salt %d\n", (int)a->salt );
+if(loud) fprintf( stderr, "old: b->salt %d\n", (int)b->salt );
+    if( a->salt != b->salt )
+        return a->salt < b->salt ? -1 : 1;
+
+    return 0;
 }
 
@@ -3309 +3429 @@
 comparePeerCandidates( const void * va, const void * vb )
 {
-    int i;
-    tr_bool af, bf;
+    int ret;
+    int oldret;
     const struct peer_candidate * a = va;
     const struct peer_candidate * b = vb;
 
-    /* prefer peers we've connected to, or never tried, over peers we failed to connect to. */
-    af = a->lastConnectionAt < a->lastConnectionAttemptAt;
-    bf = b->lastConnectionAt < b->lastConnectionAttemptAt;
-    if( af != bf )
-        return af ? 1 : -1;
-
-    /* prefer the one we attempted least recently (to cycle through all peers) */
-    if( a->lastConnectionAttemptAt != b->lastConnectionAttemptAt )
-        return a->lastConnectionAttemptAt < b->lastConnectionAttemptAt ? -1 : 1;
-
-    /* prefer peers belonging to a torrent of a higher priority */
-    if( a->priority != b->priority )
-        return a->priority > b->priority ? -1 : 1;
-
-    /* prefer recently-started torrents */
-    if( a->wasRecentlyStarted != b->wasRecentlyStarted )
-        return a->wasRecentlyStarted ? -1 : 1;
-
-    /* prefer peers that we might have a chance of uploading to */
-    if(( i = compareSeedProbabilities( a->seedProbability, b->seedProbability )))
-        return i;
-
-    /* prefer peers that we got from more trusted sources */
-    if( a->from != b->from )
-        return a->from < b->from ? -1 : 1;
-
-    /* salt */
-    return a->salt - b->salt;
+    if( a->score != b->score )
+        ret = a->score < b->score ? -1 : 1;
+    else
+        ret = 0;
+    
+    oldret = oldComparePeerCandidates( va, vb );
+
+    if( ret != oldret ) {
+        loud = TRUE;
+        oldret = oldComparePeerCandidates( va, vb );
+        fprintf( stderr, "ccc =========================\n" );
+        fprintf( stderr, "oldret %d\n", oldret );
+        fprintf( stderr, "ret %d\n", ret );
+        fprintf( stderr, "a score %"PRIu64"\n", a->score );
+        fprintf( stderr, "b score %"PRIu64"\n", b->score );
+        fprintf( stderr, "generating a score\n" );
+        getPeerCandidateScore( a->tor, a->atom, a->salt );
+        fprintf( stderr, "generating b bcore\n" );
+        getPeerCandidateScore( b->tor, b->atom, b->salt );
+        assert( 0 );
+    }
+
+    return ret;
 }
 
@@ -3403 +3518 @@
                 walk->from = atom->from;
                 walk->salt = tr_cryptoWeakRandInt( 4096 );
+                walk->score = getPeerCandidateScore( tor, atom, walk->salt );
                 walk->priority = tr_torrentGetPriority( tor );
                 walk->seedProbability = atom->seedProbability;