Changeset 7578

Timestamp:

Jan 2, 2009, 5:01:55 PM (12 years ago)

Author:

charles

Message:

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

Location:

trunk/libtransmission

Files:

• completion.c (modified) (10 diffs)
• completion.h (modified) (3 diffs)
• fastresume.c (modified) (2 diffs)
• peer-mgr.c (modified) (7 diffs)
• peer-msgs.c (modified) (8 diffs)
• resume.c (modified) (2 diffs)
• torrent.c (modified) (15 diffs)
• torrent.h (modified) (4 diffs)
• tracker.c (modified) (2 diffs)
• transmission.h (modified) (1 diff)
• verify.c (modified) (1 diff)

trunk/libtransmission/completion.c

@@ -31 +31 @@
 #include "utils.h"
 
-struct tr_completion
-{
-    tr_bool  sizeWhenDoneIsDirty;
-    tr_bool  haveValidIsDirty;
-
-    tr_torrent *    tor;
-
-    /* do we have this block? */
-    tr_bitfield    blockBitfield;
-
-    /* do we have this piece? */
-    tr_bitfield    pieceBitfield;
-
-    /* a block is complete if and only if we have it */
-    uint16_t *  completeBlocks;
-
-    /* number of bytes we'll have when done downloading. [0..info.totalSize]
-       DON'T access this directly; it's a lazy field.
-       use tr_cpSizeWhenDone() instead! */
-    uint64_t    sizeWhenDoneLazy;
-
-    /* number of bytes we'll have when done downloading. [0..info.totalSize]
-       DON'T access this directly; it's a lazy field.
-       use tr_cpHaveValid() instead! */
-    uint64_t    haveValidLazy;
-
-    /* number of bytes we want or have now. [0..sizeWhenDone] */
-    uint64_t    sizeNow;
-};
-
 static void
 tr_cpReset( tr_completion * cp )
@@ -74 +44 @@
 
 tr_completion *
-tr_cpInit( tr_torrent * tor )
-{
-    tr_completion * cp  = tr_new( tr_completion, 1 );
-
-    cp->tor             = tor;
+tr_cpConstruct( tr_completion * cp, tr_torrent * tor )
+{
+    cp->tor = tor;
     cp->completeBlocks  = tr_new( uint16_t, tor->info.pieceCount );
     tr_bitfieldConstruct( &cp->blockBitfield, tor->blockCount );
@@ -86 +54 @@
 }
 
-void
-tr_cpClose( tr_completion * cp )
+tr_completion*
+tr_cpDestruct( tr_completion * cp )
 {
     tr_free( cp->completeBlocks );
     tr_bitfieldDestruct( &cp->pieceBitfield );
     tr_bitfieldDestruct( &cp->blockBitfield );
-    tr_free        ( cp );
+    return cp;
 }
 
@@ -146 +114 @@
 }
 
-int
-tr_cpPieceIsComplete( const tr_completion * cp,
-                      tr_piece_index_t      piece )
-{
-    return cp->completeBlocks[piece] == tr_torPieceCountBlocks( cp->tor, piece );
-}
-
-const tr_bitfield *
-tr_cpPieceBitfield( const tr_completion * cp )
-{
-    return &cp->pieceBitfield;
-}
-
 void
 tr_cpPieceAdd( tr_completion *  cp,
@@ -198 +153 @@
 }
 
-int
-tr_cpBlockIsComplete( const tr_completion * cp,
-                      tr_block_index_t      block )
-{
-    return tr_bitfieldHas( &cp->blockBitfield, block );
-}
-
 void
 tr_cpBlockAdd( tr_completion *  cp,
@@ -229 +177 @@
         cp->sizeWhenDoneIsDirty = 1;
     }
-}
-
-const tr_bitfield *
-tr_cpBlockBitfield( const tr_completion * cp )
-{
-    assert( cp );
-    assert( cp->blockBitfield.bits );
-    assert( cp->blockBitfield.bitCount );
-
-    return &cp->blockBitfield;
 }
 
@@ -263 +201 @@
 }
 
