Changeset 7524

Timestamp:

Dec 29, 2008, 8:54:36 AM (12 years ago)

Author:

charles

Message:

(trunk libT) avoid some unnecessary memory fragmentation... for composited objects that have a tr_ptrArray, contain the tr_ptrArray directly rather than a pointer to one allocated elsewhere on the heap.

Location:

trunk/libtransmission

Files:

• bandwidth.c (modified) (12 diffs)
• bencode.c (modified) (8 diffs)
• json.c (modified) (6 diffs)
• peer-mgr.c (modified) (44 diffs)
• ptrarray.c (modified) (2 diffs)
• ptrarray.h (modified) (1 diff)
• torrent.c (modified) (6 diffs)

trunk/libtransmission/bandwidth.c

@@ -99 +99 @@
     int magicNumber;
     tr_session * session;
-    tr_ptrArray * children; /* struct tr_bandwidth */
-    tr_ptrArray * peers; /* tr_peerIo */
+    tr_ptrArray children; /* struct tr_bandwidth */
+    tr_ptrArray peers; /* tr_peerIo */
 };
 
@@ -131 +131 @@
     tr_bandwidth * b = tr_new0( tr_bandwidth, 1 );
     b->session = session;
-    b->children = tr_ptrArrayNew( );
-    b->peers = tr_ptrArrayNew( );
+    b->children = TR_PTR_ARRAY_INIT;
+    b->peers = TR_PTR_ARRAY_INIT;
     b->magicNumber = MAGIC_NUMBER;
     b->band[TR_UP].honorParentLimits = TRUE;
@@ -146 +146 @@
 
     tr_bandwidthSetParent( b, NULL );
-    tr_ptrArrayFree( b->peers, NULL );
-    tr_ptrArrayFree( b->children, NULL );
+    tr_ptrArrayDestruct( &b->peers, NULL );
+    tr_ptrArrayDestruct( &b->children, NULL );
     b->magicNumber = 0xDEAD;
     tr_free( b );
@@ -167 +167 @@
         assert( tr_isBandwidth( b->parent ) );
 
-        tr_ptrArrayRemoveSorted( b->parent->children, b, comparePointers );
+        tr_ptrArrayRemoveSorted( &b->parent->children, b, comparePointers );
         b->parent = NULL;
     }
@@ -176 +176 @@
         assert( parent->parent != b );
 
-        tr_ptrArrayInsertSorted( parent->children, b, comparePointers );
+        tr_ptrArrayInsertSorted( &parent->children, b, comparePointers );
         b->parent = parent;
     }
@@ -270 +270 @@
     {
         int i;
-        const int n = tr_ptrArraySize( b->peers );
+        const int n = TR_PTR_ARRAY_LENGTH( &b->peers );
         for( i=0; i<n; ++i )
-            tr_ptrArrayAppend( peer_pool, tr_ptrArrayNth( b->peers, i ) );
+            tr_ptrArrayAppend( peer_pool, tr_ptrArrayNth( &b->peers, i ) );
     }
 
@@ -282 +282 @@
     /* all children should reallocate too */
     if( 1 ) {
-        int i, n=0;
-        struct tr_bandwidth ** children = (struct tr_bandwidth**) tr_ptrArrayPeek( b->children, &n );
+        int i;
+        struct tr_bandwidth ** children = (struct tr_bandwidth**) TR_PTR_ARRAY_DATA( &b->children );
+        const int n = TR_PTR_ARRAY_LENGTH( &b->children );
         for( i=0; i<n; ++i )
             allocateBandwidth( children[i], dir, period_msec, peer_pool );
@@ -295 +296 @@
 {
     int i, n, peerCount;
-    tr_ptrArray * tmp;
+    tr_ptrArray tmp = TR_PTR_ARRAY_INIT;
     struct tr_peerIo ** peers;
     const uint64_t now = tr_date( );
@@ -304 +305 @@
      * 1. allocate bandwidth to b and its subtree
      * 2. accumulate an array of all the peerIos from b and its subtree. */
-    tmp = tr_ptrArrayNew( );
-    allocateBandwidth( b, dir, period_msec, tmp );
-    peers = (struct tr_peerIo**) tr_ptrArrayPeek( tmp, &peerCount );
+    allocateBandwidth( b, dir, period_msec, &tmp );
+    peers = (struct tr_peerIo**) tr_ptrArrayPeek( &tmp, &peerCount );
 
     /* Stop all peers from listening for the socket to be ready for IO.
@@ -348 +348 @@
 
     /* cleanup */
-    tr_ptrArrayFree( tmp, NULL );
+    tr_ptrArrayDestruct( &tmp, NULL );
 }
 
@@ -362 +362 @@
     assert( tr_isPeerIo( peerIo ) );
 
-    tr_ptrArrayInsertSorted( b->peers, peerIo, comparePointers );
+    tr_ptrArrayInsertSorted( &b->peers, peerIo, comparePointers );
 }
 
