Changeset 9633


Ignore:
Timestamp:
Nov 29, 2009, 6:35:02 PM (13 years ago)
Author:
charles
Message:

(trunk libT) #2607 "avoid unnecessary calls to getPeerCandidates(), wasted cycles in peerIsInUse()"

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/peer-mgr.c

    r9612 r9633  
    15601560        tr_netClose( session, socket );
    15611561    }
    1562     else /* we don't have a connetion to them yet... */
     1562    else /* we don't have a connection to them yet... */
    15631563    {
    15641564        tr_peerIo *    io;
     
    25242524            continue;
    25252525
    2526         /* we don't need two connections to the same peer... */
    2527         if( peerIsInUse( t, atom ) )
    2528             continue;
    2529 
    25302526        /* no need to connect if we're both seeds... */
    25312527        if( seed && ( ( atom->flags & ADDED_F_SEED_FLAG ) ||
     
    25462542            continue;
    25472543
     2544        /* we don't need two connections to the same peer... */
     2545        if( peerIsInUse( t, atom ) )
     2546            continue;
     2547
    25482548        ret[retCount++] = atom;
    25492549    }
    25502550
    2551     qsort( ret, retCount, sizeof( struct peer_atom* ), compareCandidates );
     2551    if( retCount != 0 )
     2552        qsort( ret, retCount, sizeof( struct peer_atom* ), compareCandidates );
    25522553    *setmeSize = retCount;
    25532554    return ret;
     
    25962597    {
    25972598        int i;
    2598         int canCloseCount;
    25992599        int mustCloseCount;
    2600         int candidateCount;
    26012600        int maxCandidates;
    2602         struct tr_peer ** canClose = getPeersToClose( t, TR_CAN_CLOSE, now, &canCloseCount );
    2603         struct tr_peer ** mustClose = getPeersToClose( t, TR_MUST_CLOSE, now, &mustCloseCount );
    2604         struct peer_atom ** candidates = getPeerCandidates( t, now, &candidateCount );
    2605 
    2606         tordbg( t, "reconnect pulse for [%s]: "
    2607                    "%d must-close connections, "
    2608                    "%d can-close connections, "
    2609                    "%d connection candidates, "
    2610                    "%d atoms, "
    2611                    "max per pulse is %d",
    2612                    tr_torrentName( t->tor ),
    2613                    mustCloseCount,
    2614                    canCloseCount,
    2615                    candidateCount,
    2616                    tr_ptrArraySize( &t->pool ),
    2617                    MAX_RECONNECTIONS_PER_PULSE );
     2601        struct tr_peer ** mustClose;
    26182602
    26192603        /* disconnect the really bad peers */
     2604        mustClose = getPeersToClose( t, TR_MUST_CLOSE, now, &mustCloseCount );
    26202605        for( i=0; i<mustCloseCount; ++i )
    26212606            closePeer( t, mustClose[i] );
     2607        tr_free( mustClose );
    26222608
    26232609        /* decide how many peers can we try to add in this pass */
    2624         maxCandidates = candidateCount;
    2625         maxCandidates = MIN( maxCandidates, MAX_RECONNECTIONS_PER_PULSE );
     2610        maxCandidates = MAX_RECONNECTIONS_PER_PULSE;
    26262611        maxCandidates = MIN( maxCandidates, getMaxPeerCount( t->tor ) - getPeerCount( t ) );
    26272612        maxCandidates = MIN( maxCandidates, MAX_CONNECTIONS_PER_SECOND - newConnectionsThisSecond );
    26282613
    2629         /* maybe disconnect some lesser peers, if we have candidates to replace them with */
    2630         for( i=0; ( i<canCloseCount ) && ( i<maxCandidates ); ++i )
    2631             closePeer( t, canClose[i] );
    2632 
    2633         tordbg( t, "candidateCount is %d, MAX_RECONNECTIONS_PER_PULSE is %d,"
    2634                    " getPeerCount(t) is %d, getMaxPeerCount(t) is %d, "
    2635                    "newConnectionsThisSecond is %d, MAX_CONNECTIONS_PER_SECOND is %d",
    2636                    candidateCount,
    2637                    MAX_RECONNECTIONS_PER_PULSE,
    2638                    getPeerCount( t ),
    2639                    getMaxPeerCount( t->tor ),
    2640                    newConnectionsThisSecond, MAX_CONNECTIONS_PER_SECOND );
    2641 
    2642         /* add some new ones */
    2643         for( i=0; i<maxCandidates; ++i )
     2614        /* select the best candidates, if they are requested */
     2615        if( maxCandidates == 0 )
    26442616        {
    2645             tr_peerMgr        * mgr = t->manager;
    2646             struct peer_atom  * atom = candidates[i];
    2647             tr_peerIo         * io;
    2648 
    2649             tordbg( t, "Starting an OUTGOING connection with %s",
    2650                    tr_atomAddrStr( atom ) );
    2651 
    2652             io = tr_peerIoNewOutgoing( mgr->session, mgr->session->bandwidth, &atom->addr, atom->port, t->tor->info.hash );
    2653 
    2654             if( io == NULL )
     2617            tordbg( t, "reconnect pulse for [%s]: %d must-close connections, "
     2618                       "NO connection candidates needed, %d atoms, "
     2619                       "max per pulse is %d",
     2620                       t->tor->info.name, mustCloseCount,
     2621                       tr_ptrArraySize( &t->pool ),
     2622                       MAX_RECONNECTIONS_PER_PULSE );
     2623
     2624            tordbg( t, "maxCandidates is %d, MAX_RECONNECTIONS_PER_PULSE is %d, "
     2625                       "getPeerCount(t) is %d, getMaxPeerCount(t) is %d, "
     2626                       "newConnectionsThisSecond is %d, MAX_CONNECTIONS_PER_SECOND is %d",
     2627                       maxCandidates, MAX_RECONNECTIONS_PER_PULSE,
     2628                       getPeerCount( t ), getMaxPeerCount( t->tor ),
     2629                       newConnectionsThisSecond, MAX_CONNECTIONS_PER_SECOND );
     2630        }
     2631        else
     2632        {
     2633            int canCloseCount = 0;
     2634            int candidateCount;
     2635            struct peer_atom ** candidates;
     2636
     2637            candidates = getPeerCandidates( t, now, &candidateCount );
     2638            maxCandidates = MIN( maxCandidates, candidateCount );
     2639
     2640            /* maybe disconnect some lesser peers, if we have candidates to replace them with */
     2641            if( maxCandidates != 0 )
    26552642            {
    2656                 tordbg( t, "peerIo not created; marking peer %s as unreachable",
     2643                struct tr_peer ** canClose = getPeersToClose( t, TR_CAN_CLOSE, now, &canCloseCount );
     2644                for( i=0; ( i<canCloseCount ) && ( i<maxCandidates ); ++i )
     2645                   closePeer( t, canClose[i] );
     2646                tr_free( canClose );
     2647            }
     2648
     2649            tordbg( t, "reconnect pulse for [%s]: %d must-close connections, "
     2650                       "%d can-close connections, %d connection candidates, "
     2651                       "%d atoms, max per pulse is %d",
     2652                       t->tor->info.name, mustCloseCount,
     2653                       canCloseCount, candidateCount,
     2654                       tr_ptrArraySize( &t->pool ), MAX_RECONNECTIONS_PER_PULSE );
     2655
     2656            tordbg( t, "candidateCount is %d, MAX_RECONNECTIONS_PER_PULSE is %d,"
     2657                       " getPeerCount(t) is %d, getMaxPeerCount(t) is %d, "
     2658                       "newConnectionsThisSecond is %d, MAX_CONNECTIONS_PER_SECOND is %d",
     2659                       candidateCount, MAX_RECONNECTIONS_PER_PULSE,
     2660                       getPeerCount( t ), getMaxPeerCount( t->tor ),
     2661                       newConnectionsThisSecond, MAX_CONNECTIONS_PER_SECOND );
     2662
     2663            /* add some new ones */
     2664            for( i=0; i<maxCandidates; ++i )
     2665            {
     2666                tr_peerMgr        * mgr = t->manager;
     2667                struct peer_atom  * atom = candidates[i];
     2668                tr_peerIo         * io;
     2669
     2670                tordbg( t, "Starting an OUTGOING connection with %s",
    26572671                        tr_atomAddrStr( atom ) );
    2658                 atom->myflags |= MYFLAG_UNREACHABLE;
     2672
     2673                io = tr_peerIoNewOutgoing( mgr->session,
     2674                                           mgr->session->bandwidth,
     2675                                           &atom->addr,
     2676                                           atom->port,
     2677                                           t->tor->info.hash );
     2678
     2679                if( io == NULL )
     2680                {
     2681                    tordbg( t, "peerIo not created; marking peer %s as unreachable",
     2682                            tr_atomAddrStr( atom ) );
     2683                    atom->myflags |= MYFLAG_UNREACHABLE;
     2684                }
     2685                else
     2686                {
     2687                    tr_handshake * handshake = tr_handshakeNew( io,
     2688                                                                mgr->session->encryptionMode,
     2689                                                                myHandshakeDoneCB,
     2690                                                                mgr );
     2691
     2692                    assert( tr_peerIoGetTorrentHash( io ) );
     2693
     2694                    tr_peerIoUnref( io ); /* balanced by the implicit ref in tr_peerIoNewOutgoing() */
     2695
     2696                    ++newConnectionsThisSecond;
     2697
     2698                    tr_ptrArrayInsertSorted( &t->outgoingHandshakes, handshake,
     2699                                             handshakeCompare );
     2700                }
     2701
     2702                atom->time = now;
    26592703            }
    2660             else
    2661             {
    2662                 tr_handshake * handshake = tr_handshakeNew( io,
    2663                                                             mgr->session->encryptionMode,
    2664                                                             myHandshakeDoneCB,
    2665                                                             mgr );
    2666 
    2667                 assert( tr_peerIoGetTorrentHash( io ) );
    2668 
    2669                 tr_peerIoUnref( io ); /* balanced by the implicit ref in tr_peerIoNewOutgoing() */
    2670 
    2671                 ++newConnectionsThisSecond;
    2672 
    2673                 tr_ptrArrayInsertSorted( &t->outgoingHandshakes, handshake,
    2674                                          handshakeCompare );
    2675             }
    2676 
    2677             atom->time = now;
    2678         }
    2679 
    2680         /* cleanup */
    2681         tr_free( candidates );
    2682         tr_free( mustClose );
    2683         tr_free( canClose );
     2704            tr_free( candidates );
     2705        }
    26842706    }
    26852707}
Note: See TracChangeset for help on using the changeset viewer.