-int
-tr_cpMissingBlocksInPiece( const tr_completion * cp,
-                           tr_piece_index_t      piece )
-{
-    return tr_torPieceCountBlocks( cp->tor, piece ) - cp->completeBlocks[piece];
-}
-
 /***
 ****
 ***/
-
-float
-tr_cpPercentDone( const tr_completion * cp )
-{
-    return tr_getRatio( cp->sizeNow, tr_cpSizeWhenDone( cp ) );
-}
-
-float
-tr_cpPercentComplete( const tr_completion * cp )
-{
-    return tr_getRatio( cp->sizeNow, cp->tor->info.totalSize );
-}
-
-uint64_t
-tr_cpLeftUntilDone( const tr_completion * cp )
-{
-    return tr_cpSizeWhenDone( cp ) - cp->sizeNow;
-}
-
-uint64_t
-tr_cpLeftUntilComplete( const tr_completion * cp )
-{
-    return cp->tor->info.totalSize - cp->sizeNow;
-}
 
 tr_completeness
@@ -339 +246 @@
 }
 
-uint64_t
-tr_cpHaveTotal( const tr_completion * cp )
-{
-    return cp->sizeNow;
-}
-
 void
 tr_cpGetAmountDone( const tr_completion * cp,
@@ -353 +254 @@
     const tr_torrent * tor = cp->tor;
     const float        interval = tor->info.pieceCount / (float)tabCount;
-    const int          isSeed = tr_cpGetStatus ( tor->completion ) == TR_SEED;
+    const int          isSeed = tr_cpGetStatus( cp ) == TR_SEED;
 
     for( i = 0; i < tabCount; ++i )
@@ -368 +269 @@
     }
 }
+
+int
+tr_cpMissingBlocksInPiece( const tr_completion * cp, tr_piece_index_t piece )
+{
+    return tr_torPieceCountBlocks( cp->tor, piece ) - cp->completeBlocks[piece];
+}
+
+
+int
+tr_cpPieceIsComplete( const tr_completion * cp, tr_piece_index_t piece )
+{
+    return cp->completeBlocks[piece] == tr_torPieceCountBlocks( cp->tor, piece );
+}

trunk/libtransmission/completion.h

@@ -30 +30 @@
 #endif
 
+#include <assert.h>
+
 #include "transmission.h"
+#include "utils.h" /* tr_bitfield */
 
-struct tr_bitfield;
-typedef struct tr_completion tr_completion;
+typedef struct tr_completion
+{
+    tr_bool  sizeWhenDoneIsDirty;
+    tr_bool  haveValidIsDirty;
 
-tr_completion *            tr_cpInit( tr_torrent * );
+    tr_torrent *    tor;
 
-void                       tr_cpClose( tr_completion * );
+    /* do we have this block? */
+    tr_bitfield    blockBitfield;
 
-/* General */
+    /* do we have this piece? */
+    tr_bitfield    pieceBitfield;
+
+    /* a block is complete if and only if we have it */
+    uint16_t *  completeBlocks;
+
+    /* number of bytes we'll have when done downloading. [0..info.totalSize]
+       DON'T access this directly; it's a lazy field.
+       use tr_cpSizeWhenDone() instead! */
+    uint64_t    sizeWhenDoneLazy;
+
+    /* number of bytes we'll have when done downloading. [0..info.totalSize]
+       DON'T access this directly; it's a lazy field.
+       use tr_cpHaveValid() instead! */
+    uint64_t    haveValidLazy;
+
+    /* number of bytes we want or have now. [0..sizeWhenDone] */
+    uint64_t    sizeNow;
+}
+tr_completion;
+
+/**
+*** Life Cycle
+**/
+
+tr_completion * tr_cpConstruct( tr_completion *, tr_torrent * );
+
+tr_completion * tr_cpDestruct( tr_completion * );
+
+static inline tr_completion* tr_cpNew( tr_torrent * tor )
+{
+    return tr_cpConstruct( tr_new0( tr_completion, 1 ), tor );
+}
+
+static inline void tr_cpFree( tr_completion * cp )
+{
+    tr_free( tr_cpDestruct( cp ) );
+}
+
+/**
+*** General
+**/
 
 tr_completeness            tr_cpGetStatus( const tr_completion * );
 
