Changeset 12248

Timestamp:

Mar 28, 2011, 4:31:05 PM (12 years ago)

Author:

jordan

Message:

(trunk libT) break the mac build and introduce new crashes.

This is partially to address #4145 "Downloads stuck at 100%" by refactoring the bitset, bitfield, and tr_completion; however, the ripple effect is larger than usual so things may get worse in the short term before getting better.

livings124: to fix the mac build, remove bitset.[ch] from xcode

Location:

trunk/libtransmission

Files:

• Makefile.am (modified) (2 diffs)
• bitfield.c (modified) (4 diffs)
• bitfield.h (modified) (3 diffs)
• bitset.c (deleted)
• bitset.h (deleted)
• completion.c (modified) (14 diffs)
• completion.h (modified) (6 diffs)
• peer-io.c (modified) (4 diffs)
• peer-mgr.c (modified) (24 diffs)
• peer-mgr.h (modified) (4 diffs)
• peer-msgs.c (modified) (10 diffs)
• resume.c (modified) (6 diffs)
• rpcimpl.c (modified) (1 diff)
• session.c (modified) (1 diff)
• torrent.c (modified) (5 diffs)
• utils-test.c (modified) (4 diffs)
• webseed.c (modified) (1 diff)

trunk/libtransmission/Makefile.am

@@ -24 +24 @@
     bencode.c \
     bitfield.c \
-    bitset.c \
     blocklist.c \
     cache.c \
@@ -76 +75 @@
     bencode.h \
     bitfield.h \
-    bitset.h \
     blocklist.h \
     cache.h \

trunk/libtransmission/bitfield.c

@@ -16 +16 @@
 #include "transmission.h"
 #include "bitfield.h"
-#include "bitset.h"
 #include "utils.h" /* tr_new0() */
 
-const tr_bitfield TR_BITFIELD_INIT = { NULL, 0, 0 };
-
-tr_bitfield*
-tr_bitfieldConstruct( tr_bitfield * b, size_t bitCount )
-{
-    b->bitCount = bitCount;
-    b->byteCount = ( bitCount + 7u ) / 8u;
-    b->bits = tr_new0( uint8_t, b->byteCount );
-    return b;
-}
-
-tr_bitfield*
-tr_bitfieldDestruct( tr_bitfield * b )
-{
-    if( b )
-        tr_free( b->bits );
-    return b;
-}
-
-tr_bitfield*
-tr_bitfieldNew( size_t bitCount )
-{
-    return tr_bitfieldConstruct( tr_new( tr_bitfield, 1 ), bitCount );
-}
-
-void
-tr_bitfieldFree( tr_bitfield * b )
-{
-    tr_free( tr_bitfieldDestruct( b ) );
-}
-
-void
-tr_bitfieldClear( tr_bitfield * bitfield )
-{
-    memset( bitfield->bits, 0, bitfield->byteCount );
-}
-
-int
-tr_bitfieldAdd( tr_bitfield * bitfield,
-                size_t        nth )
-{
-    assert( bitfield );
-    assert( bitfield->bits );
-
-    if( nth >= bitfield->bitCount )
-        return -1;
-
-    bitfield->bits[nth >> 3u] |= ( 0x80 >> ( nth & 7u ) );
-    return 0;
-}
-
-/* Sets bit range [begin, end) to 1 */
-int
-tr_bitfieldAddRange( tr_bitfield * b,
-                     size_t        begin,
-                     size_t        end )
-{
-    size_t        sb, eb;
-    unsigned char sm, em;
-
-    end--;
-
-    if( ( end >= b->bitCount ) || ( begin > end ) )
-        return -1;
-
-    sb = begin >> 3;
-    sm = ~( 0xff << ( 8 - ( begin & 7 ) ) );
-    eb = end >> 3;
-    em = 0xff << ( 7 - ( end & 7 ) );
-
-    if( sb == eb )
-    {
-        b->bits[sb] |= ( sm & em );
-    }
-    else
-    {
-        b->bits[sb] |= sm;
-        b->bits[eb] |= em;
-        if( ++sb < eb )
-            memset ( b->bits + sb, 0xff, eb - sb );
-    }
-
-    return 0;
-}
-
-int
-tr_bitfieldRem( tr_bitfield * bitfield,
-                size_t        nth )
-{
-    assert( bitfield );
-    assert( bitfield->bits );
-
-    if( nth >= bitfield->bitCount )
-        return -1;
-
-    bitfield->bits[nth >> 3u] &= ( 0xff7f >> ( nth & 7u ) );
-    return 0;
-}
-
-/* Clears bit range [begin, end) to 0 */
-int
-tr_bitfieldRemRange( tr_bitfield * b,
-                     size_t        begin,
-                     size_t        end )
-{
-    size_t        sb, eb;
-    unsigned char sm, em;
-
-    end--;
-
-    if( ( end >= b->bitCount ) || ( begin > end ) )
-        return -1;
-
-    sb = begin >> 3;
-    sm = 0xff << ( 8 - ( begin & 7 ) );
-    eb = end >> 3;
-    em = ~( 0xff << ( 7 - ( end & 7 ) ) );
-
-    if( sb == eb )
-    {
-        b->bits[sb] &= ( sm | em );
-    }
-    else
-    {
-        b->bits[sb] &= sm;
-        b->bits[eb] &= em;
-        if( ++sb < eb )
-            memset ( b->bits + sb, 0, eb - sb );
-    }
-
-    return 0;
-}
-
-tr_bitfield*
-tr_bitfieldOr( tr_bitfield * a, const tr_bitfield * b )
-{
-    uint8_t * ait = a->bits;
-    const uint8_t * aend = ait + a->byteCount;
-    const uint8_t * bit = b->bits;
-    const uint8_t * bend = bit + b->byteCount;
-
-    while( ait!=aend && bit!=bend )
-        *ait++ |= *bit++;
-
-    return a;
-}
-
-static const int trueBitCount[256] =
+const tr_bitfield TR_BITFIELD_INIT = { NULL, 0, 0, 0, false, false };
+
+/****
+*****
+****/
+
+static const int8_t trueBitCount[256] =
 {
     0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
@@ -186 +44 @@
 };
 
-size_t
-tr_bitfieldCountTrueBits( const tr_bitfield* b )
-{
-    size_t           ret = 0;
-    const uint8_t *  it, *end;
-
-    if( !b )
-        return 0;
-
-    for( it = b->bits, end = it + b->byteCount; it != end; ++it )
-        ret += trueBitCount[*it];
-
-    return ret;
-}
-
-size_t
-tr_bitfieldCountRange( const tr_bitfield * b, size_t begin, size_t end )
+static size_t
+countRange( const tr_bitfield * b, size_t begin, size_t end )
 {
     size_t ret = 0;
@@ -208 +51 @@
     const int last_byte = ( end - 1 ) >> 3u;
 
-    assert( begin < end );
+    assert( b->bits != NULL );
 
     if( first_byte == last_byte )
@@ -251 +94 @@
     return ret;
 }