@@ -372 +372 @@
     assert( tr_isPeerIo( peerIo ) );
 
-    tr_ptrArrayRemoveSorted( b->peers, peerIo, comparePointers );
+    tr_ptrArrayRemoveSorted( &b->peers, peerIo, comparePointers );
 }
 

trunk/libtransmission/bencode.c

@@ -327 +327 @@
 {
     int           err;
-    tr_ptrArray * parentStack = tr_ptrArrayNew( );
+    tr_ptrArray   parentStack = TR_PTR_ARRAY_INIT;
 
     top->type = 0; /* set to `uninitialized' */
-    err = tr_bencParseImpl( buf, end, top, parentStack, setme_end );
+    err = tr_bencParseImpl( buf, end, top, &parentStack, setme_end );
     if( err )
         tr_bencFree( top );
 
-    tr_ptrArrayFree( parentStack, NULL );
+    tr_ptrArrayDestruct( &parentStack, NULL );
     return err;
 }
@@ -933 +933 @@
           void *             user_data )
 {
-    tr_ptrArray * stack = tr_ptrArrayNew( );
-
-    tr_ptrArrayAppend( stack, nodeNew( top ) );
-
-    while( !tr_ptrArrayEmpty( stack ) )
-    {
-        struct SaveNode * node = tr_ptrArrayBack( stack );
+    tr_ptrArray stack = TR_PTR_ARRAY_INIT;
+
+    tr_ptrArrayAppend( &stack, nodeNew( top ) );
+
+    while( !tr_ptrArrayEmpty( &stack ) )
+    {
+        struct SaveNode * node = tr_ptrArrayBack( &stack );
         const tr_benc *   val;
 
@@ -956 +956 @@
             if( isContainer( node->val ) )
                 walkFuncs->containerEndFunc( node->val, user_data );
-            tr_ptrArrayPop( stack );
+            tr_ptrArrayPop( &stack );
             tr_free( node->children );
             tr_free( node );
@@ -974 +974 @@
                 case TYPE_LIST:
                     if( val != node->val )
-                        tr_ptrArrayAppend( stack, nodeNew( val ) );
+                        tr_ptrArrayAppend( &stack, nodeNew( val ) );
                     else
                         walkFuncs->listBeginFunc( val, user_data );
@@ -981 +981 @@
                 case TYPE_DICT:
                     if( val != node->val )
-                        tr_ptrArrayAppend( stack, nodeNew( val ) );
+                        tr_ptrArrayAppend( &stack, nodeNew( val ) );
                     else
                         walkFuncs->dictBeginFunc( val, user_data );
@@ -993 +993 @@
     }
 
-    tr_ptrArrayFree( stack, NULL );
+    tr_ptrArrayDestruct( &stack, NULL );
 }
 
@@ -1088 +1088 @@
     if( val && val->type )
     {
-        tr_ptrArray *    freeme = tr_ptrArrayNew( );
+        tr_ptrArray a = TR_PTR_ARRAY_INIT;
         struct WalkFuncs walkFuncs;
 
@@ -1096 +1096 @@
         walkFuncs.listBeginFunc = freeContainerBeginFunc;
         walkFuncs.containerEndFunc = freeDummyFunc;
-        bencWalk( val, &walkFuncs, freeme );
-
-        tr_ptrArrayFree( freeme, tr_free );
+        bencWalk( val, &walkFuncs, &a );
+
+        tr_ptrArrayDestruct( &a, tr_free );
     }
 }

trunk/libtransmission/json.c

@@ -30 +30 @@
 {
     tr_benc *      top;
-    tr_ptrArray *  stack;
+    tr_ptrArray    stack;
     char *         key;
 };
@@ -40 +40 @@
     tr_benc * node = NULL;
 
-    if( tr_ptrArrayEmpty( data->stack ) )
+    if( tr_ptrArrayEmpty( &data->stack ) )
         parent = NULL;
     else
-        parent = tr_ptrArrayBack( data->stack );
+        parent = tr_ptrArrayBack( &data->stack );
 
     if( !parent )
@@ -72 +72 @@
             node = getNode( data );
             tr_bencInitList( node, 0 );
-            tr_ptrArrayAppend( data->stack, node );
+            tr_ptrArrayAppend( &data->stack, node );
             break;
 
         case JSON_T_ARRAY_END:
-            tr_ptrArrayPop( data->stack );
+            tr_ptrArrayPop( &data->stack );
             break;
 