-extern inline uint64_t     tr_cpHaveTotal( const tr_completion * );
-
 uint64_t                   tr_cpHaveValid( const tr_completion * );
 
-extern inline uint64_t     tr_cpLeftUntilComplete( const tr_completion * );
-
-extern inline uint64_t     tr_cpLeftUntilDone( const tr_completion * );
-
 uint64_t                   tr_cpSizeWhenDone( const tr_completion * );
-
-extern inline float        tr_cpPercentComplete( const tr_completion * );
-
-extern inline float        tr_cpPercentDone( const tr_completion * );
 
 void                       tr_cpInvalidateDND( tr_completion * );
@@ -63 +100 @@
                                                int                     tabCount );
 
-/* Pieces */
-extern inline int          tr_cpPieceIsComplete( const tr_completion * completion,
-                                                 tr_piece_index_t      piece );
+static inline uint64_t tr_cpHaveTotal( const tr_completion * cp )
+{
+    return cp->sizeNow;
+}
 
-void                       tr_cpPieceAdd( tr_completion    * completion,
-                                          tr_piece_index_t   piece );
+static inline uint64_t tr_cpLeftUntilComplete( const tr_completion * cp )
+{
+    return tr_torrentInfo(cp->tor)->totalSize - cp->sizeNow;
+}
 
-void                       tr_cpPieceRem( tr_completion     * completion,
-                                           tr_piece_index_t   piece );
+static inline uint64_t tr_cpLeftUntilDone( const tr_completion * cp )
+{
+    return tr_cpSizeWhenDone( cp ) - cp->sizeNow;
+}
 
-/* Blocks */
-extern inline int          tr_cpBlockIsComplete( const tr_completion * completion,
-                                                 tr_block_index_t block );
+static inline float tr_cpPercentComplete( const tr_completion * cp )
+{
+    return tr_getRatio( cp->sizeNow, tr_torrentInfo(cp->tor)->totalSize );
+}
+
+static inline float tr_cpPercentDone( const tr_completion * cp )
+{
+    return tr_getRatio( cp->sizeNow, tr_cpSizeWhenDone( cp ) );
+}
+
+/**
+*** Pieces
+**/
+
+int tr_cpMissingBlocksInPiece( const tr_completion  * cp,
+                               tr_piece_index_t       piece );
+
+int    tr_cpPieceIsComplete( const tr_completion * cp,
+                             tr_piece_index_t      piece );
+
+void   tr_cpPieceAdd( tr_completion    * completion,
+                      tr_piece_index_t   piece );
+
+void   tr_cpPieceRem( tr_completion     * completion,
+                      tr_piece_index_t   piece );
+
+/**
+*** Blocks
+**/
+
+static inline int tr_cpBlockIsComplete( const tr_completion * cp, tr_block_index_t block ) {
+    return tr_bitfieldHas( &cp->blockBitfield, block );
+}
 
 void                       tr_cpBlockAdd( tr_completion * completion,
@@ -83 +155 @@
                                                   struct tr_bitfield * blocks );
 
-extern inline int          tr_cpMissingBlocksInPiece( const tr_completion  * completion,
-                                                      tr_piece_index_t       piece );
+/***
+****
+***/
 
+static inline const struct tr_bitfield * tr_cpPieceBitfield( const tr_completion * cp ) {
+    return &cp->pieceBitfield;
+}
 
-extern inline const struct tr_bitfield *
-                           tr_cpPieceBitfield( const tr_completion* );
-
-extern inline const struct tr_bitfield *
-                           tr_cpBlockBitfield( const tr_completion * );
+static inline const struct tr_bitfield * tr_cpBlockBitfield( const tr_completion * cp ) {
+    assert( cp );
+    assert( cp->blockBitfield.bits );
+    assert( cp->blockBitfield.bitCount );
+    return &cp->blockBitfield;
+}
 
 #endif

trunk/libtransmission/fastresume.c

@@ -283 +283 @@
         bitfield.bitCount = bitfield.byteCount * 8;
         bitfield.bits = (uint8_t*) walk;