+
+size_t
+tr_bitfieldCountRange( const tr_bitfield * b, size_t begin, size_t end )
+{
+    assert( begin < end );
+
+    if( tr_bitfieldHasAll( b ) )
+        return end - begin;
+
+    if( tr_bitfieldHasNone( b ) )
+        return 0;
+
+    return countRange( b, begin, end );
+}
+
+/***
+****
+***/
+
+static bool
+tr_bitfieldIsValid( const tr_bitfield * b )
+{
+    return ( b != NULL )
+        && ( b->bits || ( tr_bitfieldHasAll( b ) || tr_bitfieldHasNone( b )))
+        && ( b->byte_count <= b->bit_count )
+        && ( b->true_count <= b->bit_count )
+        && ( !b->bits || ( b->true_count == countRange( b, 0, b->bit_count )));
+}
+
+void*
+tr_bitfieldGetRaw( const tr_bitfield * b, size_t * byte_count )
+{
+    uint8_t * bits;
+
+    if( b->bits )
+    {
+        bits = tr_memdup( b->bits, b->byte_count );
+    }
+    else
+    {
+        assert( tr_bitfieldHasAll( b ) || tr_bitfieldHasNone( b ) );
+
+        bits = tr_new0( uint8_t, b->byte_count );
+
+        if( tr_bitfieldHasAll( b ) )
+        {
+            uint8_t val = 0xFF;
+            const int n = b->byte_count - 1;
+            memset( bits, val, n );
+            bits[n] = val << (b->byte_count*8 - b->bit_count);
+        }
+    }
+
+    *byte_count = b->byte_count;
+    return bits;
+}
+
+static void
+tr_bitfieldEnsureBitsAlloced( tr_bitfield * b )
+{
+    if( b->bits == NULL )
+        b->bits = tr_bitfieldGetRaw( b, &b->byte_count );
+
+    assert( tr_bitfieldIsValid( b ) );
+}
+
+static void
+tr_bitfieldSetTrueCount( tr_bitfield * b, size_t n )
+{
+    b->true_count = n;
+
+    if( tr_bitfieldHasAll( b ) || tr_bitfieldHasNone( b ) )
+    {
+        tr_free( b->bits );
+        b->bits = NULL;
+    }
+
+    assert( tr_bitfieldIsValid(  b ) );
+}
+
+static void
+tr_bitfieldRebuildTrueCount( tr_bitfield * b )
+{
+    tr_bitfieldSetTrueCount( b, countRange( b, 0, b->bit_count ) );
+}
+
+static void
+tr_bitfieldIncTrueCount( tr_bitfield * b, int i )
+{
+    tr_bitfieldSetTrueCount( b, b->true_count + i );
+}
+
+/****
+*****
+****/
+
+void
+tr_bitfieldConstruct( tr_bitfield * b, size_t bit_count )
+{
+    b->bit_count = bit_count;
+    b->byte_count = ( bit_count + 7u ) / 8u;
+    b->true_count = 0;
+    b->bits = NULL;
+    b->have_all_hint = false;
+    b->have_none_hint = false;
+
+    assert( tr_bitfieldIsValid( b ) );
+}
+
+void
+tr_bitfieldDestruct( tr_bitfield * b )
+{
+    tr_bitfieldSetHasNone( b );
+}
+
+static void
+tr_bitfieldClear( tr_bitfield * b )
+{
+    tr_free( b->bits );
+    b->bits = NULL;
+    b->true_count = 0;
+
+    assert( tr_bitfieldIsValid( b ) );
+}
+
+void
+tr_bitfieldSetHasNone( tr_bitfield * b )
+{
+    tr_bitfieldClear( b );
+    b->have_all_hint = false;
+    b->have_none_hint = true;
+}
+
+void
+tr_bitfieldSetHasAll( tr_bitfield * b )
+{
+    tr_bitfieldClear( b );
+    b->true_count = b->bit_count;
+    b->have_all_hint = true;
+    b->have_none_hint = false;
+}
+
+bool
+tr_bitfieldSetFromBitfield( tr_bitfield * b, const tr_bitfield * src )
+{
+    bool success = true;
+
+    if( tr_bitfieldHasAll( src ) )
+        tr_bitfieldSetHasAll( b );
+    else if( tr_bitfieldHasNone( src ) )
+        tr_bitfieldSetHasNone( b );
+    else
+        success = tr_bitfieldSetRaw( b, src->bits, src->byte_count );
+
+    return success;
+}
+
+bool
+tr_bitfieldSetRaw( tr_bitfield * b, const void * bits, size_t byte_count )
+{
+    const bool success = b->byte_count == byte_count;
+
+    if( success )
+    {
+        tr_bitfieldSetHasNone( b );
+        b->bits = tr_memdup( bits, byte_count );
+        tr_bitfieldRebuildTrueCount( b );
+    }
+
+    return success;
+}
+
+void
+tr_bitfieldAdd( tr_bitfield * b, size_t nth )
+{
+    assert( nth < b->bit_count );
+
+    if( !tr_bitfieldHas( b, nth ) )
+    {
+        tr_bitfieldEnsureBitsAlloced( b );
+        b->bits[nth >> 3u] |= ( 0x80 >> ( nth & 7u ) );
+        tr_bitfieldIncTrueCount( b, 1 );
+    }
+}
+
+/* Sets bit range [begin, end) to 1 */
+void
+tr_bitfieldAddRange( tr_bitfield * b, size_t begin, size_t end )
+{
+    size_t sb, eb;
+    unsigned char sm, em;
+    const size_t diff = (end-begin) - tr_bitfieldCountRange( b, begin, end );
+
+    if( diff == 0 )
+        return;
+
+    end--;
+    if( ( end >= b->bit_count ) || ( begin > end ) )
+        return;
+
+    sb = begin >> 3;
+    sm = ~( 0xff << ( 8 - ( begin & 7 ) ) );
+    eb = end >> 3;
+    em = 0xff << ( 7 - ( end & 7 ) );
+
+    tr_bitfieldEnsureBitsAlloced( b );
+    if( sb == eb )
+    {
+        b->bits[sb] |= ( sm & em );
+    }
+    else
+    {
+        b->bits[sb] |= sm;
+        b->bits[eb] |= em;
+        if( ++sb < eb )
+            memset ( b->bits + sb, 0xff, eb - sb );
+    }
+
+    tr_bitfieldIncTrueCount( b, diff );
+}
+
+void
+tr_bitfieldRem( tr_bitfield * b, size_t nth )
+{
+    assert( tr_bitfieldIsValid( b ) );
+
+    if( !tr_bitfieldHas( b, nth ) )
+    {
+        tr_bitfieldEnsureBitsAlloced( b );
+        b->bits[nth >> 3u] &= ( 0xff7f >> ( nth & 7u ) );
+        tr_bitfieldIncTrueCount( b, -1 );
+    }
+}
+
+/* Clears bit range [begin, end) to 0 */
+void
+tr_bitfieldRemRange( tr_bitfield * b, size_t begin, size_t end )
+{
+    size_t sb, eb;
+    unsigned char sm, em;
+    const size_t diff = tr_bitfieldCountRange( b, begin, end );
+
+    if( !diff )
+        return;
+
+    end--;
+
+    if( ( end >= b->bit_count ) || ( begin > end ) )
+        return;
+
+    sb = begin >> 3;
+    sm = 0xff << ( 8 - ( begin & 7 ) );
+    eb = end >> 3;
+    em = ~( 0xff << ( 7 - ( end & 7 ) ) );
+
+    tr_bitfieldEnsureBitsAlloced( b );
+    if( sb == eb )
+    {
+        b->bits[sb] &= ( sm | em );
+    }
+    else
+    {
+        b->bits[sb] &= sm;
+        b->bits[eb] &= em;
+        if( ++sb < eb )
+            memset ( b->bits + sb, 0, eb - sb );
+    }
+
+    tr_bitfieldIncTrueCount( b, -diff );
+}

trunk/libtransmission/bitfield.h

@@ -18 +18 @@
 #define TR_BITFIELD_H 1
 
+#include <assert.h>
 #include "transmission.h"
 
@@ -24 +25 @@
 {
     uint8_t *  bits;
-    size_t     bitCount;
-    size_t     byteCount;
+    size_t     bit_count;
+    size_t     byte_count;
+    size_t     true_count;
+
+    /* Special cases for when full or empty but we don't know the bitCount.
+       This occurs when a magnet link's peers send have all / have none */
+    bool       have_all_hint;
+    bool       have_none_hint;
 }
 tr_bitfield;
 
+/***
+****  life cycle
+***/
+
 extern const tr_bitfield TR_BITFIELD_INIT;
 
-tr_bitfield* tr_bitfieldConstruct( tr_bitfield*, size_t bitCount );
+void   tr_bitfieldConstruct( tr_bitfield*, size_t bit_count );
 
-tr_bitfield* tr_bitfieldDestruct( tr_bitfield* );
+void   tr_bitfieldDestruct( tr_bitfield* );
 
-tr_bitfield* tr_bitfieldNew( size_t bitCount );
+/***
+****
+***/
 
-void tr_bitfieldFree( tr_bitfield * b );
+void   tr_bitfieldSetHasAll( tr_bitfield* );
 
-void         tr_bitfieldClear( tr_bitfield* );
+void   tr_bitfieldSetHasNone( tr_bitfield* );
 
-int          tr_bitfieldAdd( tr_bitfield*, size_t bit );
+void   tr_bitfieldAdd( tr_bitfield*, size_t bit );
 
-int          tr_bitfieldRem( tr_bitfield*, size_t bit );
+void   tr_bitfieldRem( tr_bitfield*, size_t bit );
 
-int          tr_bitfieldAddRange( tr_bitfield *, size_t begin, size_t end );
+void   tr_bitfieldAddRange( tr_bitfield*, size_t begin, size_t end );
 
-int          tr_bitfieldRemRange( tr_bitfield*, size_t begin, size_t end );
+void   tr_bitfieldRemRange( tr_bitfield*, size_t begin, size_t end );
 
-size_t       tr_bitfieldCountTrueBits( const tr_bitfield* );
+/***
+****
+***/
 
-size_t       tr_bitfieldCountRange( const tr_bitfield * b, size_t begin, size_t end );
+bool   tr_bitfieldSetFromBitfield( tr_bitfield*, const tr_bitfield* );
 
+bool   tr_bitfieldSetRaw( tr_bitfield*, const void * bits, size_t byte_count );
 
-tr_bitfield* tr_bitfieldOr( tr_bitfield*, const tr_bitfield* );
+void*  tr_bitfieldGetRaw( const tr_bitfield * b, size_t * byte_count );
+
+/***
+****
+***/
+
+size_t  tr_bitfieldCountRange( const tr_bitfield*, size_t begin, size_t end );
+
+static inline size_t
+tr_bitfieldCountTrueBits( const tr_bitfield * b )
+{
+    assert( b->true_count == tr_bitfieldCountRange( b, 0, b->bit_count ) );
+    return b->true_count;
+}
+
+static inline bool
+tr_bitfieldHasAll( const tr_bitfield * b )
+{
+    return b->bit_count ? ( b->true_count == b->bit_count ) : b->have_all_hint;
+}
+
+static inline bool
+tr_bitfieldHasNone( const tr_bitfield * b )
+{
+    return b->bit_count ? ( b->true_count == 0 ) : b->have_none_hint;
+}
 
 /** A stripped-down version of bitfieldHas to be used
@@ -61 +102 @@
     need to call tr_bitfieldTestFast() first before you
     start looping. */
-static inline bool tr_bitfieldHasFast( const tr_bitfield * b, const size_t nth )
+static inline bool
+tr_bitfieldHasFast( const tr_bitfield * b, const size_t n )
 {
-    return ( b->bits[nth>>3u] << ( nth & 7u ) & 0x80 ) != 0;
+    if( tr_bitfieldHasAll( b ) ) return true;
+    if( tr_bitfieldHasNone( b ) ) return false;
+    return ( b->bits[n>>3u] << ( n & 7u ) & 0x80 ) != 0;
 }
 
 /** @param high the highest nth bit you're going to access */