@@ -82 +82 @@
             node = getNode( data );
             tr_bencInitDict( node, 0 );
-            tr_ptrArrayAppend( data->stack, node );
+            tr_ptrArrayAppend( &data->stack, node );
             break;
 
         case JSON_T_OBJECT_END:
-            tr_ptrArrayPop( data->stack );
+            tr_ptrArrayPop( &data->stack );
             break;
 
@@ -149 +149 @@
     data.key = NULL;
     data.top = setme_benc;
-    data.stack = tr_ptrArrayNew( );
+    data.stack = TR_PTR_ARRAY_INIT;
 
     checker = new_JSON_parser( &config );
@@ -162 +162 @@
 
     delete_JSON_parser( checker );
-    tr_ptrArrayFree( data.stack, NULL );
+    tr_ptrArrayDestruct( &data.stack, NULL );
     return err;
 }

trunk/libtransmission/peer-mgr.c

@@ -126 +126 @@
     uint8_t         hash[SHA_DIGEST_LENGTH];
     int         *   pendingRequestCount;
-    tr_ptrArray *   outgoingHandshakes; /* tr_handshake */
-    tr_ptrArray *   pool; /* struct peer_atom */
-    tr_ptrArray *   peers; /* tr_peer */
-    tr_ptrArray *   webseeds; /* tr_webseed */
+    tr_ptrArray     outgoingHandshakes; /* tr_handshake */
+    tr_ptrArray     pool; /* struct peer_atom */
+    tr_ptrArray     peers; /* tr_peer */
+    tr_ptrArray     webseeds; /* tr_webseed */
     tr_timer *      reconnectTimer;
     tr_timer *      rechokeTimer;
@@ -143 +143 @@
 {
     tr_session      * session;
-    tr_ptrArray     * torrents; /* Torrent */
-    tr_ptrArray     * incomingHandshakes; /* tr_handshake */
-    tr_ptrArray     * finishedHandshakes; /* tr_handshake */
+    tr_ptrArray       torrents; /* Torrent */
+    tr_ptrArray       incomingHandshakes; /* tr_handshake */
+    tr_ptrArray       finishedHandshakes; /* tr_handshake */
     tr_timer        * bandwidthTimer;
 };
@@ -264 +264 @@
                     const uint8_t * hash )
 {
-    return (Torrent*) tr_ptrArrayFindSorted( manager->torrents,
+    return (Torrent*) tr_ptrArrayFindSorted( &manager->torrents,
                                              hash,
                                              torrentCompareToHash );
@@ -293 +293 @@
     assert( addr );
 
-    return tr_ptrArrayFindSorted( torrent->peers, addr, peerCompareToAddr );
+    return tr_ptrArrayFindSorted( &torrent->peers, addr, peerCompareToAddr );
 }
 
@@ -300 +300 @@
                  const tr_address * addr )
 {
+    Torrent * tt = (Torrent*)t;
     assert( torrentIsLocked( t ) );
-    return tr_ptrArrayFindSorted( t->pool, addr, comparePeerAtomToAddress );
+    return tr_ptrArrayFindSorted( &tt->pool, addr, comparePeerAtomToAddress );
 }
 
@@ -313 +314 @@
 
     return getExistingPeer( t, addr )
-        || getExistingHandshake( t->outgoingHandshakes, addr )
-        || getExistingHandshake( t->manager->incomingHandshakes, addr );
+        || getExistingHandshake( &t->outgoingHandshakes, addr )
+        || getExistingHandshake( &t->manager->incomingHandshakes, addr );
 }
 
@@ -340 +341 @@
     {
         peer = peerConstructor( torrent->tor, addr );
-        tr_ptrArrayInsertSorted( torrent->peers, peer, peerCompare );
+        tr_ptrArrayInsertSorted( &torrent->peers, peer, peerCompare );
     }
 
@@ -381 +382 @@
     atom->time = time( NULL );
 
-    removed = tr_ptrArrayRemoveSorted( t->peers, peer, peerCompare );
+    removed = tr_ptrArrayRemoveSorted( &t->peers, peer, peerCompare );
     assert( removed == peer );
     peerDestructor( removed );
@@ -389 +390 @@
 removeAllPeers( Torrent * t )
 {
-    while( !tr_ptrArrayEmpty( t->peers ) )
-        removePeer( t, tr_ptrArrayNth( t->peers, 0 ) );
+    while( !tr_ptrArrayEmpty( &t->peers ) )
+        removePeer( t, tr_ptrArrayNth( &t->peers, 0 ) );
 }
 
@@ -401 +402 @@
     assert( t );
     assert( !t->isRunning );
-    assert( t->peers );
     assert( torrentIsLocked( t ) );