-        if( tr_cpBlockBitfieldSet( tor->completion, &bitfield ) )
+        if( tr_cpBlockBitfieldSet( &tor->completion, &bitfield ) )
             ret = TR_FR_PROGRESS;
         else {
@@ -297 +297 @@
         for( i = 0; i < tor->info.pieceCount; ++i )
             if( !tr_torrentIsPieceChecked( tor, i ) )
-                tr_cpPieceRem( tor->completion, i );
+                tr_cpPieceRem( &tor->completion, i );
     }
 

trunk/libtransmission/peer-mgr.c

@@ -629 +629 @@
     for( i = 0; i < inf->pieceCount; ++i )
         if( !tor->info.pieces[i].dnd
-                && !tr_cpPieceIsComplete( tor->completion, i ) )
+                && !tr_cpPieceIsComplete( &tor->completion, i ) )
             pool[poolSize++] = i;
 
@@ -650 +650 @@
             setme->pendingRequestCount = getPieceRequests( t, piece );
             setme->missingBlockCount
-                         = tr_cpMissingBlocksInPiece( tor->completion, piece );
+                         = tr_cpMissingBlocksInPiece( &tor->completion, piece );
 
             for( k = 0; k < peerCount; ++k )
@@ -712 +712 @@
         i->blockIndex = 0;
         for( block=b; block!=e; ++block )
-            if( !tr_cpBlockIsComplete( tor->completion, block ) )
+            if( !tr_cpBlockIsComplete( &tor->completion, block ) )
                 i->blocks[i->blockCount++] = block;
     }
@@ -1082 +1082 @@
             tr_block_index_t block = _tr_block( tor, e->pieceIndex, e->offset );
 
-            tr_cpBlockAdd( tor->completion, block );
+            tr_cpBlockAdd( &tor->completion, block );
             decrementPieceRequests( t, e->pieceIndex );
 
             broadcastGotBlock( t, e->pieceIndex, e->offset, e->length );
 