-static inline bool tr_bitfieldTestFast( const tr_bitfield * b, const size_t high )
+static inline bool
+tr_bitfieldTestFast( const tr_bitfield * b, const size_t high )
 {
     return ( b != NULL )
-        && ( b->bits != NULL )
-        && ( high < b->bitCount );
+        && ( high < b->bit_count );
 }
 
-static inline bool tr_bitfieldHas( const tr_bitfield * b, size_t nth )
+static inline bool
+tr_bitfieldHas( const tr_bitfield * b, size_t n )
 {
-    return tr_bitfieldTestFast( b, nth ) && tr_bitfieldHasFast( b, nth );
+    return tr_bitfieldTestFast( b, n )
+        && tr_bitfieldHasFast( b, n );
 }
 

trunk/libtransmission/completion.c

@@ -11 +11 @@
  */
 
-#include <string.h> /* memcpy() */
-
 #include "transmission.h"
 #include "completion.h"
@@ -25 +23 @@
 tr_cpReset( tr_completion * cp )
 {
-    tr_bitsetSetHaveNone( &cp->blockBitset );
-    tr_free( cp->completeBlocks );
-    cp->completeBlocks = NULL;
     cp->sizeNow = 0;
     cp->sizeWhenDoneIsDirty = true;
-    cp->blocksWantedIsDirty = true;
     cp->haveValidIsDirty = true;
-}
-
-tr_completion *
+    tr_bitfieldSetHasNone( &cp->blockBitfield );
+}
+
+void
 tr_cpConstruct( tr_completion * cp, tr_torrent * tor )
 {
     cp->tor = tor;
-    cp->completeBlocks = NULL;
-    tr_bitsetConstruct( &cp->blockBitset, tor->blockCount );
+    tr_bitfieldConstruct( &cp->blockBitfield, tor->blockCount );
     tr_cpReset( cp );
-    return cp;
-}
-
-tr_completion*
+}
+
+void
 tr_cpDestruct( tr_completion * cp )
 {
-    tr_free( cp->completeBlocks );
-    tr_bitsetDestruct( &cp->blockBitset );
-    return cp;
+    tr_bitfieldDestruct( &cp->blockBitfield );
+}
+
+bool
+tr_cpBlockInit( tr_completion * cp, const tr_bitfield * b )
+{
+    bool success;
+
+    tr_cpReset( cp );
+
+    /* set blockBitfield */
+    success = tr_bitfieldSetFromBitfield( &cp->blockBitfield, b );
+
+    /* set sizeNow */
+    cp->sizeNow = tr_bitfieldCountTrueBits( &cp->blockBitfield );
+    cp->sizeNow *= cp->tor->blockSize;
+    if( tr_bitfieldHas( b, cp->tor->blockCount-1 ) )
+        cp->sizeNow -= ( cp->tor->blockSize - cp->tor->lastBlockSize );
+
+    return success;
 }
 
@@ -59 +69 @@
 isSeed( const tr_completion * cp )
 {
-    return cp->blockBitset.haveAll;
+    return tr_bitfieldHasAll( &cp->blockBitfield );
 }
 
@@ -65 +75 @@
 tr_cpGetStatus( const tr_completion * cp )
 {
+    if( isSeed( cp ) ) return TR_SEED;
     if( !tr_torrentHasMetadata( cp->tor ) ) return TR_LEECH;
-    if( cp->sizeNow == cp->tor->info.totalSize ) return TR_SEED;
     if( cp->sizeNow == tr_cpSizeWhenDone( cp ) ) return TR_PARTIAL_SEED;
     return TR_LEECH;
 }
 
-/* how many blocks are in this piece? */
-static inline uint16_t
-countBlocksInPiece( const tr_torrent * tor, const tr_piece_index_t piece )
-{
-    return piece + 1 == tor->info.pieceCount ? tor->blockCountInLastPiece
-                                             : tor->blockCountInPiece;
-}
-
-static uint16_t *
-getCompleteBlocks( const tr_completion * ccp )
-{
-    if( ccp->completeBlocks == NULL )
-    {
-        tr_completion * cp = (tr_completion*) ccp;
-        cp->completeBlocks = tr_new0( uint16_t, ccp->tor->info.pieceCount );
-    }
-
-    return ccp->completeBlocks;
-}
-
 void
 tr_cpInvalidateDND( tr_completion * cp )
 {
     cp->sizeWhenDoneIsDirty = true;
-    cp->blocksWantedIsDirty = true;
-}
-
-tr_block_index_t
-tr_cpBlocksMissing( const tr_completion * ccp )
-{
-    if( isSeed( ccp ) )
-        return 0;
-
-    if( ccp->blocksWantedIsDirty )
-    {
-        tr_piece_index_t   i;
-        tr_block_index_t   wanted = 0;
-        tr_block_index_t   complete = 0;
-        tr_completion    * cp = (tr_completion *) ccp; /* mutable */
-        const uint16_t   * complete_blocks = getCompleteBlocks( cp );
-        const tr_torrent * tor = ccp->tor;
-        const tr_info    * info = &tor->info;
-
-        for( i = 0; i < info->pieceCount; ++i )
-        {
-            if( !info->pieces[i].dnd )
-            {
-                wanted += countBlocksInPiece( tor, i );
-                complete += complete_blocks[i];
-            }
-        }
-
-        cp->blocksWantedLazy = wanted;
-        cp->blocksWantedCompleteLazy = complete;
-        cp->blocksWantedIsDirty = false;
-    }
-
-    return ccp->blocksWantedLazy - ccp->blocksWantedCompleteLazy;
 }
 
@@ -134 +90 @@
 tr_cpPieceRem( tr_completion *  cp, tr_piece_index_t piece )
 {
-    tr_block_index_t i;
-    tr_block_index_t first;
-    tr_block_index_t last;
+    tr_block_index_t i, f, l;
     const tr_torrent * tor = cp->tor;
-    uint16_t * complete_blocks = getCompleteBlocks( cp );
-
-    tr_torGetPieceBlockRange( cp->tor, piece, &first, &last );
-    for( i=first; i<=last; ++i )
+
+    tr_torGetPieceBlockRange( cp->tor, piece, &f, &l );
+
+    for( i=f; i<=l; ++i )
         if( tr_cpBlockIsComplete( cp, i ) )
             cp->sizeNow -= tr_torBlockCountBytes( tor, i );
 
-    if( !tor->info.pieces[piece].dnd )
-        cp->blocksWantedCompleteLazy -= complete_blocks[piece];
-
+    cp->haveValidIsDirty = true;
     cp->sizeWhenDoneIsDirty = true;
-    cp->haveValidIsDirty = true;
-    complete_blocks[piece] = 0;
-    tr_bitsetRemRange( &cp->blockBitset, first, last+1 );
+    tr_bitfieldRemRange( &cp->blockBitfield, f, l+1 );
 }
 
@@ -157 +107 @@
 tr_cpPieceAdd( tr_completion * cp, tr_piece_index_t piece )
 {
-    tr_block_index_t i;
-    tr_block_index_t first;
-    tr_block_index_t last;
-    tr_torGetPieceBlockRange( cp->tor, piece, &first, &last );
-
-    for( i=first; i<=last; ++i )
+    tr_block_index_t i, f, l;
+    tr_torGetPieceBlockRange( cp->tor, piece, &f, &l );
+
+    for( i=f; i<=l; ++i )
         tr_cpBlockAdd( cp, i );
 }
@@ -173 +121 @@
     if( !tr_cpBlockIsComplete( cp, block ) )
     {
-        const tr_piece_index_t piece = tr_torBlockPiece( tor, block );
-        const int blockSize = tr_torBlockCountBytes( tor, block );
-
-        getCompleteBlocks(cp)[piece]++;
-
-        tr_bitsetAdd( &cp->blockBitset, block );
-
-        cp->sizeNow += blockSize;
-        if( !tor->info.pieces[piece].dnd )
-            cp->blocksWantedCompleteLazy++;
-
+        tr_bitfieldAdd( &cp->blockBitfield, block );
+        cp->sizeNow += tr_torBlockCountBytes( tor, block );
+
+        cp->haveValidIsDirty = true;
         cp->sizeWhenDoneIsDirty = true;
-        cp->haveValidIsDirty = true;
-    }
-}
-
-
-bool
-tr_cpBlockBitsetInit( tr_completion * cp, const tr_bitset * blocks )
-{
-    bool success = false;
-    tr_torrent * tor = cp->tor;
-
-    /* start cp with a state where it thinks we have nothing */
-    tr_cpReset( cp );
-
-    if( blocks->haveAll )
-    {
-        tr_bitsetSetHaveAll( &cp->blockBitset );
-        cp->sizeNow = tor->info.totalSize;
-
-        success = true;
-    }
-    else if( blocks->haveNone )
-    {
-        /* already reset... */
-        success = true;
-    }
-    else
-    {
-        const tr_bitfield * src = &blocks->bitfield;
-        tr_bitfield * tgt = &cp->blockBitset.bitfield;
-
-        tr_bitfieldConstruct( tgt, tor->blockCount );
-
-        /* The bitfield of block flags is typically loaded from a resume file.
-           Test the bitfield's length in case the resume file is corrupt */
-        if(( success = src->byteCount == tgt->byteCount ))
-        {
-            size_t i = 0;
-            uint16_t * complete_blocks_in_piece = getCompleteBlocks( cp );
-
-            /* init our block bitfield from the one passed in */
-            memcpy( tgt->bits, src->bits, src->byteCount );
-
-            /* update cp.sizeNow and the cp.blockBitset flags */
-            i = tr_bitfieldCountTrueBits( tgt );
-            if( i == tor->blockCount ) {
-                tr_bitsetSetHaveAll( &cp->blockBitset );
-                cp->sizeNow = cp->tor->info.totalSize;
-            } else if( !i ) {
-                tr_bitsetSetHaveNone( &cp->blockBitset );
-                cp->sizeNow = 0;
-            } else {
-                cp->blockBitset.haveAll = cp->blockBitset.haveNone = false;
-                cp->sizeNow = tr_bitfieldCountRange( tgt, 0, tor->blockCount-1 );
-                cp->sizeNow *= tor->blockSize;
-                if( tr_bitfieldHas( tgt, tor->blockCount-1 ) )
-                    cp->sizeNow += tr_torBlockCountBytes( tor, tor->blockCount-1 );
-            }
-
-            /* update complete_blocks_in_piece */
-            for( i=0; i<tor->info.pieceCount; ++i ) {
-                 tr_block_index_t first, last;
-                 tr_torGetPieceBlockRange( tor, i, &first, &last );
-                 complete_blocks_in_piece[i] = tr_bitfieldCountRange( src, first, last+1 );
-            }
-        }
-    }
-
-    return success;
+    }
 }
 