-    assert( tr_ptrArrayEmpty( t->outgoingHandshakes ) );
-    assert( tr_ptrArrayEmpty( t->peers ) );
+    assert( tr_ptrArrayEmpty( &t->outgoingHandshakes ) );
+    assert( tr_ptrArrayEmpty( &t->peers ) );
 
     memcpy( hash, t->hash, SHA_DIGEST_LENGTH );
@@ -412 +412 @@
     tr_timerFree( &t->refillTimer );
 
-    tr_ptrArrayFree( t->webseeds, (PtrArrayForeachFunc)tr_webseedFree );
-    tr_ptrArrayFree( t->pool, (PtrArrayForeachFunc)tr_free );
-    tr_ptrArrayFree( t->outgoingHandshakes, NULL );
-    tr_ptrArrayFree( t->peers, NULL );
+    tr_ptrArrayDestruct( &t->webseeds, (PtrArrayForeachFunc)tr_webseedFree );
+    tr_ptrArrayDestruct( &t->pool, (PtrArrayForeachFunc)tr_free );
+    tr_ptrArrayDestruct( &t->outgoingHandshakes, NULL );
+    tr_ptrArrayDestruct( &t->peers, NULL );
 
     tr_free( t->pendingRequestCount );
@@ -435 +435 @@
     t->manager = manager;
     t->tor = tor;
-    t->pool = tr_ptrArrayNew( );
-    t->peers = tr_ptrArrayNew( );
-    t->webseeds = tr_ptrArrayNew( );
-    t->outgoingHandshakes = tr_ptrArrayNew( );
+    t->pool = TR_PTR_ARRAY_INIT;
+    t->peers = TR_PTR_ARRAY_INIT;
+    t->webseeds = TR_PTR_ARRAY_INIT;
+    t->outgoingHandshakes = TR_PTR_ARRAY_INIT;
     memcpy( t->hash, tor->info.hash, SHA_DIGEST_LENGTH );
 
@@ -444 +444 @@
     {
         tr_webseed * w =
-            tr_webseedNew( tor, tor->info.webseeds[i], peerCallbackFunc,
-                           t );
-        tr_ptrArrayAppend( t->webseeds, w );
+            tr_webseedNew( tor, tor->info.webseeds[i], peerCallbackFunc, t );
+        tr_ptrArrayAppend( &t->webseeds, w );
     }
 
@@ -462 +461 @@
 
     m->session = session;
-    m->torrents = tr_ptrArrayNew( );
-    m->incomingHandshakes = tr_ptrArrayNew( );
-    m->finishedHandshakes = tr_ptrArrayNew( );
+    m->torrents = TR_PTR_ARRAY_INIT;
+    m->incomingHandshakes = TR_PTR_ARRAY_INIT;
+    m->finishedHandshakes = TR_PTR_ARRAY_INIT;
     m->bandwidthTimer = tr_timerNew( session, bandwidthPulse, m, BANDWIDTH_PERIOD_MSEC );
     return m;
@@ -480 +479 @@
     /* free the handshakes.  Abort invokes handshakeDoneCB(), which removes
      * the item from manager->handshakes, so this is a little roundabout... */
-    while( !tr_ptrArrayEmpty( manager->incomingHandshakes ) )
-        tr_handshakeAbort( tr_ptrArrayNth( manager->incomingHandshakes, 0 ) );
-
-    tr_ptrArrayFree( manager->incomingHandshakes, NULL );
-
-    while(( handshake = tr_ptrArrayPop( manager->finishedHandshakes )))
+    while( !tr_ptrArrayEmpty( &manager->incomingHandshakes ) )
+        tr_handshakeAbort( tr_ptrArrayNth( &manager->incomingHandshakes, 0 ) );
+
+    tr_ptrArrayDestruct( &manager->incomingHandshakes, NULL );
+
+    while(( handshake = tr_ptrArrayPop( &manager->finishedHandshakes )))
         tr_handshakeFree( handshake );
 
-    tr_ptrArrayFree( manager->finishedHandshakes, NULL );
+    tr_ptrArrayDestruct( &manager->finishedHandshakes, NULL );
 
     /* free the torrents. */
-    tr_ptrArrayFree( manager->torrents, torrentDestructor );
+    tr_ptrArrayDestruct( &manager->torrents, torrentDestructor );
 
     managerUnlock( manager );
@@ -506 +505 @@
     assert( torrentIsLocked( t ) );
 
-    peers = (tr_peer **) tr_ptrArrayPeek( t->peers, &peerCount );
+    peers = (tr_peer **) tr_ptrArrayPeek( &t->peers, &peerCount );
     ret = tr_new( tr_peer *, peerCount );
 
