Ticket #2352: libdispatch.diff

PiecesView.h

@@ -29 +29 @@
 @interface PiecesView : NSImageView
 {
     int8_t  * fPieces;
+        
+        float   * fPrevPiecesPercent;
     
     NSImage * fBack;
-    NSColor * fGreenAvailabilityColor, * fBluePieceColor;
+    NSColor * fGreenAvailabilityColor, * fBluePieceColor, * fPercentProgressColor0, * fPercentProgressColor1;
     
     Torrent * fTorrent;
     NSInteger fNumPieces, fAcross, fWidth, fExtraBorder;
+                
+        BOOL prevShowAvailability;
+        
+        float interval;
+        int   lastRowColCount;
+        
+        BOOL useGCD;
 }
 
 - (void) setTorrent: (Torrent *) torrent;
@@ -42 +51 @@
 - (void) clearView;
 - (void) updateView;
 
+- (void) determineColorsForRow: (NSInteger) row 
+                                  withColCount: (NSInteger) colCount 
+                                        withPieces: (int8_t *)pieces
+                         withPiecesPercent: (float *) piecesPercent
+                                        imageWidth: (CGFloat) imageWidth
+                          showAvailability: (BOOL) showAvailablity
+                                          firstRun: (BOOL) first
+                                  allFillRects: (NSRect   *) allFillRects
+                                 allFillColors: (NSColor **) allFillColors
+                                 allUsedCounts: (int      *) allUsedCounts;
+
+
+
 @end
+
+// A couple of straight C functions
+void calculatePiecesPercentInterval(int row, int rowCount, int lastRowColCount, int stride, float interval, float* unsampledPiecesPercent, float* piecesPercent);
+void calculatePiecesInterval(int row, int rowCount, int lastRowColCount, int stride, float interval, int8_t* unsampledPieces, int8_t* pieces);
+

PiecesView.m

@@ -22 +22 @@
  * DEALINGS IN THE SOFTWARE.
  *****************************************************************************/
 
+#import "NSApplicationAdditions.h"
+
 #import "PiecesView.h"
 #import "Torrent.h"
 #import "InfoWindowController.h"
@@ -36 +38 @@
 #define PIECE_SOME 1
 #define PIECE_HIGH_PEERS 2
 #define PIECE_FINISHED 3
-#define PIECE_FLASHING 4
+#define PIECE_FLASHING_COMPLETE 4
+#define PIECE_FLASHING_PROGRESS_0 5
+#define PIECE_FLASHING_PROGRESS_1 6
 
+#define USE_GCD
+
+
 @implementation PiecesView
 
 - (void) awakeFromNib
@@ -51 +58 @@
     [gradient drawInRect: [self bounds] angle: 90.0f];
     [gradient release];
     [fBack unlockFocus];
-    
+        
     //store box colors
     fGreenAvailabilityColor = [[NSColor colorWithCalibratedRed: 0.0f green: 1.0f blue: 0.4f alpha: 1.0f] retain];
     fBluePieceColor = [[NSColor colorWithCalibratedRed: 0.0f green: 0.4f blue: 0.8f alpha: 1.0f] retain];
-            
+                
+    //store box colors for the yellow flash on progress
+        fPercentProgressColor0 = [[NSColor colorWithCalibratedRed: 0.900f green: 0.900f blue: 0.165f alpha: 1.0f] retain];
+        fPercentProgressColor1 = [[NSColor colorWithCalibratedRed: 0.925f green: 0.925f blue: 0.171f alpha: 1.0f] retain];      
+
+        // Use Grand Central Dispatch (libdispatch) for some loops
+        // useGCD      = [NSApp isOnSnowLeopardOrBetter] ;   // Only use GCD on Snow Leopard
+                
     //actually draw the box
     [self setTorrent: nil];
 }
@@ -63 +77 @@
 - (void) dealloc
 {
     tr_free(fPieces);
-    
+        tr_free(fPrevPiecesPercent);
+        
     [fBack release];
     
     [fGreenAvailabilityColor release];
     [fBluePieceColor release];
+    [fPercentProgressColor0 release];
+    [fPercentProgressColor1 release];
     
     [super dealloc];
 }