@@ -265 +138 @@
     if( ccp->haveValidIsDirty )
     {
-        tr_piece_index_t   i;
-        uint64_t           size = 0;
-        tr_completion    * cp = (tr_completion *) ccp; /* mutable */
+        tr_piece_index_t i;
+        uint64_t size = 0;
+        tr_completion * cp = (tr_completion *) ccp; /* mutable */
         const tr_torrent * tor = ccp->tor;
-        const tr_info    * info = &tor->info;
+        const tr_info * info = &tor->info;
 
         for( i=0; i<info->pieceCount; ++i )
@@ -275 +148 @@
                 size += tr_torPieceCountBytes( tor, i );
 
+        cp->haveValidLazy = size;
         cp->haveValidIsDirty = false;
-        cp->haveValidLazy = size;
     }
 
@@ -287 +160 @@
     if( ccp->sizeWhenDoneIsDirty )
     {
-        tr_piece_index_t   i;
-        uint64_t           size = 0;
-        tr_completion    * cp = (tr_completion *) ccp; /* mutable */
+        tr_piece_index_t i;
+        uint64_t size = 0;
+        tr_completion * cp = (tr_completion *) ccp; /* mutable */
         const tr_torrent * tor = ccp->tor;
-        const tr_info    * info = &tor->info;
+        const tr_info * info = &tor->info;
 
         for( i=0; i<info->pieceCount; ++i )
@@ -297 +170 @@
                 size += tr_torPieceCountBytes( tor, i );
 
+        cp->sizeWhenDoneLazy = size;
         cp->sizeWhenDoneIsDirty = false;
-        cp->sizeWhenDoneLazy = size;
     }
 
@@ -304 +177 @@
 }
 
+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;
+}
+
 void
 tr_cpGetAmountDone( const tr_completion * cp, float * tab, int tabCount )
 {
     int i;
+    const bool seed = isSeed( cp );
     const float interval = cp->tor->info.pieceCount / (float)tabCount;
-    const bool seed = isSeed( cp );
 
     for( i=0; i<tabCount; ++i ) {
@@ -315 +200 @@
             tab[i] = 1.0f;
         else {
+            tr_block_index_t f, l;
             const tr_piece_index_t piece = (tr_piece_index_t)i * interval;
-            tab[i] = getCompleteBlocks(cp)[piece] / (float)countBlocksInPiece( cp->tor, piece );
+            tr_torGetPieceBlockRange( cp->tor, piece, &f, &l );
+            tab[i] = tr_bitfieldCountRange( &cp->blockBitfield, f, l+1 )
+                                                            / (float)(l+1-f);
         }
     }
 }
 
-int
-tr_cpMissingBlocksInPiece( const tr_completion * cp, tr_piece_index_t i )
+size_t
+tr_cpMissingBlocksInPiece( const tr_completion * cp, tr_piece_index_t piece )
 {
     if( isSeed( cp ) )
         return 0;
-
-    return countBlocksInPiece( cp->tor, i ) - getCompleteBlocks(cp)[i];
+    else {
+        tr_block_index_t f, l;
+        tr_torGetPieceBlockRange( cp->tor, piece, &f, &l );
+        return (l+1-f) - tr_bitfieldCountRange( &cp->blockBitfield, f, l+1 );
+    }
+}
+
+size_t
+tr_cpMissingBytesInPiece( const tr_completion * cp, tr_piece_index_t piece )
+{
+    if( isSeed( cp ) )
+        return 0;
+    else {
+        size_t haveBytes = 0;
+        tr_block_index_t f, l;
+        tr_torGetPieceBlockRange( cp->tor, piece, &f, &l );
+        haveBytes = tr_bitfieldCountRange( &cp->blockBitfield, f, l );
+        haveBytes *= cp->tor->blockSize;
+        if( tr_bitfieldHas( &cp->blockBitfield, l ) )
+            haveBytes += tr_torBlockCountBytes( cp->tor, l );
+        return tr_torPieceCountBytes( cp->tor, piece ) - haveBytes;
+    }
 }
 
@@ -333 +241 @@
 tr_cpFileIsComplete( const tr_completion * cp, tr_file_index_t i )
 {
-    tr_block_index_t f, l;
-
     if( cp->tor->info.files[i].length == 0 )
         return true;
-
-    tr_torGetFileBlockRange( cp->tor, i, &f, &l );
-    return tr_bitsetCountRange( &cp->blockBitset, f, l+1 ) == (l+1-f);
-}
-
-tr_bitfield *
-tr_cpCreatePieceBitfield( const tr_completion * cp )
-{
-    tr_piece_index_t i;
+    else {
+        tr_block_index_t f, l;
+        tr_torGetFileBlockRange( cp->tor, i, &f, &l );
+        return tr_bitfieldCountRange( &cp->blockBitfield, f, l+1 ) == (l+1-f);
+    }
+}
+
+void *
+tr_cpCreatePieceBitfield( const tr_completion * cp, size_t * byte_count )
+{
+    void * ret;
+    tr_bitfield pieces;
     const tr_piece_index_t n = cp->tor->info.pieceCount;
-    tr_bitfield * bf = tr_bitfieldNew( n );
-
-    for( i=0; i<n; ++i )
-        if( tr_cpPieceIsComplete( cp, i ) )
-            tr_bitfieldAdd( bf, i );
-
-    return bf;
-}
+    tr_bitfieldConstruct( &pieces, n );
+
+    if( tr_cpHasAll( cp ) )
+        tr_bitfieldSetHasAll( &pieces );
+    else if( !tr_cpHasNone( cp ) ) {
+        tr_piece_index_t i;
+        for( i=0; i<n; ++i )
+            if( tr_cpPieceIsComplete( cp, i ) )
+                tr_bitfieldAdd( &pieces, i );
+    }
+
+    ret = tr_bitfieldGetRaw( &pieces, byte_count );
+    tr_bitfieldDestruct( &pieces );
+    return ret;
+}
+
+double
+tr_cpPercentComplete( const tr_completion * cp )
+{
+    const double ratio = tr_getRatio( cp->sizeNow, cp->tor->info.totalSize );
+
+    if( (int)ratio == TR_RATIO_NA )
+        return 0.0;
+    else if( (int)ratio == TR_RATIO_INF )
+        return 1.0;
+    else
+        return ratio;
+}
+
+double
+tr_cpPercentDone( const tr_completion * cp )
+{
+    const double ratio = tr_getRatio( cp->sizeNow, tr_cpSizeWhenDone( cp ) );
+    const int iratio = (int)ratio;
+    return ((iratio == TR_RATIO_NA) || (iratio == TR_RATIO_INF)) ? 0.0 : ratio;
+}

trunk/libtransmission/completion.h

@@ -18 +18 @@
 #define TR_COMPLETION_H
 
-#include <assert.h>
-
 #include "transmission.h"
-#include "bitset.h"
+#include "bitfield.h"
 #include "utils.h" /* tr_getRatio() */
 
 typedef struct tr_completion
 {
-    bool  sizeWhenDoneIsDirty;
-    bool  blocksWantedIsDirty;
-    bool  haveValidIsDirty;
-
-    tr_torrent *    tor;
+    tr_torrent * tor;
 
     /* do we have this block? */
-    tr_bitset    blockBitset;
-
-    /* a block is complete if and only if we have it */
-    uint16_t *  completeBlocks;
-
-    /* total number of blocks that we want downloaded
-       DON'T access this directly; it's a lazy field.
-       Used by tr_cpBlocksMissing(). */
-    tr_block_index_t    blocksWantedLazy;
-
-    /* total number of completed blocks that we want downloaded
-       DON'T access this directly; it's a lazy field.
-       Used by tr_cpBlocksMissing(). */
-    tr_block_index_t    blocksWantedCompleteLazy;
+    tr_bitfield blockBitfield;
 
     /* 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;
+    uint64_t sizeWhenDoneLazy;
+
+    /* whether or not sizeWhenDone needs to be recalculated */
+    bool sizeWhenDoneIsDirty;
 
     /* 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;
+    uint64_t haveValidLazy;
+
+    /* whether or not haveValidLazy needs to be recalculated */
+    bool haveValidIsDirty;
 
     /* number of bytes we want or have now. [0..sizeWhenDone] */
-    uint64_t    sizeNow;
+    uint64_t sizeNow;
 }
 tr_completion;