@@ -759 +758 @@
     int peerCount = 0;
     int retCount = 0;
-    tr_peer ** peers = (tr_peer **) tr_ptrArrayPeek( t->peers, &peerCount );
+    tr_peer ** peers = (tr_peer **) tr_ptrArrayPeek( &t->peers, &peerCount );
     tr_peer ** ret = tr_new( tr_peer *, peerCount );
 
@@ -813 +812 @@
     blockIterator = blockIteratorNew( t );
     peers = getPeersUploadingToClient( t, &peerCount );
-    webseedCount = tr_ptrArraySize( t->webseeds );
-    webseeds = tr_memdup( tr_ptrArrayBase( t->webseeds ),
+    webseedCount = tr_ptrArraySize( &t->webseeds );
+    webseeds = tr_memdup( tr_ptrArrayBase( &t->webseeds ),
                           webseedCount * sizeof( tr_webseed* ) );
 
@@ -1183 +1182 @@
         a->from = from;
         tordbg( t, "got a new atom: %s", tr_peerIoAddrStr( &a->addr, a->port ) );
-        tr_ptrArrayInsertSorted( t->pool, a, comparePeerAtoms );
+        tr_ptrArrayInsertSorted( &t->pool, a, comparePeerAtoms );
     }
 }
@@ -1196 +1195 @@
 getPeerCount( const Torrent * t )
 {
-    return tr_ptrArraySize( t->peers ) + tr_ptrArraySize( t->outgoingHandshakes );
+    return tr_ptrArraySize( &t->peers ) + tr_ptrArraySize( &t->outgoingHandshakes );
 }
 
@@ -1223 +1222 @@
 
     if( tr_peerIoIsIncoming ( io ) )
-        ours = tr_ptrArrayRemoveSorted( manager->incomingHandshakes,
+        ours = tr_ptrArrayRemoveSorted( &manager->incomingHandshakes,
                                         handshake, handshakeCompare );
     else if( t )
-        ours = tr_ptrArrayRemoveSorted( t->outgoingHandshakes,
+        ours = tr_ptrArrayRemoveSorted( &t->outgoingHandshakes,
                                         handshake, handshakeCompare );
     else
@@ -1297 +1296 @@
 
     if( !success )
-        tr_ptrArrayAppend( manager->finishedHandshakes, handshake );
+        tr_ptrArrayAppend( &manager->finishedHandshakes, handshake );
 
     if( t )
@@ -1318 +1317 @@
         tr_netClose( socket );
     }
-    else if( getExistingHandshake( manager->incomingHandshakes, addr ) )
+    else if( getExistingHandshake( &manager->incomingHandshakes, addr ) )
     {
         tr_netClose( socket );
@@ -1334 +1333 @@
                                      manager );
 
-        tr_ptrArrayInsertSorted( manager->incomingHandshakes, handshake,
+        tr_ptrArrayInsertSorted( &manager->incomingHandshakes, handshake,
                                  handshakeCompare );
     }
@@ -1457 +1456 @@
         assert( torrentIsLocked( t ) );
 
-        peers = (tr_peer **) tr_ptrArrayPeek( t->peers, &peerCount );
+        peers = (tr_peer **) tr_ptrArrayPeek( &t->peers, &peerCount );
         for( i = 0; i < peerCount; ++i )
         {
@@ -1509 +1508 @@
                     uint8_t           af)
 {
-    int peerCount = 0;
     int peersReturning = 0;
     const Torrent *  t;
@@ -1523 +1521 @@
     {
         int i;
-        const tr_peer ** peers = (const tr_peer **) tr_ptrArrayPeek( t->peers, &peerCount );
+        const tr_peer ** peers = (const tr_peer**) TR_PTR_ARRAY_DATA( &t->peers );
+        const int peerCount = TR_PTR_ARRAY_LENGTH( &t->peers );
         /* for now, this will waste memory on torrents that have both
          * ipv6 and ipv4 peers */
@@ -1592 +1591 @@
         rechokePulse( t );
 
-        if( !tr_ptrArrayEmpty( t->webseeds ) )
+        if( !tr_ptrArrayEmpty( &t->webseeds ) )
             refillSoon( t );
     }
@@ -1609 +1608 @@
 
     /* disconnect the peers. */
-    tr_ptrArrayForeach( t->peers, (PtrArrayForeachFunc)peerDestructor );
-    tr_ptrArrayClear( t->peers );
+    tr_ptrArrayForeach( &t->peers, (PtrArrayForeachFunc)peerDestructor );
+    tr_ptrArrayClear( &t->peers );
 
     /* disconnect the handshakes.  handshakeAbort calls handshakeDoneCB(),
      * which removes the handshake from t->outgoingHandshakes... */
-    while( !tr_ptrArrayEmpty( t->outgoingHandshakes ) )
-        tr_handshakeAbort( tr_ptrArrayNth( t->outgoingHandshakes, 0 ) );
+    while( !tr_ptrArrayEmpty( &t->outgoingHandshakes ) )
+        tr_handshakeAbort( tr_ptrArrayNth( &t->outgoingHandshakes, 0 ) );
 }
 
@@ -1641 +1640 @@
 
     t = torrentConstructor( manager, tor );
-    tr_ptrArrayInsertSorted( manager->torrents, t, torrentCompare );
+    tr_ptrArrayInsertSorted( &manager->torrents, t, torrentCompare );
 
     managerUnlock( manager );
@@ -1657 +1656 @@
     assert( t );
     stopTorrent( t );
-    tr_ptrArrayRemoveSorted( manager->torrents, t, torrentCompare );
+    tr_ptrArrayRemoveSorted( &manager->torrents, t, torrentCompare );
     torrentDestructor( t );
 
@@ -1683 +1682 @@
     interval = tor->info.pieceCount / (float)tabCount;
     isSeed = tor && ( tr_cpGetStatus ( tor->completion ) == TR_SEED );
-    peers = (const tr_peer **) tr_ptrArrayPeek( t->peers, &peerCount );
+    peers = (const tr_peer **) TR_PTR_ARRAY_DATA( &t->peers );
+    peerCount = TR_PTR_ARRAY_LENGTH( &t->peers );
 
     memset( tab, 0, tabCount );
@@ -1735 +1735 @@
 
     t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
-    ret = t && ( !tr_ptrArrayEmpty( t->peers ) || !tr_ptrArrayEmpty( t->webseeds ) );
+    ret = t && ( !tr_ptrArrayEmpty( &t->peers ) || !tr_ptrArrayEmpty( &t->webseeds ) );
 
     managerUnlock( manager );
@@ -1760 +1760 @@
 
     t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
-    peers = (const tr_peer **) tr_ptrArrayPeek( t->peers, &size );
-
-    *setmePeersKnown           = tr_ptrArraySize( t->pool );
+    peers = (const tr_peer **) TR_PTR_ARRAY_DATA( &t->peers );
+    size = TR_PTR_ARRAY_LENGTH( &t->peers );
+
+    *setmePeersKnown           = tr_ptrArraySize( &t->pool );
     *setmePeersConnected       = 0;
     *setmeSeedsConnected       = 0;
@@ -1794 +1795 @@
     }
 