-            if( tr_cpPieceIsComplete( tor->completion, e->pieceIndex ) )
+            if( tr_cpPieceIsComplete( &tor->completion, e->pieceIndex ) )
             {
                 const tr_piece_index_t p = e->pieceIndex;
@@ -1664 +1664 @@
     tor = t->tor;
     interval = tor->info.pieceCount / (float)tabCount;
-    isSeed = tor && ( tr_cpGetStatus ( tor->completion ) == TR_SEED );
+    isSeed = tor && ( tr_cpGetStatus ( &tor->completion ) == TR_SEED );
     peers = (const tr_peer **) TR_PTR_ARRAY_DATA( &t->peers );
     peerCount = TR_PTR_ARRAY_LENGTH( &t->peers );
@@ -1674 +1674 @@
         const int piece = i * interval;
 
-        if( isSeed || tr_cpPieceIsComplete( tor->completion, piece ) )
+        if( isSeed || tr_cpPieceIsComplete( &tor->completion, piece ) )
             tab[i] = -1;
         else if( peerCount ) {
@@ -2075 +2075 @@
         if( atom->flags & ADDED_F_SEED_FLAG )
             peerHasEverything = TRUE;
-        else if( peer->progress < tr_cpPercentDone( tor->completion ) )
+        else if( peer->progress < tr_cpPercentDone( &tor->completion ) )
             peerHasEverything = FALSE;
         else {
-            tr_bitfield * tmp = tr_bitfieldDup( tr_cpPieceBitfield( tor->completion ) );
+            tr_bitfield * tmp = tr_bitfieldDup( tr_cpPieceBitfield( &tor->completion ) );
             tr_bitfieldDifference( tmp, peer->have );
             peerHasEverything = tr_bitfieldCountTrueBits( tmp ) == 0;

trunk/libtransmission/peer-msgs.c

@@ -718 +718 @@
 
     return ( !torrent->info.pieces[piece].dnd )                 /* we want it */
-          && ( !tr_cpPieceIsComplete( torrent->completion, piece ) ) /* !have */
+          && ( !tr_cpPieceIsComplete( &torrent->completion, piece ) ) /* !have */
           && ( tr_bitfieldHas( msgs->peer->have, piece ) );    /* peer has it */
 }
@@ -738 +738 @@
 
     torrent = msgs->torrent;
-    bitfield = tr_cpPieceBitfield( torrent->completion );
+    bitfield = tr_cpPieceBitfield( &torrent->completion );
 
     if( !msgs->peer->have )
@@ -927 +927 @@
         /* don't ask for it if we've already got it... this block may have
          * come in from a different peer after we cancelled a request for it */
-        if( !tr_cpBlockIsComplete( msgs->torrent->completion, block ) )
+        if( !tr_cpBlockIsComplete( &msgs->torrent->completion, block ) )
         {
             protocolSendRequest( msgs, &req );
@@ -1292 +1292 @@
     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 clientHasPiece = reqIsValid && tr_cpPieceIsComplete( &msgs->torrent->completion, req->index );
     const int peerIsChoked = msgs->peer->peerIsChoked;
 
@@ -1641 +1641 @@
     **/
 
-    if( tr_cpBlockIsComplete( tor->completion, block ) ) {
+    if( tr_cpBlockIsComplete( &tor->completion, block ) ) {
         dbgmsg( msgs, "we have this block already..." );
         clientGotUnwantedBlock( msgs, req );
@@ -1753 +1753 @@
     {
         if( requestIsValid( msgs, &req )
-            && tr_cpPieceIsComplete( msgs->torrent->completion, req.index ) )
+            && tr_cpPieceIsComplete( &msgs->torrent->completion, req.index ) )
         {
             int err;
@@ -1850 +1850 @@
     size_t            lazyCount = 0;
 
-    field = tr_bitfieldDup( tr_cpPieceBitfield( msgs->torrent->completion ) );
+    field = tr_bitfieldDup( tr_cpPieceBitfield( &msgs->torrent->completion ) );
 
     if( tr_sessionIsLazyBitfieldEnabled( msgs->session ) )
@@ -1899 +1899 @@
     const tr_bool fext = tr_peerIoSupportsFEXT( msgs->peer->io );
 
-    if( fext && ( tr_cpGetStatus( msgs->torrent->completion ) == TR_SEED ) )
+    if( fext && ( tr_cpGetStatus( &msgs->torrent->completion ) == TR_SEED ) )
     {
         protocolSendHaveAll( msgs );
     }
-    else if( fext && ( tr_cpHaveValid( msgs->torrent->completion ) == 0 ) )
+    else if( fext && ( tr_cpHaveValid( &msgs->torrent->completion ) == 0 ) )
     {
         protocolSendHaveNone( msgs );

trunk/libtransmission/resume.c

@@ -309 +309 @@
 
     /* add the bitfield */
-    bitfield = tr_cpBlockBitfield( tor->completion );
+    bitfield = tr_cpBlockBitfield( &tor->completion );
     tr_bencDictAddRaw( p, KEY_PROGRESS_BITFIELD,
                        bitfield->bits, bitfield->byteCount );
@@ -377 +377 @@
             tmp.bitCount = tmp.byteCount * 8;
             tmp.bits = (uint8_t*) raw;
-            if( !tr_cpBlockBitfieldSet( tor->completion, &tmp ) )
+            if( !tr_cpBlockBitfieldSet( &tor->completion, &tmp ) )
             {
                 tr_torrentUncheck( tor );

trunk/libtransmission/torrent.c

@@ -88 +88 @@
 }
 
-tr_bool
-tr_torrentExists( const tr_session * session, const uint8_t *   torrentHash )
-{
-    return tr_torrentFindFromHash( (tr_session*)session, torrentHash ) != NULL;
-}
-
 tr_torrent*
 tr_torrentFindFromHash( tr_session * session, const uint8_t * torrentHash )
@@ -119 +113 @@
 
     return NULL;
-}
-
-/***
-****  LOCKS
-***/
-
-void
-tr_torrentLock( const tr_torrent * tor )
-{
-    tr_globalLock( tor->session );
-}
-
-void
-tr_torrentUnlock( const tr_torrent * tor )
-{
-    tr_globalUnlock( tor->session );
 }
 
@@ -520 +498 @@
     assert( t == (uint64_t)tor->blockCount );
 
-    tor->completion = tr_cpInit( tor );
+    tr_cpConstruct( &tor->completion, tor );
 
     tr_torrentInitFilePieces( tor );
@@ -557 +535 @@
     }
 
-    tor->completeness = tr_cpGetStatus( tor->completion );
+    tor->completeness = tr_cpGetStatus( &tor->completion );
 
     tor->tracker = tr_trackerNew( tor );
@@ -803 +781 @@
     usableSeeds += tor->info.webseedCount;
 
-    s->percentComplete = tr_cpPercentComplete ( tor->completion );
-
-    s->percentDone = tr_cpPercentDone( tor->completion );
-    s->leftUntilDone = tr_cpLeftUntilDone( tor->completion );
-    s->sizeWhenDone = tr_cpSizeWhenDone( tor->completion );
+    s->percentComplete = tr_cpPercentComplete ( &tor->completion );
+
+    s->percentDone   = tr_cpPercentDone  ( &tor->completion );
+    s->leftUntilDone = tr_cpLeftUntilDone( &tor->completion );
+    s->sizeWhenDone  = tr_cpSizeWhenDone ( &tor->completion );
 
     s->recheckProgress = s->activity == TR_STATUS_CHECK
@@ -825 +803 @@
     s->downloadedEver  = tor->downloadedCur + tor->downloadedPrev;
     s->uploadedEver    = tor->uploadedCur   + tor->uploadedPrev;
-    s->haveValid       = tr_cpHaveValid( tor->completion );
-    s->haveUnchecked   = tr_cpHaveTotal( tor->completion ) - s->haveValid;
+    s->haveValid       = tr_cpHaveValid( &tor->completion );
+    s->haveUnchecked   = tr_cpHaveTotal( &tor->completion ) - s->haveValid;
 
 
@@ -847 +825 @@
         for( i = 0; i < tor->info.pieceCount; ++i )
             if( !tor->info.pieces[i].dnd && tr_bitfieldHas( peerPieces, i ) )
-                s->desiredAvailable += tr_cpMissingBlocksInPiece(
-                    tor->completion, i );
+                s->desiredAvailable += tr_cpMissingBlocksInPiece( &tor->completion, i );
         s->desiredAvailable *= tor->blockSize;
         tr_bitfieldFree( peerPieces );
@@ -904 +881 @@
     if( firstBlock == lastBlock )
     {
-        if( tr_cpBlockIsComplete( tor->completion, firstBlock ) )
+        if( tr_cpBlockIsComplete( &tor->completion, firstBlock ) )
             haveBytes += lastBlockOffset + 1 - firstBlockOffset;
     }
@@ -911 +888 @@
         tr_block_index_t i;
 
-        if( tr_cpBlockIsComplete( tor->completion, firstBlock ) )
+        if( tr_cpBlockIsComplete( &tor->completion, firstBlock ) )
             haveBytes += tor->blockSize - firstBlockOffset;
 
         for( i = firstBlock + 1; i < lastBlock; ++i )
-            if( tr_cpBlockIsComplete( tor->completion, i ) )
+            if( tr_cpBlockIsComplete( &tor->completion, i ) )
                 haveBytes += tor->blockSize;
 
-        if( tr_cpBlockIsComplete( tor->completion, lastBlock ) )
+        if( tr_cpBlockIsComplete( &tor->completion, lastBlock ) )
             haveBytes += lastBlockOffset + 1;
     }
@@ -1001 +978 @@
 {
     tr_torrentLock( tor );
-    tr_cpGetAmountDone( tor->completion, tab, size );
+    tr_cpGetAmountDone( &tor->completion, tab, size );
     tr_torrentUnlock( tor );
 }
@@ -1031 +1008 @@
 
     if( has )
-        tr_cpPieceAdd( tor->completion, pieceIndex );
+        tr_cpPieceAdd( &tor->completion, pieceIndex );
     else
-        tr_cpPieceRem( tor->completion, pieceIndex );
+        tr_cpPieceRem( &tor->completion, pieceIndex );
 
     tr_torrentUnlock( tor );
@@ -1056 +1033 @@
     tr_peerMgrRemoveTorrent( session->peerMgr, tor->info.hash );
 
-    tr_cpClose( tor->completion );
+    tr_cpDestruct( &tor->completion );
 
     tr_rcClose( tor->swarmSpeed );
@@ -1103 +1080 @@
     *tor->errorString = '\0';
     tr_torrentResetTransferStats( tor );
-    tor->completeness = tr_cpGetStatus( tor->completion );
+    tor->completeness = tr_cpGetStatus( &tor->completion );
     tr_torrentSaveResume( tor );
     tor->startDate = time( NULL );
@@ -1307 +1284 @@
     tr_torrentLock( tor );
 
-    completeness = tr_cpGetStatus( tor->completion );
+    completeness = tr_cpGetStatus( &tor->completion );
 
     if( completeness != tor->completeness )
@@ -1500 +1477 @@
     for( i = 0; i < fileCount; ++i )
         setFileDND( tor, files[i], doDownload );
-    tr_cpInvalidateDND ( tor->completion );
+    tr_cpInvalidateDND ( &tor->completion );
 
     tr_torrentUnlock( tor );

trunk/libtransmission/torrent.h

@@ -27 +27 @@
 #endif
 
-#include "utils.h" /* tr_bitfield */
-
 #ifndef TR_TORRENT_H
 #define TR_TORRENT_H 1
+
+#include "completion.h" /* tr_completion */
+#include "session.h" /* tr_globalLock(), tr_globalUnlock() */
+#include "utils.h" /* tr_bitfield */
 
 struct tr_bandwidth;
@@ -64 +66 @@
                                    tr_bool          has );
 
-extern inline void
-            tr_torrentLock( const tr_torrent * session );
-
-extern inline void
-            tr_torrentUnlock( const tr_torrent * session );
-
 tr_bool     tr_torrentIsSeed( const tr_torrent * session );
 
 void        tr_torrentChangeMyPort( tr_torrent * session );
-
-extern inline tr_bool
-            tr_torrentExists( const tr_session * session,
-                              const uint8_t    * hash );
 
 tr_torrent* tr_torrentFindFromId( tr_session * session,
@@ -184 +176 @@
     uint32_t                   blockCountInLastPiece;
 
-    struct tr_completion *     completion;
+    struct tr_completion       completion;
 
     struct tr_bitfield         checkedPieces;
@@ -262 +254 @@
 }
 
+static inline void
+tr_torrentLock( const tr_torrent * tor )
+{
+    tr_globalLock( tor->session );
+}
+
+static inline void
+tr_torrentUnlock( const tr_torrent * tor )
+{
+    tr_globalUnlock( tor->session );
+}
+
+static inline tr_bool
+tr_torrentExists( const tr_session * session, const uint8_t *   torrentHash )
+{
+    return tr_torrentFindFromHash( (tr_session*)session, torrentHash ) != NULL;
+}
+
+
 #endif

trunk/libtransmission/tracker.c

@@ -768 +768 @@
                               torrent->downloadedCur,
                               torrent->corruptCur,
-                              tr_cpLeftUntilComplete( torrent->completion ),
+                              tr_cpLeftUntilComplete( &torrent->completion ),
                               numwant,
                               t->key_param );
@@ -794 +794 @@
     /* BEP 21: In order to tell the tracker that a peer is a partial seed, it MUST send
      * an event=paused parameter in every announce while it is a partial seed. */
-    if( tr_cpGetStatus( torrent->completion ) == TR_PARTIAL_SEED )
+    if( tr_cpGetStatus( &torrent->completion ) == TR_PARTIAL_SEED )
         reqtype = TR_REQ_PAUSED;
 

trunk/libtransmission/transmission.h

@@ -827 +827 @@
  * tr_info.hashString.
  */
-extern inline int tr_torrentId( const tr_torrent * torrent );
+int tr_torrentId( const tr_torrent * torrent );
 
 /****

trunk/libtransmission/verify.c

@@ -87 +87 @@
         else if( !tr_torrentIsPieceChecked( tor, i ) )
         {
-            const int wasComplete = tr_cpPieceIsComplete( tor->completion, i );
+            const int wasComplete = tr_cpPieceIsComplete( &tor->completion, i );
 
             if( tr_ioTestPiece( tor, i, buffer, buflen ) ) /* yay */