@@ -86 +103 @@
         CGFloat width = [self bounds].size.width;
         fWidth = (width - (fAcross + 1) * BETWEEN) / fAcross;
         fExtraBorder = (width - ((fWidth + BETWEEN) * fAcross + BETWEEN)) / 2;
+                
+                interval = (float)[fTorrent pieceCount] / fNumPieces;
+                
+                // Calculate number of columns in the last row of the grid. 
+                // This should cover cases with fewer than fAcross*fAcross pieces.
+                // In the normal case with many pieces, lastRowColCount 
+                // should be equal to fAcross. 
+                lastRowColCount = fNumPieces % fAcross > 0 ? fNumPieces % fAcross : fAcross;
     }
     
     //reset the view to blank
@@ -99 +124 @@
 - (void) clearView
 {
     tr_free(fPieces);
+        tr_free(fPrevPiecesPercent);
+        
     fPieces = NULL;
+        fPrevPiecesPercent = NULL;
 }
 
 - (void) updateView
 {
     if (!fTorrent)
         return;
+                    
+    int8_t * pieces = NULL, * unsampledPieces = NULL;
+    float * piecesPercent = NULL, * unsampledPiecesPercent = NULL;
+        
+        // For parallelization of the drawing algorithm
+        NSRect   * allFillRects = tr_malloc([fTorrent pieceCount] * sizeof(NSRect));    
+        NSColor ** allFillColors = tr_malloc([fTorrent pieceCount] * sizeof(NSColor *));
+        int      * allUsedCounts = tr_malloc(fAcross * sizeof(int) );
+                    
+    BOOL showAvailablity = [[NSUserDefaults standardUserDefaults] boolForKey: @"PiecesViewShowAvailability"];
+                
+        if (showAvailablity)
+    {   
+                unsampledPieces = (int8_t *)tr_malloc([fTorrent pieceCount] * sizeof(int8_t));
+                pieces = (int8_t *)tr_malloc(fNumPieces * sizeof(int8_t));
+                [fTorrent getAvailability: unsampledPieces size: [fTorrent pieceCount]];
+
+#ifdef USE_GCD
+                dispatch_apply(fAcross, dispatch_get_global_queue(0, 0), ^(size_t row) {
+#else
+                for ( int row = 0; row < fAcross; ++row )                       
+#endif
+                        calculatePiecesInterval( row,  fAcross,  lastRowColCount,  fAcross,  interval, unsampledPieces, pieces);
+#ifdef USE_GCD
+                });
+#endif
+                
+                /*
+                if ( useGCD ) {
+                        dispatch_apply(fAcross, dispatch_get_global_queue(0, 0), ^(size_t row) {
+                                calculatePiecesInterval( row,  fAcross,  lastRowColCount,  fAcross,  interval, unsampledPieces, pieces);
+                        });
+                }
+                else {
+                        for ( int row = 0; row < fAcross; ++row ) 
+                                calculatePiecesInterval( row,  fAcross,  lastRowColCount,  fAcross,  interval, unsampledPieces, pieces);
+                }
+                 */
+    }
+    else
+    {   
+                unsampledPiecesPercent = (float *)tr_malloc([fTorrent pieceCount] * sizeof(float));
+                piecesPercent = (float *)tr_malloc(fNumPieces * sizeof(float));
+                [fTorrent getAmountFinished: unsampledPiecesPercent size: [fTorrent pieceCount]];
+                
+#ifdef USE_GCD
+                dispatch_apply(fAcross, dispatch_get_global_queue(0, 0), ^(size_t row) {
+#else
+                for ( int row = 0; row < fAcross; ++row )                       
+#endif
+                        calculatePiecesPercentInterval( row,  fAcross,  lastRowColCount,  fAcross,  interval, unsampledPiecesPercent, piecesPercent);
+#ifdef USE_GCD
+                });
+#endif
+                
+                /*
+                if ( useGCD ) {
+                        dispatch_apply(fAcross, dispatch_get_global_queue(0, 0), ^(size_t row) {
+                                calculatePiecesPercentInterval( row,  fAcross,  lastRowColCount,  fAcross,  interval, unsampledPiecesPercent, piecesPercent);
+                        });
+                }
+                else {
+                        for ( int row = 0; row < fAcross; ++row ) 
+                                calculatePiecesPercentInterval( row,  fAcross,  lastRowColCount,  fAcross,  interval, unsampledPiecesPercent, piecesPercent);
+                }
+                 */
+        }
     
     //determine if first time
     const BOOL first = fPieces == NULL;
-    if (first)
+    if (first) {
         fPieces = (int8_t *)tr_malloc(fNumPieces * sizeof(int8_t));
+                fPrevPiecesPercent = (float *)tr_malloc(fNumPieces * sizeof(float));
+        }
 
-    int8_t * pieces = NULL;
-    float * piecesPercent = NULL;
+        if ( first || !showAvailablity && prevShowAvailability  ) {
+                // First run after switching view from availability to progress
+                // (or first run altogether) so previous pieces are set to 200%
+                // to avoid a huge flash of yellow.
+                for ( int i = 0; i < fNumPieces; i++ ) {
+                        fPrevPiecesPercent[i] = 2.0f;
+                }
+        }
+        
+    NSImage * image = [self image];
+        
+        for (NSInteger i = 0; i < fAcross; i++)
+                 allUsedCounts[i] = 0;
     
-    const BOOL showAvailablity = [[NSUserDefaults standardUserDefaults] boolForKey: @"PiecesViewShowAvailability"];
-    if (showAvailablity)
-    {   
-        pieces = (int8_t *)tr_malloc(fNumPieces * sizeof(int8_t));
-        [fTorrent getAvailability: pieces size: fNumPieces];
+#ifdef USE_GCD
+        dispatch_apply(fAcross, dispatch_get_global_queue(0, 0), ^(size_t i) {
+#else
+        for (NSInteger i = 0; i < fAcross; i++)
+#endif
+                [self determineColorsForRow: i 
+                                           withColCount: fAcross
+                                                 withPieces: pieces
+                                  withPiecesPercent:  piecesPercent
+                                                 imageWidth:  [image size].width
+                                   showAvailability:  showAvailablity
+                                                   firstRun:  first
+                                           allFillRects:  allFillRects
+                                          allFillColors:  allFillColors
+                                          allUsedCounts:  allUsedCounts
+                 ];
+#ifdef USE_GCD
+        });
+#endif
+        
+                
+        /*
+        if ( useGCD ) {
+                dispatch_apply(fAcross, dispatch_get_global_queue(0, 0), ^(size_t i) {
+                        [self determineColorsForRow: i 
+                                                   withColCount: fAcross
+                                                         withPieces: pieces
+                                          withPiecesPercent:  piecesPercent
+                                                         imageWidth:  [image size].width
+                                           showAvailability:  showAvailablity
+                                                           firstRun:  first
+                                                   allFillRects:  allFillRects
+                                                  allFillColors:  allFillColors
+                                                  allUsedCounts:  allUsedCounts
+                         ];
+                });
+        }
+        else {
+                for (NSInteger i = 0; i < fAcross; i++)
+                        [self determineColorsForRow: i 
+                                                   withColCount: fAcross
+                                                         withPieces: pieces
+                                          withPiecesPercent: piecesPercent
+                                                         imageWidth: [image size].width
+                                           showAvailability: showAvailablity
+                                                           firstRun: first
+                                                   allFillRects: allFillRects
+                                                  allFillColors: allFillColors
+                                                  allUsedCounts: allUsedCounts
+                         ];
     }
-    else
-    {   
-        piecesPercent = (float *)tr_malloc(fNumPieces * sizeof(float));
-        [fTorrent getAmountFinished: piecesPercent size: fNumPieces];
-    }
-    
-    NSImage * image = [self image];
-    
-    NSRect fillRects[fNumPieces];
-    NSColor * fillColors[fNumPieces];
-    
-    NSInteger index = -1, usedCount = 0;
-    
+        */
+        
+        BOOL changed = FALSE;
     for (NSInteger i = 0; i < fAcross; i++)
-        for (NSInteger j = 0; j < fAcross; j++)
-        {
-            index++;
-            if (index >= fNumPieces)
-            {
-                i = fAcross;
-                break;
-            }
-            
-            NSColor * pieceColor = nil;
-            
-            if (showAvailablity ? pieces[index] == -1 : piecesPercent[index] == 1.0)
-            {
-                if (first || fPieces[index] != PIECE_FINISHED)
-                {
-                    if (!first && fPieces[index] != PIECE_FLASHING)
-                    {
-                        pieceColor = [NSColor orangeColor];
-                        fPieces[index] = PIECE_FLASHING;
-                    }
-                    else
-                    {
-                        pieceColor = fBluePieceColor;
-                        fPieces[index] = PIECE_FINISHED;
-                    }
-                }
-            }
-            else if (showAvailablity ? pieces[index] == 0 : piecesPercent[index] == 0.0)
-            {
-                if (first || fPieces[index] != PIECE_NONE)
-                {
-                    pieceColor = [NSColor whiteColor];
-                    fPieces[index] = PIECE_NONE;
-                }
-            }
-            else if (showAvailablity && pieces[index] >= HIGH_PEERS)
-            {
-                if (first || fPieces[index] != PIECE_HIGH_PEERS)
-                {
-                    pieceColor = fGreenAvailabilityColor;
-                    fPieces[index] = PIECE_HIGH_PEERS;
-                }
-            }
-            else
-            {
-                //always redraw "mixed"
-                CGFloat percent = showAvailablity ? (CGFloat)pieces[index]/HIGH_PEERS : piecesPercent[index];
-                NSColor * fullColor = showAvailablity ? fGreenAvailabilityColor : fBluePieceColor;
-                pieceColor = [[NSColor whiteColor] blendedColorWithFraction: percent ofColor: fullColor];
-                fPieces[index] = PIECE_SOME;
-            }
-            
-            if (pieceColor)
-            {
-                fillRects[usedCount] = NSMakeRect(j * (fWidth + BETWEEN) + BETWEEN + fExtraBorder,
-                                                    [image size].width - (i + 1) * (fWidth + BETWEEN) - fExtraBorder,
-                                                    fWidth, fWidth);
-                fillColors[usedCount] = pieceColor;
-                
-                usedCount++;
-            }
-        }
-    
-    if (usedCount > 0)
-    {
-        [image lockFocus];
-        NSRectFillListWithColors(fillRects, fillColors, usedCount);
-        [image unlockFocus];
-        [self setNeedsDisplay];
-    }
-    
+                        changed |= allUsedCounts[i] > 0;
+        
+        if (changed) {
+                [image lockFocus];
+                for (NSInteger i = 0; i < fAcross; i++)
+                {
+                        NSRectFillListWithColors( &(allFillRects[i * fAcross]), &(allFillColors[i * fAcross]), allUsedCounts[i]);
+                        for (int j = 0; j < allUsedCounts[i]; j++) 
+                                [allFillColors[i * fAcross + j] release];
+                }
+                [image unlockFocus];
+                [self setNeedsDisplay];
+        }
+        
+        if ( !showAvailablity ) {
+                memcpy(fPrevPiecesPercent,  piecesPercent, fNumPieces * sizeof(float));
+        }
+
     tr_free(pieces);
     tr_free(piecesPercent);
+        tr_free(unsampledPieces);
+        tr_free(unsampledPiecesPercent);
+        
+        tr_free(allFillRects);  
+        tr_free(allFillColors); 
+        tr_free(allUsedCounts); 
+        
+        prevShowAvailability = showAvailablity;
 }
 
+
+- (void) determineColorsForRow: (NSInteger) row 
+                                  withColCount: (NSInteger) colCount 
+                                        withPieces: (int8_t *)pieces
+                         withPiecesPercent: (float *) piecesPercent
+                                        imageWidth: (CGFloat) imageWidth
+                          showAvailability: (BOOL) showAvailablity
+                                          firstRun: (BOOL) first
+                                  allFillRects: (NSRect   *) allFillRects
+                                 allFillColors: (NSColor **) allFillColors
+                                 allUsedCounts: (int      *) allUsedCounts
+{
+        int usedCount = 0;
+        
+        for (NSInteger j = 0; j < colCount; j++)
+        {
+                NSInteger index = row * colCount + j;
+                if (index >= fNumPieces)
+                {
+                        //i = fAcross;
+                        break;
+                }
+                
+                NSColor * pieceColor = nil;
+                
+                if (showAvailablity ? pieces[index] == -1 : piecesPercent[index] == 1.0)
+                {
+                        if (first || fPieces[index] != PIECE_FINISHED)
+                        {
+                                if (!first && fPieces[index] != PIECE_FLASHING_COMPLETE)
+                                {
+                                        pieceColor = [NSColor orangeColor];
+                                        fPieces[index] = PIECE_FLASHING_COMPLETE;
+                                }
+                                else
+                                {
+                                        pieceColor = fBluePieceColor;
+                                        fPieces[index] = PIECE_FINISHED;
+                                }
+                        }
+                }
+                else if (showAvailablity ? pieces[index] == 0 : piecesPercent[index] == 0.0)
+                {
+                        if (first || fPieces[index] != PIECE_NONE)
+                        {
+                                pieceColor = [NSColor whiteColor];
+                                fPieces[index] = PIECE_NONE;
+                        }
+                }
+                else if ( !showAvailablity && ( piecesPercent[index] > fPrevPiecesPercent[index] ) )
+                {               
+                        // There is progress compared to the previous run - show it!
+                        if ( fPieces[index] == PIECE_FLASHING_PROGRESS_1 ) {
+                                pieceColor = fPercentProgressColor0;
+                                fPieces[index] = PIECE_FLASHING_PROGRESS_0;
+                        }
+                        else {
+                                pieceColor = fPercentProgressColor1;
+                                fPieces[index] = PIECE_FLASHING_PROGRESS_1;
+                        }                               
+                }
+                else if (showAvailablity && pieces[index] >= HIGH_PEERS)
+                {
+                        if (first || fPieces[index] != PIECE_HIGH_PEERS)
+                        {
+                                pieceColor = fGreenAvailabilityColor;
+                                fPieces[index] = PIECE_HIGH_PEERS;
+                        }
+                }
+                else
+                {
+                        //always redraw "mixed"
+                        CGFloat percent = showAvailablity ? (CGFloat)pieces[index]/HIGH_PEERS : piecesPercent[index];
+                        NSColor * fullColor = showAvailablity ? fGreenAvailabilityColor : fBluePieceColor;
+                        pieceColor = [[NSColor whiteColor] blendedColorWithFraction: percent ofColor: fullColor];
+                        fPieces[index] = PIECE_SOME;
+                }
+                
+                
+                if (pieceColor)
+                {
+                        allFillRects[ row * colCount + usedCount] = NSMakeRect(j * (fWidth + BETWEEN) + BETWEEN + fExtraBorder,
+                                                                                          imageWidth - (row + 1) * (fWidth + BETWEEN) - fExtraBorder,
+                                                                                          fWidth, fWidth);
+                        [pieceColor retain];
+                        allFillColors[row * colCount + usedCount] = pieceColor;
+                        
+                        usedCount++;
+                        allUsedCounts[row] = usedCount;                         
+                }
+        }
+}
+
+void calculatePiecesPercentInterval(int row, int rowCount, int lastRowColCount, int stride, float interval, float* unsampledPiecesPercent, float* piecesPercent)
+{
+        int colCount = row == rowCount - 1 ? lastRowColCount : stride;
+        
+        for( int col = 0; col < colCount; ++col )
+        {
+                int i = row * stride + col;
+                
+                int first_piece = i * interval;
+                
+                // Last piece of last interval is also the last piece of the torrent
+                int last_piece =  ( i + 1 ) * interval;
+                
+                float lower_piece_fract = 1.0f - ((float)i * interval - first_piece );
+                float upper_piece_fract = ((float)(i + 1) * interval -  last_piece );
+                
+                if ( upper_piece_fract == 0.0f ) {
+                        last_piece--;
+                        upper_piece_fract = 1.0f;
+                }
+                
+                float sum = 0.0f, avg;
+                
+                // The flag complete is used to keep track of the interval. If
+                // all pieces in the interval are complete, the downsampled
+                // value is set to exactly 1.0f to avoid rounding errors.
+                BOOL complete = TRUE;
+                
+                if ( first_piece == last_piece ) {
+                        avg =  unsampledPiecesPercent[first_piece];
+                        complete = ( avg == 1.0f );
+                }
+                else {
+                        if ( unsampledPiecesPercent[first_piece] != 1.0f ) {
+                                sum += unsampledPiecesPercent[first_piece] * lower_piece_fract;
+                                complete = FALSE;
+                        }
+                        else {
+                                sum += lower_piece_fract;
+                        }
+                        
+                        if ( unsampledPiecesPercent[last_piece] != 1.0f ) {                             
+                                sum += unsampledPiecesPercent[last_piece] * upper_piece_fract;
+                                complete = FALSE;
+                        }
+                        else {
+                                sum += upper_piece_fract;
+                        }
+                        
+                        int j;
+                        for ( j = first_piece + 1; j < last_piece; j++ ) {
+                                if ( unsampledPiecesPercent[j] != 1.0f ) {
+                                        sum += unsampledPiecesPercent[j];
+                                        complete = FALSE;
+                                }
+                                else {
+                                        sum += 1.0f;
+                                }
+                        }
+                        
+                        avg = sum / interval;
+                }
+                
+                piecesPercent[i] = complete ? 1.0f : avg;
+        }
+}
+
+void calculatePiecesInterval(int row, int rowCount, int lastRowColCount, int stride, float interval, int8_t* unsampledPieces, int8_t* pieces)
+{               
+        int colCount = row == rowCount - 1 ? lastRowColCount : stride;
+        
+        for( int col = 0; col < colCount; ++col )
+        {
+                int i = row * stride + col;
+                
+                int first_piece = i * interval;
+                int last_piece =  ( i + 1 ) * interval;
+                
+                float lower_piece_fract = 1.0f - ((float)i * interval - first_piece );
+                float upper_piece_fract = ((float)(i + 1) * interval -  last_piece );
+                
+                if ( upper_piece_fract == 0.0f ) {
+                        last_piece--;
+                        upper_piece_fract = 1.0f;
+                }
+                
+                int   pieceCount;
+                
+                float sum = 0.0f, result;
+                
+                if ( first_piece == last_piece ) {
+                        if ( unsampledPieces[first_piece] != -1 ) {
+                                result = (pieceCount = unsampledPieces[first_piece]);
+                        }
+                        else {
+                                result = -1;
+                        }
+                }
+                else {
+                        float incompleteCount = 0.0f;
+                        
+                        if ( unsampledPieces[first_piece] != -1 ) 
+                        {       
+                                sum += (pieceCount = unsampledPieces[first_piece]) * lower_piece_fract;
+                                incompleteCount += lower_piece_fract;
+                        }
+                        
+                        if ( unsampledPieces[last_piece] != -1 ) 
+                        {       
+                                sum += (pieceCount = unsampledPieces[last_piece]) * upper_piece_fract;
+                                incompleteCount += upper_piece_fract;
+                        }
+                        
+                        for ( int j = first_piece + 1; j < last_piece; j++ ) {
+                                if ( unsampledPieces[j] != -1 ) 
+                                {       
+                                        sum += (pieceCount = unsampledPieces[j]);
+                                        incompleteCount += 1.0f;
+                                }
+                        }
+                        
+                        if ( incompleteCount > 0 ) {
+                                result = sum / incompleteCount;
+                        }
+                        else {
+                                result = -1;
+                        }
+                }
+                
+                pieces[i] = (int)result;
+    }
+}
+
+
 - (BOOL) acceptsFirstMouse: (NSEvent *) event
 {
     return YES;