-    webseeds = (const tr_webseed **) tr_ptrArrayPeek( t->webseeds, &size );
+    webseeds = (const tr_webseed**) TR_PTR_ARRAY_DATA( &t->webseeds );
+    size = TR_PTR_ARRAY_LENGTH( &t->webseeds );
     for( i=0; i<size; ++i )
         if( tr_webseedIsActive( webseeds[i] ) )
@@ -1816 +1818 @@
 
     t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
-    webseeds = (const tr_webseed**) tr_ptrArrayPeek( t->webseeds,
-                                                     &webseedCount );
+    webseeds = (const tr_webseed**) TR_PTR_ARRAY_DATA( &t->webseeds );
+    webseedCount = TR_PTR_ARRAY_LENGTH( &t->webseeds );
     assert( webseedCount == t->tor->info.webseedCount );
     ret = tr_new0( float, webseedCount );
@@ -2015 +2017 @@
         int n;
         struct ChokeData * c;
-        tr_ptrArray * randPool = tr_ptrArrayNew( );
+        tr_ptrArray randPool = TR_PTR_ARRAY_INIT;
 
         for( ; i<size; ++i )
@@ -2026 +2028 @@
                 if( isSame( peer ) ) x *= 3;
                 for( y=0; y<x; ++y )
-                    tr_ptrArrayAppend( randPool, &choke[i] );
+                    tr_ptrArrayAppend( &randPool, &choke[i] );
             }
         }
 
-        if(( n = tr_ptrArraySize( randPool )))
+        if(( n = tr_ptrArraySize( &randPool )))
         {
-            c = tr_ptrArrayNth( randPool, tr_cryptoWeakRandInt( n ));
+            c = tr_ptrArrayNth( &randPool, tr_cryptoWeakRandInt( n ));
             c->doUnchoke = 1;
             t->optimistic = c->peer;
         }
 
-        tr_ptrArrayFree( randPool, NULL );
+        tr_ptrArrayDestruct( &randPool, NULL );
     }
 