@@ -67 +54 @@
 **/
 
-tr_completion * tr_cpConstruct( tr_completion *, tr_torrent * );
+void              tr_cpConstruct( tr_completion *, tr_torrent * );
 
-tr_completion * tr_cpDestruct( tr_completion * );
+void              tr_cpDestruct( tr_completion * );
 
 /**
@@ -75 +62 @@
 **/
 
-tr_completeness    tr_cpGetStatus( const tr_completion * );
+double            tr_cpPercentComplete( const tr_completion * cp );
 
-uint64_t           tr_cpHaveValid( const tr_completion * );
+double            tr_cpPercentDone( const tr_completion * cp );
 
-tr_block_index_t   tr_cpBlocksMissing( const tr_completion * );
+tr_completeness   tr_cpGetStatus( const tr_completion * );
 
-uint64_t           tr_cpSizeWhenDone( const tr_completion * );
+uint64_t          tr_cpHaveValid( const tr_completion * );
 
-void               tr_cpInvalidateDND( tr_completion * );
+uint64_t          tr_cpSizeWhenDone( const tr_completion * );
 
-void               tr_cpGetAmountDone( const   tr_completion * completion,
-                                       float                 * tab,
-                                       int                     tabCount );
+uint64_t          tr_cpLeftUntilComplete( const tr_completion * );
+
+uint64_t          tr_cpLeftUntilDone( const tr_completion * );
+
+void              tr_cpGetAmountDone( const   tr_completion * completion,
+                                      float                 * tab,
+                                      int                     tabCount );
+
+static inline bool tr_cpHasAll( const tr_completion * cp )
+{
+    return tr_bitfieldHasAll( &cp->blockBitfield );
+}
+
+static inline bool tr_cpHasNone( const tr_completion * cp )
+{
+    return tr_bitfieldHasNone( &cp->blockBitfield );
+}
 
 static inline uint64_t tr_cpHaveTotal( const tr_completion * cp )
@@ -94 +95 @@
 }
 
-static inline uint64_t tr_cpLeftUntilComplete( const tr_completion * cp )
-{
-    return tr_torrentInfo(cp->tor)->totalSize - cp->sizeNow;
-}
-
-static inline uint64_t tr_cpLeftUntilDone( const tr_completion * cp )
-{
-    return tr_cpSizeWhenDone( cp ) - cp->sizeNow;
-}
-
-static inline double tr_cpPercentComplete( const tr_completion * cp )
-{
-    const double ratio = tr_getRatio( cp->sizeNow, tr_torrentInfo(cp->tor)->totalSize );
-    if( (int)ratio == TR_RATIO_NA )
-        return 0.0;
-    else if( (int)ratio == TR_RATIO_INF )
-        return 1.0;
-    else
-        return ratio;
-}
-
-static inline double tr_cpPercentDone( const tr_completion * cp )
-{
-    const double ratio = tr_getRatio( cp->sizeNow, tr_cpSizeWhenDone( cp ) );
-    const int iratio = (int)ratio;
-    return ((iratio == TR_RATIO_NA) || (iratio == TR_RATIO_INF)) ? 0.0 : ratio;
-}
-
 /**
-*** Pieces
+***  Pieces
 **/
 
-int tr_cpMissingBlocksInPiece( const tr_completion * cp, tr_piece_index_t i );
+void    tr_cpPieceAdd( tr_completion * cp, tr_piece_index_t i );
+
+void    tr_cpPieceRem( tr_completion * cp, tr_piece_index_t i );
+
+size_t  tr_cpMissingBlocksInPiece( const tr_completion *, tr_piece_index_t );
+
+size_t  tr_cpMissingBytesInPiece ( const tr_completion *, tr_piece_index_t );
 
 static inline bool
@@ -134 +113 @@
 }
 
-void tr_cpPieceAdd( tr_completion * cp, tr_piece_index_t i );
-
-void tr_cpPieceRem( tr_completion * cp, tr_piece_index_t i );
-
-bool tr_cpFileIsComplete( const tr_completion * cp, tr_file_index_t );
-
 /**
-*** Blocks
+***  Blocks
 **/
 
@@ -147 +120 @@
 tr_cpBlockIsComplete( const tr_completion * cp, tr_block_index_t i )
 {
-    return tr_bitsetHas( &cp->blockBitset, i );
+    return tr_bitfieldHas( &cp->blockBitfield, i );
 }
 
-void tr_cpBlockAdd( tr_completion * cp, tr_block_index_t i );
+void  tr_cpBlockAdd( tr_completion * cp, tr_block_index_t i );
 
-bool tr_cpBlockBitsetInit( tr_completion * cp, const tr_bitset * blocks );
+bool  tr_cpBlockInit( tr_completion * cp, const tr_bitfield * blocks );
 
 /***
-****
+****  Misc
 ***/
 
-static inline const tr_bitset *
-tr_cpBlockBitset( const tr_completion * cp )
-{
-    return &cp->blockBitset;
-}
+bool  tr_cpFileIsComplete( const tr_completion * cp, tr_file_index_t );
 
-tr_bitfield * tr_cpCreatePieceBitfield( const tr_completion * cp );
+void  tr_cpInvalidateDND( tr_completion * );
+
+void* tr_cpCreatePieceBitfield( const tr_completion * cp, size_t * byte_count );
+
 
 #endif

trunk/libtransmission/peer-io.c

@@ -130 +130 @@
 
     dbgmsg( io, "canRead" );
+
+fprintf( stderr, "[%p] in canRead; refcount is %d (%s:%d)\n", io, io->refCount, __FILE__, __LINE__ );
 
     tr_peerIoRef( io );
@@ -569 +571 @@
         UTP_SetSockopt( utp_socket, SO_RCVBUF, UTP_READ_BUFFER_SIZE );
         dbgmsg( io, "%s", "calling UTP_SetCallbacks &utp_function_table" );