@@ -2134 +2136 @@
 {
     int i, peerCount, outsize;
-    tr_peer ** peers = (tr_peer**) tr_ptrArrayPeek( t->peers, &peerCount );
+    tr_peer ** peers = (tr_peer**) tr_ptrArrayPeek( &t->peers, &peerCount );
     struct tr_peer ** ret = tr_new( tr_peer *, peerCount );
 
@@ -2220 +2222 @@
     assert( torrentIsLocked( t ) );
 
-    atoms = (struct peer_atom**) tr_ptrArrayPeek( t->pool, &atomCount );
+    atoms = (struct peer_atom**) tr_ptrArrayPeek( &t->pool, &atomCount );
     ret = tr_new( struct peer_atom*, atomCount );
     for( i = retCount = 0; i < atomCount; ++i )
@@ -2299 +2301 @@
                     "%d connection candidates, %d atoms, max per pulse is %d",
                     t->tor->info.name, nBad, nCandidates,
-                    tr_ptrArraySize( t->pool ),
+                    tr_ptrArraySize( &t->pool ),
                     (int)MAX_RECONNECTIONS_PER_PULSE );
 
@@ -2346 +2348 @@
                 ++newConnectionsThisSecond;
 
-                tr_ptrArrayInsertSorted( t->outgoingHandshakes, handshake,
+                tr_ptrArrayInsertSorted( &t->outgoingHandshakes, handshake,
                                          handshakeCompare );
             }