+fprintf( stderr, "[%p] setting utp callbacks (%s:%d)\n", io, __FILE__, __LINE__ );
         UTP_SetCallbacks( utp_socket,
                           &utp_function_table,
@@ -607 +610 @@
 {
     int fd = -1;
-    struct UTPSocket *utp_socket = NULL;
+    struct UTPSocket * utp_socket = NULL;
 
     assert( session );
@@ -722 +725 @@
 #ifdef WITH_UTP
     if( io->utp_socket ) {
+fprintf( stderr, "[%p] clearing utp callbacks (%s:%d)\n", io, __FILE__, __LINE__ );
         UTP_SetCallbacks( io->utp_socket,
                           &dummy_utp_function_table,

trunk/libtransmission/peer-mgr.c

@@ -375 +375 @@
     memset( peer, 0, sizeof( tr_peer ) );
 
-    peer->have = TR_BITSET_INIT;
+    peer->have = TR_BITFIELD_INIT;
 
     tr_historyConstruct( &peer->blocksSentToClient,  CANCEL_HISTORY_SEC, ( RECHOKE_PERIOD_MSEC / 1000 ) );
@@ -407 +407 @@
     {
         peer = peerNew( atom );
+        tr_bitfieldConstruct( &peer->have, torrent->tor->blockCount );
+        tr_bitfieldConstruct( &peer->blame, torrent->tor->blockCount );
         tr_ptrArrayInsertSorted( &torrent->peers, peer, peerCompare );
     }
@@ -420 +422 @@
     assert( peer != NULL );
 
-    peerDeclinedAllRequests( tor->torrentPeers, peer );
+    if( tor->torrentPeers->isRunning )
+        peerDeclinedAllRequests( tor->torrentPeers, peer );
 
     if( peer->msgs != NULL )
@@ -426 +429 @@
 
     if( peer->io ) {
+fprintf( stderr, "[%p] peer %p clearing/unreffing its io (%s:%d)\n", peer->io, peer, __FILE__, __LINE__ );
         tr_peerIoClear( peer->io );
         tr_peerIoUnref( peer->io ); /* balanced by the ref in handshakeDoneCB() */
@@ -435 +439 @@
     tr_historyDestruct( &peer->cancelsSentToPeer   );
 
-    tr_bitsetDestruct( &peer->have );
-    tr_bitfieldFree( peer->blame );
+    tr_bitfieldDestruct( &peer->have );
+    tr_bitfieldDestruct( &peer->blame );
     tr_free( peer->client );
 
@@ -483 +487 @@
 
         for( peer_i=0; peer_i<peer_count; ++peer_i )
-            if( tr_bitsetHas( &peers[peer_i]->have, piece_i ) )
+            if( tr_bitfieldHas( &peers[peer_i]->have, piece_i ) )
                 ++r;
 
@@ -867 +871 @@
 }
 
+static bool
+testForEndgame( const Torrent * t )
+{
+    /* we consider ourselves to be in endgame if the number of bytes
+       we've got requested is >= the number of bytes left to download */
+    return ( t->requestCount * t->tor->blockSize )
+               <= tr_cpLeftUntilDone( &t->tor->completion );
+}
+
 static void
 updateEndgame( Torrent * t )
 {
-    const tr_torrent * tor = t->tor;
-    const tr_block_index_t missing = tr_cpBlocksMissing( &tor->completion );
-
     assert( t->requestCount >= 0 );
 
-    if( (tr_block_index_t) t->requestCount < missing )
+    if( !testForEndgame( t ) )
     {
         /* not in endgame */
@@ -1268 +1278 @@
  */
 static void
-tr_decrReplicationFromBitset( Torrent * t, const tr_bitset * bitset )
+tr_decrReplicationFromBitfield( Torrent * t, const tr_bitfield * b )
 {
     int i;
@@ -1276 +1286 @@
     assert( t->pieceReplicationSize == t->tor->info.pieceCount );
 
-    if( bitset->haveAll )
+    if( tr_bitfieldHasAll( b ) )
     {
         for( i=0; i<n; ++i )
             --t->pieceReplication[i];
     }
-    else if ( !bitset->haveNone )
-    {
-        const tr_bitfield * const b = &bitset->bitfield;
-
+    else if ( !tr_bitfieldHasNone( b ) )
+    {
         for( i=0; i<n; ++i )
             if( tr_bitfieldHas( b, i ) )
@@ -1317 +1325 @@
     Torrent * t;
     struct weighted_piece * pieces;
-    const tr_bitset * have = &peer->have;
+    const tr_bitfield * const have = &peer->have;
 
     /* sanity clause */
@@ -1346 +1354 @@
 
         /* if the peer has this piece that we want... */
-        if( tr_bitsetHas( have, p->index ) )
+        if( tr_bitfieldHas( have, p->index ) )
         {
             tr_block_index_t b;
@@ -2213 +2221 @@
         {
             tr_peer * peer = peers[i];
-            if( tr_bitfieldHas( peer->blame, pieceIndex ) )
+            if( tr_bitfieldHas( &peer->blame, pieceIndex ) )
             {
                 tordbg( t, "peer %s contributed to corrupt piece (%d); now has %d strikes",
@@ -2403 +2411 @@
 stopTorrent( Torrent * t )
 {
-    int i, n;
+    tr_peer * peer;
 
     t->isRunning = false;
@@ -2411 +2419 @@
 
     /* disconnect the peers. */
-    for( i=0, n=tr_ptrArraySize( &t->peers ); i<n; ++i )
-        peerDelete( t, tr_ptrArrayNth( &t->peers, i ) );
-    tr_ptrArrayClear( &t->peers );
+    while(( peer = tr_ptrArrayPop( &t->peers )))
+        peerDelete( t, peer );
 
     /* disconnect the handshakes. handshakeAbort calls handshakeDoneCB(),
@@ -2453 +2460 @@
 tr_peerUpdateProgress( tr_torrent * tor, tr_peer * peer )
 {
-    const tr_bitset * have = &peer->have;
-
-    if( have->haveAll )
+    const tr_bitfield * have = &peer->have;
+
+    if( tr_bitfieldHasAll( have ) )
     {
         peer->progress = 1.0;
     }
-    else if( have->haveNone )
+    else if( tr_bitfieldHasNone( have ) )
     {
         peer->progress = 0.0;
@@ -2465 +2472 @@
     else
     {
-        const float trueCount = tr_bitfieldCountTrueBits( &have->bitfield );
+        const float true_count = tr_bitfieldCountTrueBits( have );
 
         if( tr_torrentHasMetadata( tor ) )
-            peer->progress = trueCount / tor->info.pieceCount;
+            peer->progress = true_count / tor->info.pieceCount;
         else /* without pieceCount, this result is only a best guess... */
-            peer->progress = trueCount / ( have->bitfield.bitCount + 1 );
+            peer->progress = true_count / ( have->bit_count + 1 );
     }
 
@@ -2517 +2524 @@
                 int j;
                 for( j=0; j<peerCount; ++j )
-                    if( tr_bitsetHas( &peers[j]->have, piece ) )
+                    if( tr_bitfieldHas( &peers[j]->have, piece ) )
                         ++tab[i];
             }
@@ -2524 +2531 @@
 }
 
-/* Returns the pieces that are available from peers */
-tr_bitfield*
-tr_peerMgrGetAvailable( const tr_torrent * tor )
-{
-    int i;
-    Torrent * t = tor->torrentPeers;
-    const int peerCount = tr_ptrArraySize( &t->peers );
-    const tr_peer ** peers = (const tr_peer**) tr_ptrArrayBase( &t->peers );
-    tr_bitfield * pieces = tr_bitfieldNew( t->tor->info.pieceCount );
-
-    assert( tr_torrentIsLocked( tor ) );
-
-    for( i=0; i<peerCount; ++i )
-        tr_bitsetOr( pieces, &peers[i]->have );
-
-    return pieces;
+static bool
+peerIsSeed( const tr_peer * peer )
+{
+    if( peer->progress >= 1.0 )
+        return true;
+
+    if( peer->atom && atomIsSeed( peer->atom ) )
+        return true;
+
+    return false;
+}
+
+/* count how many pieces we want that connected peers have */
+uint64_t
+tr_peerMgrGetDesiredAvailable( const tr_torrent * tor )
+{
+    size_t i;
+    size_t n;
+    uint64_t desiredAvailable;
+    const Torrent * t = tor->torrentPeers;
+
+    /* common shortcuts... */
+
+    if( tr_torrentIsSeed( t->tor ) )
+        return 0;
+
+    if( !tr_torrentHasMetadata( tor ) )
+        return 0;
+
+    n = tr_ptrArraySize( &t->peers );
+    if( n == 0 )
+        return 0;
+    else {
+        const tr_peer ** peers = (const tr_peer**) tr_ptrArrayBase( &t->peers );
+        for( i=0; i<n; ++i )
+            if( peers[i]->atom && atomIsSeed( peers[i]->atom ) )
+                return tr_cpLeftUntilDone( &tor->completion );
+    }
+
+    if( !t->pieceReplication || !t->pieceReplicationSize )
+        return 0;
+
+    /* do it the hard way */
+
+    desiredAvailable = 0;
+    for( i=0, n=tor->info.pieceCount; i<n; ++i )
+    {
+        if( tor->info.pieces[i].dnd )
+            continue;
+        if( t->pieceReplicationSize >= i )
+            continue;
+        if( t->pieceReplication[i] == 0 )
+            continue;
+
+        desiredAvailable += tr_cpMissingBytesInPiece( &t->tor->completion, i );
+    }
+
+    return desiredAvailable;
 }
 
@@ -2545 +2594 @@
 tr_peerMgrTorrentStats( tr_torrent  * tor,
                         int         * setmePeersConnected,
-                        int         * setmeSeedsConnected,
                         int         * setmeWebseedsSendingToUs,
                         int         * setmePeersSendingToUs,
@@ -2561 +2609 @@
 
     *setmePeersConnected       = 0;
-    *setmeSeedsConnected       = 0;
     *setmePeersGettingFromUs   = 0;
     *setmePeersSendingToUs     = 0;
@@ -2586 +2633 @@
         if( clientIsUploadingTo( peer ) )
             ++*setmePeersGettingFromUs;
-
-        if( atomIsSeed( atom ) )
-            ++*setmeSeedsConnected;
     }
 
@@ -2624 +2668 @@
 {
     return peer->io ? tr_peerIoGetPieceSpeed_Bps( peer->io, now, direction ) : 0.0;
-}
-
-static bool
-peerIsSeed( const tr_peer * peer )
-{
-    if( peer->progress >= 1.0 )
-        return true;
-
-    if( peer->atom && atomIsSeed( peer->atom ) )
-        return true;
-
-    return false;
 }
 
@@ -2735 +2767 @@
     return ( !tor->info.pieces[index].dnd ) /* we want it */
         && ( !tr_cpPieceIsComplete( &tor->completion, index ) )  /* we don't have it */
-        && ( tr_bitsetHas( &peer->have, index ) ); /* peer has it */
+        && ( tr_bitfieldHas( &peer->have, index ) ); /* peer has it */
 }
 
@@ -3234 +3266 @@
 
     if( replicationExists( t ) )
-        tr_decrReplicationFromBitset( t, &peer->have );
+        tr_decrReplicationFromBitfield( t, &peer->have );
 
     assert( removed == peer );

trunk/libtransmission/peer-mgr.h

@@ -25 +25 @@
 
 #include "bitfield.h"
-#include "bitset.h"
 #include "history.h"
 #include "net.h" /* tr_address */
@@ -111 +110 @@
     struct peer_atom       * atom;
 
-    struct tr_bitfield     * blame;
-    struct tr_bitset         have;
+    struct tr_bitfield       blame;
+    struct tr_bitfield       have;
 
     /** how complete the peer's copy of the torrent is. [0.0...1.0] */
@@ -230 +229 @@
                                     unsigned int       tabCount );
 
-struct tr_bitfield* tr_peerMgrGetAvailable( const tr_torrent * tor );
+uint64_t tr_peerMgrGetDesiredAvailable( const tr_torrent * tor );
 
 void tr_peerMgrOnTorrentGotMetainfo( tr_torrent * tor );
@@ -238 +237 @@
 void tr_peerMgrTorrentStats( tr_torrent * tor,
                              int * setmePeersConnected,
-                             int * setmeSeedsConnected,
                              int * setmeWebseedsSendingToUs,
                              int * setmePeersSendingToUs,

trunk/libtransmission/peer-msgs.c

@@ -14 +14 @@
 #include <errno.h>
 #include <stdarg.h>
-#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -217 +216 @@
 ***
 **/
-
-#if 0
-static tr_bitfield*
-getHave( const struct tr_peermsgs * msgs )
-{
-    if( msgs->peer->have == NULL )
-        msgs->peer->have = tr_bitfieldNew( msgs->torrent->info.pieceCount );
-    return msgs->peer->have;
-}
-#endif
 
 static inline tr_session*
@@ -1418 +1407 @@
 
             /* a peer can send the same HAVE message twice... */
-            if( !tr_bitsetHas( &msgs->peer->have, ui32 ) ) {
-                tr_bitsetAdd( &msgs->peer->have, ui32 );
+            if( !tr_bitfieldHas( &msgs->peer->have, ui32 ) ) {
+                tr_bitfieldAdd( &msgs->peer->have, ui32 );
                 fireClientGotHave( msgs, ui32 );
             }
@@ -1426 +1415 @@
 
         case BT_BITFIELD: {
-            tr_bitfield tmp = TR_BITFIELD_INIT;
-            const size_t bitCount = tr_torrentHasMetadata( msgs->torrent )
-                                  ? msgs->torrent->info.pieceCount
-                                  : msglen * 8;
-            tr_bitfieldConstruct( &tmp, bitCount );
+            uint8_t * tmp = tr_new( uint8_t, msglen );
             dbgmsg( msgs, "got a bitfield" );
-            tr_peerIoReadBytes( msgs->peer->io, inbuf, tmp.bits, msglen );
-            tr_bitsetSetBitfield( &msgs->peer->have, &tmp );
-            fireClientGotBitfield( msgs, &tmp );
-            tr_bitfieldDestruct( &tmp );
+            tr_peerIoReadBytes( msgs->peer->io, inbuf, tmp, msglen );
+            tr_bitfieldSetRaw( &msgs->peer->have, tmp, msglen );
+            fireClientGotBitfield( msgs, &msgs->peer->have );
             updatePeerProgress( msgs );
+            tr_free( tmp );
             break;
         }
@@ -1511 +1496 @@
             dbgmsg( msgs, "Got a BT_FEXT_HAVE_ALL" );
             if( fext ) {
-                tr_bitsetSetHaveAll( &msgs->peer->have );
+                tr_bitfieldSetHasAll( &msgs->peer->have );
+assert( tr_bitfieldHasAll( &msgs->peer->have ) );
                 fireClientGotHaveAll( msgs );
                 updatePeerProgress( msgs );
@@ -1523 +1509 @@
             dbgmsg( msgs, "Got a BT_FEXT_HAVE_NONE" );
             if( fext ) {
-                tr_bitsetSetHaveNone( &msgs->peer->have );
+                tr_bitfieldSetHasNone( &msgs->peer->have );
                 fireClientGotHaveNone( msgs );
                 updatePeerProgress( msgs );
@@ -1566 +1552 @@
 }
 
-static void
-addPeerToBlamefield( tr_peermsgs * msgs, uint32_t index )
-{
-    if( !msgs->peer->blame )
-         msgs->peer->blame = tr_bitfieldNew( msgs->torrent->info.pieceCount );
-    tr_bitfieldAdd( msgs->peer->blame, index );
-}
-
 /* returns 0 on success, or an errno on failure */
 static int
@@ -1611 +1589 @@
         return err;
 
-    addPeerToBlamefield( msgs, req->index );
+    tr_bitfieldAdd( &msgs->peer->blame, req->index );
     fireGotBlock( msgs, req );
     return 0;
@@ -2016 +1994 @@
 sendBitfield( tr_peermsgs * msgs )
 {
+    size_t byte_count = 0;
     struct evbuffer * out = msgs->outMessages;
-    tr_bitfield * bf = tr_cpCreatePieceBitfield( &msgs->torrent->completion );
-
-    evbuffer_add_uint32( out, sizeof( uint8_t ) + bf->byteCount );
+    void * bytes = tr_cpCreatePieceBitfield( &msgs->torrent->completion, &byte_count );
+
+    evbuffer_add_uint32( out, sizeof( uint8_t ) + byte_count );
     evbuffer_add_uint8 ( out, BT_BITFIELD );
-    evbuffer_add       ( out, bf->bits, bf->byteCount );
+    evbuffer_add       ( out, bytes, byte_count );
     dbgmsg( msgs, "sending bitfield... outMessage size is now %zu", evbuffer_get_length( out ) );
     pokeBatchPeriod( msgs, IMMEDIATE_PRIORITY_INTERVAL_SECS );
 
-    tr_bitfieldFree( bf );
+    tr_free( bytes );
 }
 
@@ -2033 +2012 @@
     const bool fext = tr_peerIoSupportsFEXT( msgs->peer->io );
 
-    if( fext && ( tr_cpBlockBitset( &msgs->torrent->completion )->haveAll ) )
+    if( fext && tr_cpHasAll( &msgs->torrent->completion ) )
     {
         protocolSendHaveAll( msgs );
     }
-    else if( fext && ( tr_cpBlockBitset( &msgs->torrent->completion )->haveNone ) )
+    else if( fext && tr_cpHasNone( &msgs->torrent->completion ) )
     {
         protocolSendHaveNone( msgs );
     }
-    else
+    else if( !tr_cpHasNone( &msgs->torrent->completion ) )
     {
         sendBitfield( msgs );

trunk/libtransmission/resume.c

@@ -17 +17 @@
 #include "transmission.h"
 #include "bencode.h"
-#include "bitset.h"
 #include "completion.h"
 #include "metainfo.h" /* tr_metainfoGetBasename() */
@@ -410 +409 @@
 
 static void
+bitfieldToBenc( const tr_bitfield * b, tr_benc * benc )
+{
+    if( tr_bitfieldHasAll( b ) )
+        tr_bencInitStr( benc, "all", 3 );
+    else if( tr_bitfieldHasNone( b ) )
+        tr_bencInitStr( benc, "none", 4 );
+    else
+        tr_bencInitRaw( benc, b->bits, b->byte_count );
+}
+
+
+static void
 saveProgress( tr_benc * dict, tr_torrent * tor )
 {
@@ -470 +481 @@
 
     /* add the blocks bitfield */
-    tr_bitsetToBenc( tr_cpBlockBitset( &tor->completion ),
-                     tr_bencDictAdd( prog, KEY_PROGRESS_BLOCKS ) );
+    bitfieldToBenc( &tor->completion.blockBitfield,
+                    tr_bencDictAdd( prog, KEY_PROGRESS_BLOCKS ) );
 }
 
@@ -493 +504 @@
         tr_benc * l;
         tr_benc * b;
-        struct tr_bitset bitset = TR_BITSET_INIT;
+        struct tr_bitfield blocks = TR_BITFIELD_INIT;
 
         if( tr_bencDictFindList( prog, KEY_PROGRESS_CHECKTIME, &l ) )
@@ -568 +579 @@
 
         err = NULL;
+        tr_bitfieldConstruct( &blocks, tor->blockCount );
 
         if(( b = tr_bencDictFind( prog, KEY_PROGRESS_BLOCKS )))
         {
-            if( !tr_bitsetFromBenc( &bitset, b ) )
-                err = "Invalid value for PIECES";
+            size_t buflen;
+            const uint8_t * buf;
+
+            if( !tr_bencGetRaw( b, &buf, &buflen ) )
+                err = "Invalid value for \"blocks\"";
+            else if( ( buflen == 3 ) && !memcmp( buf, "all", 3 ) )
+                tr_bitfieldSetHasAll( &blocks );
+            else if( ( buflen == 4 ) && !memcmp( buf, "none", 4 ) )
+                tr_bitfieldSetHasNone( &blocks );
+            else
+                tr_bitfieldSetRaw( &blocks, buf, buflen );
         }
         else if( tr_bencDictFindStr( prog, KEY_PROGRESS_HAVE, &str ) )
         {
             if( !strcmp( str, "all" ) )
-                tr_bitsetSetHaveAll( &bitset );
+                tr_bitfieldSetHasAll( &blocks );
             else
                 err = "Invalid value for HAVE";
@@ -583 +604 @@
         else if( tr_bencDictFindRaw( prog, KEY_PROGRESS_BITFIELD, &raw, &rawlen ) )
         {
-            bitset.bitfield.bits = (void*) raw;
-            bitset.bitfield.byteCount = rawlen;
-            bitset.bitfield.bitCount = rawlen * 8;
+            tr_bitfieldSetRaw( &blocks, raw, rawlen );
         }
         else err = "Couldn't find 'pieces' or 'have' or 'bitfield'";
 
-        if( !err && !tr_cpBlockBitsetInit( &tor->completion, &bitset ) )
+        if( !err && !tr_cpBlockInit( &tor->completion, &blocks ) )
             err = "Error loading bitfield";
         if( err != NULL )
             tr_tordbg( tor, "Torrent needs to be verified - %s", err );
 
+        tr_bitfieldDestruct( &blocks );
         ret = TR_FR_PROGRESS;
     }

trunk/libtransmission/rpcimpl.c

@@ -559 +559 @@
         tr_bencDictAddInt( d, key, st->peersSendingToUs );
     else if( tr_streq( key, keylen, "pieces" ) ) {
-        tr_bitfield * bf = tr_cpCreatePieceBitfield( &tor->completion );
-        char * str = tr_base64_encode( bf->bits, bf->byteCount, NULL );
+        size_t byte_count = 0;
+        void * bytes = tr_cpCreatePieceBitfield( &tor->completion, &byte_count );
+        char * str = tr_base64_encode( bytes, byte_count, NULL );
         tr_bencDictAddStr( d, key, str!=NULL ? str : "" );
         tr_free( str );
-        tr_bitfieldFree( bf );
+        tr_free( bytes );
     }
     else if( tr_streq( key, keylen, "pieceCount" ) )

trunk/libtransmission/session.c

@@ -1263 +1263 @@
     tr_bitfield * b = &t->minutes;
 
-    tr_bitfieldClear( b );
+    tr_bitfieldSetHasNone( b );
 
     for( day=0; day<7; ++day )

trunk/libtransmission/torrent.c

@@ -1139 +1139 @@
 {
     tr_stat *               s;
-    int                     usableSeeds;
     uint64_t                now;
     uint64_t                seedRatioBytesLeft;
@@ -1164 +1163 @@
     tr_peerMgrTorrentStats( tor,
                             &s->peersConnected,
-                            &usableSeeds,
                             &s->webseedsSendingToUs,
                             &s->peersSendingToUs,
@@ -1175 +1173 @@
     s->rawDownloadSpeed_KBps   = toSpeedKBps( tr_bandwidthGetRawSpeed_Bps  ( tor->bandwidth, now, TR_DOWN ) );
     s->pieceDownloadSpeed_KBps = toSpeedKBps( tr_bandwidthGetPieceSpeed_Bps( tor->bandwidth, now, TR_DOWN ) );
-
-    usableSeeds += tor->info.webseedCount;
 
     s->percentComplete = tr_cpPercentComplete ( &tor->completion );
@@ -1197 +1193 @@
         s->idleSecs = -1;
 
-    s->corruptEver     = tor->corruptCur    + tor->corruptPrev;
-    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;
-
-    if( usableSeeds > 0 )
-    {
-        s->desiredAvailable = s->leftUntilDone;
-    }
-    else if( !s->leftUntilDone || !s->peersConnected )
-    {
-        s->desiredAvailable = 0;
-    }
-    else
-    {
-        tr_piece_index_t i;
-        tr_bitfield *    peerPieces = tr_peerMgrGetAvailable( tor );
-        s->desiredAvailable = 0;
-        for( i = 0; i < tor->info.pieceCount; ++i )
-            if( !tor->info.pieces[i].dnd && tr_bitfieldHasFast( peerPieces, i ) )
-                s->desiredAvailable += tr_cpMissingBlocksInPiece( &tor->completion, i );
-        s->desiredAvailable *= tor->blockSize;
-        tr_bitfieldFree( peerPieces );
-    }
+    s->corruptEver      = tor->corruptCur    + tor->corruptPrev;
+    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->desiredAvailable = tr_peerMgrGetDesiredAvailable( tor );
 
     s->ratio = tr_getRatio( s->uploadedEver,
@@ -1328 +1305 @@
             /* the middle blocks */
             if( first + 1 < last ) {
-                uint64_t u = tr_bitsetCountRange( tr_cpBlockBitset( &tor->completion ), first+1, last );
+                uint64_t u = tr_bitfieldCountRange( &tor->completion.blockBitfield, first+1, last );
                 u *= tor->blockSize;
                 total += u;

trunk/libtransmission/utils-test.c

@@ -56 +56 @@
     int count2;
     const int bitCount = 100 + tr_cryptoWeakRandInt( 1000 );
-    tr_bitfield * bf;
+    tr_bitfield bf;
 
     /* generate a random bitfield */
-    bf = tr_bitfieldNew( bitCount );
+    tr_bitfieldConstruct( &bf, bitCount );
     for( i=0, n=tr_cryptoWeakRandInt(bitCount); i<n; ++i )
-        tr_bitfieldAdd( bf, tr_cryptoWeakRandInt(bitCount) );
+        tr_bitfieldAdd( &bf, tr_cryptoWeakRandInt(bitCount) );
 
     begin = tr_cryptoWeakRandInt( bitCount );
@@ -75 +75 @@
     count1 = 0;
     for( i=begin; i<end; ++i )
-        if( tr_bitfieldHas( bf, i ) )
+        if( tr_bitfieldHas( &bf, i ) )
             ++count1;
-    count2 = tr_bitfieldCountRange( bf, begin, end );
+    count2 = tr_bitfieldCountRange( &bf, begin, end );
     check( count1 == count2 );
 
-    tr_bitfieldFree( bf );
+    tr_bitfieldDestruct( &bf );
     return 0;
 }
@@ -88 +88 @@
 {
     unsigned int  i;
-    unsigned int  bitcount = 5000000;
-    tr_bitfield * field = tr_bitfieldNew( bitcount );
+    unsigned int  bitcount = 500;
+    tr_bitfield field;
+
+    tr_bitfieldConstruct( &field, bitcount );
 
     /* test tr_bitfieldAdd */
     for( i = 0; i < bitcount; ++i )
         if( !( i % 7 ) )
-            tr_bitfieldAdd( field, i );
+            tr_bitfieldAdd( &field, i );
     for( i = 0; i < bitcount; ++i )
-        check( tr_bitfieldHas( field, i ) == ( !( i % 7 ) ) );
+        check( tr_bitfieldHas( &field, i ) == ( !( i % 7 ) ) );
 
     /* test tr_bitfieldAddRange */
-    tr_bitfieldAddRange( field, 0, bitcount );
+    tr_bitfieldAddRange( &field, 0, bitcount );
     for( i = 0; i < bitcount; ++i )
-        check( tr_bitfieldHas( field, i ) );
+        check( tr_bitfieldHas( &field, i ) );
 
     /* test tr_bitfieldRemRange in the middle of a boundary */
-    tr_bitfieldRemRange( field, 4, 21 );
+    tr_bitfieldRemRange( &field, 4, 21 );
     for( i = 0; i < 64; ++i )
-        check( tr_bitfieldHas( field, i ) == ( ( i < 4 ) || ( i >= 21 ) ) );
+        check( tr_bitfieldHas( &field, i ) == ( ( i < 4 ) || ( i >= 21 ) ) );
 
     /* test tr_bitfieldRemRange on the boundaries */
-    tr_bitfieldAddRange( field, 0, 64 );
-    tr_bitfieldRemRange( field, 8, 24 );
+    tr_bitfieldAddRange( &field, 0, 64 );
+    tr_bitfieldRemRange( &field, 8, 24 );
     for( i = 0; i < 64; ++i )
-        check( tr_bitfieldHas( field, i ) == ( ( i < 8 ) || ( i >= 24 ) ) );
+        check( tr_bitfieldHas( &field, i ) == ( ( i < 8 ) || ( i >= 24 ) ) );
 
     /* test tr_bitfieldRemRange when begin & end is on the same word */
-    tr_bitfieldAddRange( field, 0, 64 );
-    tr_bitfieldRemRange( field, 4, 5 );
+    tr_bitfieldAddRange( &field, 0, 64 );
+    tr_bitfieldRemRange( &field, 4, 5 );
     for( i = 0; i < 64; ++i )
-        check( tr_bitfieldHas( field, i ) == ( ( i < 4 ) || ( i >= 5 ) ) );
+        check( tr_bitfieldHas( &field, i ) == ( ( i < 4 ) || ( i >= 5 ) ) );
 
     /* test tr_bitfieldAddRange */
-    tr_bitfieldRemRange( field, 0, 64 );
-    tr_bitfieldAddRange( field, 4, 21 );
+    tr_bitfieldRemRange( &field, 0, 64 );
+    tr_bitfieldAddRange( &field, 4, 21 );
     for( i = 0; i < 64; ++i )
-        check( tr_bitfieldHas( field, i ) == ( ( 4 <= i ) && ( i < 21 ) ) );
+        check( tr_bitfieldHas( &field, i ) == ( ( 4 <= i ) && ( i < 21 ) ) );
 
     /* test tr_bitfieldAddRange on the boundaries */
-    tr_bitfieldRemRange( field, 0, 64 );
-    tr_bitfieldAddRange( field, 8, 24 );
+    tr_bitfieldRemRange( &field, 0, 64 );
+    tr_bitfieldAddRange( &field, 8, 24 );
     for( i = 0; i < 64; ++i )
-        check( tr_bitfieldHas( field, i ) == ( ( 8 <= i ) && ( i < 24 ) ) );
+        check( tr_bitfieldHas( &field, i ) == ( ( 8 <= i ) && ( i < 24 ) ) );
 
     /* test tr_bitfieldAddRange when begin & end is on the same word */
-    tr_bitfieldRemRange( field, 0, 64 );
-    tr_bitfieldAddRange( field, 4, 5 );
+    tr_bitfieldRemRange( &field, 0, 64 );
+    tr_bitfieldAddRange( &field, 4, 5 );
     for( i = 0; i < 64; ++i )
-        check( tr_bitfieldHas( field, i ) == ( ( 4 <= i ) && ( i < 5 ) ) );
-
-    tr_bitfieldFree( field );
+        check( tr_bitfieldHas( &field, i ) == ( ( 4 <= i ) && ( i < 5 ) ) );
+
+    tr_bitfieldDestruct( &field );
     return 0;
 }
@@ -514 +516 @@
 
     /* bitfield count range */
-    for( l=0; l<1000000; ++l )
+    for( l=0; l<10000; ++l )
         if(( i = test_bitfield_count_range( )))
             return i;

trunk/libtransmission/webseed.c

@@ -338 +338 @@
     peer->clientIsInterested = !tr_torrentIsSeed( tor );
     peer->client = tr_strdup( "webseed" );
-    tr_bitsetSetHaveAll( &peer->have );
+    tr_bitfieldSetHasAll( &peer->have );
     tr_peerUpdateProgress( tor, peer );