@@ -2371 +2373 @@
 pumpAllPeers( tr_peerMgr * mgr )
 {
-    const int torrentCount = tr_ptrArraySize( mgr->torrents );
+    const int torrentCount = tr_ptrArraySize( &mgr->torrents );
     int       i, j;
 
     for( i=0; i<torrentCount; ++i )
     {
-        Torrent * t = tr_ptrArrayNth( mgr->torrents, i );
-        for( j=0; j<tr_ptrArraySize( t->peers ); ++j )
+        Torrent * t = tr_ptrArrayNth( &mgr->torrents, i );
+        for( j=0; j<tr_ptrArraySize( &t->peers ); ++j )
         {
-            tr_peer * peer = tr_ptrArrayNth( t->peers, j );
+            tr_peer * peer = tr_ptrArrayNth( &t->peers, j );
             tr_peerMsgsPulse( peer->msgs );
         }
@@ -2400 +2402 @@
 
     /* free all the finished handshakes */
-    while(( handshake = tr_ptrArrayPop( mgr->finishedHandshakes )))
+    while(( handshake = tr_ptrArrayPop( &mgr->finishedHandshakes )))
         tr_handshakeFree( handshake );
 

trunk/libtransmission/ptrarray.c

@@ -20 +20 @@
 #define GROW 32
 
-struct tr_ptrArray
-{
-    void ** items;
-    int     n_items;
-    int     n_alloc;
-};
+const tr_ptrArray TR_PTR_ARRAY_INIT = { NULL, 0, 0 };
+
+void
+tr_ptrArrayDestruct( tr_ptrArray * p, PtrArrayForeachFunc func )
+{
+    assert( p );
+    assert( p->items || !p->n_items );
+
+    if( func )
+        tr_ptrArrayForeach( p, func );
+
+    tr_free( p->items );
+
+    memset( p, ~0, sizeof( tr_ptrArray ) );
+}
 
 tr_ptrArray*
 tr_ptrArrayNew( void )
 {
-    tr_ptrArray * p;
-
-    p = tr_new( tr_ptrArray, 1 );
-    p->n_items = 0;
-    p->n_alloc = 0;
-    p->items = NULL;
-
+    tr_ptrArray * p = tr_new( tr_ptrArray, 1 );
+    *p = TR_PTR_ARRAY_INIT;
     return p;
 }
@@ -70 +74 @@
                  PtrArrayForeachFunc func )
 {
-    assert( t );
-    assert( t->items || !t->n_items );
-
-    if( func )
-        tr_ptrArrayForeach( t, func );
-
-    tr_free( t->items );
+    tr_ptrArrayDestruct( t, func );
     tr_free( t );
 }

trunk/libtransmission/ptrarray.h

@@ -33 +33 @@
  * A simple pointer array that resizes itself dynamically.
  */
-typedef struct tr_ptrArray tr_ptrArray;
+typedef struct tr_ptrArray
+{
+    void ** items;
+    int     n_items;
+    int     n_alloc;
+}
+tr_ptrArray;
+
+#define TR_PTR_ARRAY_DATA( A ) ((A)->items)
+#define TR_PTR_ARRAY_LENGTH( A ) ((A)->n_items)
 
 typedef void ( *PtrArrayForeachFunc )( void * );
+
+extern const tr_ptrArray TR_PTR_ARRAY_INIT;
+
+void          tr_ptrArrayDestruct( tr_ptrArray*, PtrArrayForeachFunc func );
 
 tr_ptrArray * tr_ptrArrayNew( void );

trunk/libtransmission/torrent.c

@@ -1842 +1842 @@
         char * tmp;
         tr_ptrArrayInsertSorted( dirtyFolders, tr_strdup( dir ), vstrcmp );
+
         tmp = tr_dirname( dir );
         tr_free( dir );
@@ -1896 +1897 @@
     char ** s;
     tr_file_index_t f;
-    tr_ptrArray * torrentFiles = tr_ptrArrayNew( );
-    tr_ptrArray * folders = tr_ptrArrayNew( );
-    tr_ptrArray * dirtyFolders = tr_ptrArrayNew( ); /* dirty == contains non-torrent files */
+    tr_ptrArray torrentFiles = TR_PTR_ARRAY_INIT;
+    tr_ptrArray folders      = TR_PTR_ARRAY_INIT;
+    tr_ptrArray dirtyFolders = TR_PTR_ARRAY_INIT; /* dirty == contains non-torrent files */
 
     const char * firstFile = tor->info.files[0].name;
@@ -1906 +1907 @@
 
     for( f=0; f<tor->info.fileCount; ++f )
-        tr_ptrArrayInsertSorted( torrentFiles, tor->info.files[f].name, vstrcmp );
+        tr_ptrArrayInsertSorted( &torrentFiles, tor->info.files[f].name, vstrcmp );
 
     /* build the set of folders and dirtyFolders */
-    walkLocalData( tor, root, root, NULL, torrentFiles, folders, dirtyFolders );
+    walkLocalData( tor, root, root, NULL, &torrentFiles, &folders, &dirtyFolders );
 
     /* close all the files because we're about to delete them */
@@ -1919 +1920 @@
 
     /* try to remove entire folders first, so that the recycle bin will be tidy */
-    s = (char**) tr_ptrArrayPeek( folders, &n );
+    s = (char**) tr_ptrArrayPeek( &folders, &n );
     for( i=0; i<n; ++i )
-        if( tr_ptrArrayFindSorted( dirtyFolders, s[i], vstrcmp ) == NULL )
+        if( tr_ptrArrayFindSorted( &dirtyFolders, s[i], vstrcmp ) == NULL )
             fileFunc( s[i] );
 
-    /* now blow away any remaining torrent files, such torrent files in dirty folders */
+    /* now blow away any remaining torrent files, such as torrent files in dirty folders */
     for( f=0; f<tor->info.fileCount; ++f ) {
         char * path = tr_buildPath( tor->downloadDir, tor->info.files[f].name, NULL );
@@ -1935 +1936 @@
      * won't prevent the upper folders from being deleted */
     {
-        tr_ptrArray * cleanFolders = tr_ptrArrayNew( );
-        s = (char**) tr_ptrArrayPeek( folders, &n );
+        tr_ptrArray cleanFolders = TR_PTR_ARRAY_INIT;
+        s = (char**) tr_ptrArrayPeek( &folders, &n );
         for( i=0; i<n; ++i )
-            if( tr_ptrArrayFindSorted( dirtyFolders, s[i], vstrcmp ) == NULL )
-                tr_ptrArrayInsertSorted( cleanFolders, s[i], compareLongestFirst );
-        s = (char**) tr_ptrArrayPeek( cleanFolders, &n );
+            if( tr_ptrArrayFindSorted( &dirtyFolders, s[i], vstrcmp ) == NULL )
+                tr_ptrArrayInsertSorted( &cleanFolders, s[i], compareLongestFirst );
+        s = (char**) tr_ptrArrayPeek( &cleanFolders, &n );
         for( i=0; i<n; ++i )
             fileFunc( s[i] );
-        tr_ptrArrayFree( cleanFolders, NULL );
+        tr_ptrArrayDestruct( &cleanFolders, NULL );
     }
 
     /* cleanup */
-    tr_ptrArrayFree( dirtyFolders, tr_free );
-    tr_ptrArrayFree( folders, tr_free );
-    tr_ptrArrayFree( torrentFiles, NULL );
+    tr_ptrArrayDestruct( &dirtyFolders, tr_free );
+    tr_ptrArrayDestruct( &folders, tr_free );
+    tr_ptrArrayDestruct( &torrentFiles, NULL );
     tr_free( root );
     tr_free( tmp );
@@ -1963 +1964 @@
         deleteLocalData( tor, fileFunc );
     else {
+        /* torrent only has one file */
         char * path = tr_buildPath( tor->downloadDir, tor->info.files[0].name, NULL );
+        tr_fdFileClose( path );
         fileFunc( path );
         tr_free( path );